# RiveScript-Python # # This code is released under the MIT License. # See the "LICENSE" file for more information. # # https://www.rivescript.com/ from __future__ import print_function, unicode_literals import argparse import json import re from six.moves import input from six import text_type, PY2 from rivescript import RiveScript def json_in(bot, buffer, stateful): # Prepare the response. resp = { 'status': 'ok', 'reply': '', 'vars': {} } # Decode the incoming JSON. try: incoming = json.loads(buffer) except Exception as e: resp['status'] = 'error' resp['reply'] = 'Failed to decode incoming JSON data.' resp['error'] = text_type(e) print(json.dumps(resp)) if stateful: print("__END__") return # Username? username = "json" if 'username' in incoming: username = incoming["username"] # Decode their variables. if "vars" in incoming: for var in incoming["vars"]: bot.set_uservar(username, var, incoming["vars"][var]) # Get a response. if 'message' in incoming: resp['reply'] = bot.reply(username, incoming["message"]) else: resp['reply'] = "[ERR: No message provided]" # Retrieve vars. resp['vars'] = bot.get_uservars(username) print(json.dumps(resp)) if stateful: print("__END__") def interactive_mode(): """The built-in RiveScript Interactive Mode. This feature of RiveScript allows you to test and debug a chatbot in your terminal window. There are two ways to invoke this mode:: # By running the Python RiveScript module directly: python rivescript eg/brain # By running the shell.py in the source distribution: python shell.py eg/brain The only required command line parameter is a filesystem path to a directory containing RiveScript source files (with the ``*.rive`` file extension). Additionally, it accepts command line flags. Parameters: --utf8: Enable UTF-8 mode. --json: Use JSON to communicate with the bot instead of plain text. See the JSON Mode documentation below for advanced details. --debug: Enable verbose debug logging. --log (str): The path to a text file you want the debug logging to be written to. This is to be used in conjunction with ``--debug``, for the case where you don't want your terminal window to be flooded with debug messages. --depth (int): Override the recursion depth limit (default ``50``). --nostrict: Disable strict syntax checking when parsing the RiveScript files. By default a syntax error raises an exception and will terminate the interactive mode. --help: Show the documentation of command line flags. path (str): The path to a directory containing ``.rive`` files. **JSON Mode** By invoking the interactive mode with the ``--json`` (or ``-j``) flag, the interactive mode will communicate with you via JSON messages. This can be used as a "bridge" to enable the use of RiveScript from another programming language that doesn't have its own native RiveScript implementation. For example, a program could open a shell pipe to the RiveScript interactive mode and send/receive JSON payloads to communicate with the bot. In JSON mode, you send a message to the bot in the following format:: { "username": "str username", "message": "str message", "vars": { "topic": "random", "name": "Alice" } } The ``username`` and ``message`` keys are required, and ``vars`` is a key/value object of all the variables about the user. After sending the JSON payload over standard input, you can either close the input file handle (send the EOF signal; or Ctrl-D in a terminal), or send the string ``__END__`` on a line of text by itself. This will cause the bot to parse your payload, get a reply for the message, and respond with a similar JSON payload:: { "status": "ok", "reply": "str response", "vars": { "topic": "random", "name": "Alice" } } The ``vars`` structure in the response contains all of the key/value pairs the bot knows about the username you passed in. This will also contain a lot of internal data, such as the user's history and last matched trigger. To keep a stateful session, you should parse the ``vars`` returned by RiveScript and pass them in with your next request so that the bot can remember them for the next reply. If you closed the filehandle (Ctrl-D, EOF) after your input payload, the interactive mode will exit after giving the response. If, on the other hand, you sent the string ``__END__`` on a line by itself after your payload, the RiveScript interactive mode will do the same after its response is returned. This way, you can re-use the shell pipe to send and receive many messages over a single session. """ parser = argparse.ArgumentParser(description="RiveScript interactive mode.") parser.add_argument("--debug", "-d", help="Enable debug logging within RiveScript.", action="store_true", ) parser.add_argument("--json", "-j", help="Enable JSON mode. In this mode, you communicate with the bot by " "sending a JSON-encoded object with keys 'username', 'message' and " "'vars' (an object of user variables) over standard input, and " "then close the input (^D) or send the string '__END__' on a line " "by itself. The bot will respond with a similarly formatted JSON " "response over standard output, and then will either exit or send " "'__END__' depending on how you ended your input.", action="store_true", ) parser.add_argument("--utf8", "-u", help="Enable UTF-8 mode (default is disabled)", action="store_true", ) parser.add_argument("--log", help="The path to a log file to send debugging output to (when debug " "mode is enabled) instead of standard output.", type=text_type, ) parser.add_argument("--nostrict", help="Disable strict mode (where syntax errors are fatal)", action="store_true", ) parser.add_argument("--depth", help="Override the default recursion depth limit when fetching a reply " "(default 50)", type=int, default=50, ) parser.add_argument("path", help="A directory containing RiveScript files (*.rive) to load.", type=text_type, # required=True, ) args = parser.parse_args() # Make the bot. bot = RiveScript( debug=args.debug, strict=not args.nostrict, depth=args.depth, utf8=args.utf8, log=args.log ) bot.load_directory(args.path) bot.sort_replies() # Interactive mode? if args.json: # Read from standard input. buffer = "" stateful = False while True: line = "" try: line = input() except EOFError: break # Look for the __END__ line. end = re.match(r'^__END__$', line) if end: # Process it. stateful = True # This is a stateful session json_in(bot, buffer, stateful) buffer = "" continue else: buffer += line + "\n" # We got the EOF. If the session was stateful, just exit, # otherwise process what we just read. if stateful: quit() json_in(bot, buffer, stateful) quit() print( " . . \n" " .:...:: RiveScript Interpreter (Python)\n" " .:: ::. Library Version: v{version}\n" " ..:;;. ' .;;:.. \n" " . ''' . Type '/quit' to quit.\n" " :;,:,;: Type '/help' for more options.\n" " : : \n" "\n" "Using the RiveScript bot found in: {path}\n" "Type a message to the bot and press Return to send it.\n" .format(version=bot.VERSION(), path=args.path) ) while True: msg = input("You> ") if PY2: # For Python 2 only: cast the message to Unicode. msg = msg.decode("utf-8") # Commands if msg == '/help': print("> Supported Commands:") print("> /help - Displays this message.") print("> /quit - Exit the program.") elif msg == '/quit': exit() else: reply = bot.reply("localuser", msg) print("Bot>", reply)