class bot():
"""This is a bare minimal example for how to write your own RiveScript bot!
For a more full-fledged example, try running: `python rivescript brain`
This will run the built-in Interactive Mode of the RiveScript library. It has
some more advanced features like supporting JSON for communication with the
bot. See `python rivescript --help` for more info.
example.py is just a simple script that loads the RiveScript documents from
the 'brain/' folder, and lets you chat with the bot.
Type /quit when you're done to exit this example.
"""
def __init__(self):
self.currentOperation = None
self.rs = RiveScript()
self.rs.load_directory(os.path.dirname(__file__) + "/rep_src")
self.rs.sort_replies()
def sanitizeUserQuery(self, userQuery):
return userQuery
def identifyOperation(self, userQuery):
"""
function identifyOperation(string: userQuery)
Output: ([keywords_in_input], [action_in_input])
"""
userQuery = self.sanitizeUserQuery(userQuery)
queryTokens = nltk.word_tokenize(userQuery)
pos = nltk.pos_tag(queryTokens)
keywords = []
verbs = []
adjective = []
for w in pos:
if w[1] == 'NN' or w[1] == 'NNP':
keywords.append(str(w[0]))
if w[1] == 'VB' or w[1] == 'VBD' or w[1] == 'VBN':
verbs.append(w[0])
if w[1] == 'JJ':
adjective.append(w[0])
# print(str(keywords).rsplit() + " " + str(verbs).rsplit() + " " + str(adjective).rsplit())
return (keywords, verbs, adjective)
def reply(self, user, msg):
# t = self.identifyOperation(msg)
# print(' '.join(t[0] + t[1] + t[2]))
return self.rs.reply(user, msg)
def Agente(self):
self.agente = RiveScript()
self.agente.load_directory("./recursos")
self.agente.sort_replies()
self.lector = Dispatch("SAPI.SpVoice")
if time.localtime().tm_hour < 12:
self.agente.set_variable("time", "dia")
else:
if time.localtime().tm_hour < 18:
self.agente.set_variable("time", "tarde")
else:
self.agente.set_variable("time", "noche")
def reload_brain(self):
"""(Re)load the RiveScript brain for the bot."""
self.log.info("Loading RiveScript brain from {}".format(
self.c.personality.replies
))
self.rs = RiveScript(
debug=self.c.debug.rivescript,
utf8=True,
)
self.rs.load_directory(self.c.personality.replies)
self.rs.sort_replies()
class RiveScriptTestCase(unittest.TestCase):
"""Base class for all RiveScript test cases, with helper functions."""
def setUp(self, **kwargs):
self.rs = None # Local RiveScript bot object
self.username = "******"
def tearDown(self):
pass
def new(self, code, **kwargs):
"""Make a bot and stream in the code."""
self.rs = RiveScript(**kwargs)
self.extend(code)
def extend(self, code):
"""Stream code into the bot."""
self.rs.stream(code)
self.rs.sort_replies()
def reply(self, message, expected):
"""Test that the user's message gets the expected response."""
reply = self.rs.reply(self.username, message)
self.assertEqual(reply, expected)
def uservar(self, var, expected):
"""Test the value of a user variable."""
value = self.rs.get_uservar(self.username, var)
self.assertEqual(value, expected)
def bot_talk():
from rivescript import RiveScript
import sys, os
bot = RiveScript(utf8=True)
bot.load_directory("/home/mate/Downloads/web2py/applications/saria/static/riverscript/brain/")
#bot.load_directory("/home/relsi/Projetos/Web2py/pris/applications/saria/static/riverscript/brain")
bot.sort_replies()
msg = request.post_vars.chat_text
reply = bot.reply("localuser", msg.decode('utf-8'))
return reply
def __init__(self, script_dir, user, ss, debug=False):
self._user = user
self._redirect = None
# init RiveScript
self._rs = RiveScript(debug=debug)
self._rs.load_directory(script_dir)
self._rs.sort_replies()
# restore session
if isinstance(ss, SessionStore):
self._ss = ss
else:
raise RuntimeError("RiveBot init error: provided session store object is not a SessionStore instance.")
self._restore_session()
# register event callbacks
self._rs.on('topic', self._topic_cb)
self._rs.on('uservar', self._uservar_cb)
def __init__(self):
self.currentOperation = None
self.rs = RiveScript()
self.rs.load_directory(os.path.dirname(__file__) + "/rep_src")
self.rs.sort_replies()
from rivescript import RiveScript
import os.path
import re
bot = RiveScript(utf8=True)
bot.unicode_punctuation = re.compile(r'[.,!?;:]')
file = os.path.dirname(__file__)
data = os.path.join(file, 'data')
bot = RiveScript()
bot.load_directory(data)
bot.sort_replies()
print(
'You are now talking to Chatty. Type \"/q\" to end the conversation. Have fun!'
)
while True:
msg = input('You> ')
if msg == '/q':
print('Bot>', "Bye Bye")
quit()
reply = bot.reply("localuser", msg)
print('Bot>', reply)
import sys
import os
import json
from rivescript import RiveScript
bot = RiveScript(utf8=True)
bot.load_file(sys.argv[1])
bot.sort_replies()
deparsed = bot.deparse()
full_dump = {"sub_clause": [], "array_clauses": [], "include_clauses": [], "raw_rule_clauses": []}
for raw_rule_topic in deparsed["topic"].keys():
for raw_rule_key in deparsed["topic"][raw_rule_topic].keys():
raw_rule = {"topic": raw_rule_topic, "name": raw_rule_key, "reply": [], "condition": [], "previous": []}
if "reply" in deparsed["topic"][raw_rule_topic][raw_rule_key].keys():
for reply in deparsed["topic"][raw_rule_topic][raw_rule_key]["reply"]:
raw_rule["reply"].append(reply)
if "condition" in deparsed["topic"][raw_rule_topic][raw_rule_key].keys():
for reply in deparsed["topic"][raw_rule_topic][raw_rule_key]["condition"]:
raw_rule["condition"].append(reply)
if "previous" in deparsed["topic"][raw_rule_topic][raw_rule_key].keys():
raw_rule["previous"].append(deparsed["topic"][raw_rule_topic][raw_rule_key]["previous"])
full_dump["raw_rule_clauses"].append(raw_rule)
for raw_rule_topic in deparsed["that"].keys():
for raw_rule_key in deparsed["that"][raw_rule_topic].keys():
raw_rule = {"topic": raw_rule_topic, "name": raw_rule_key, "reply": [], "condition": [], "previous": []}
if "reply" in deparsed["that"][raw_rule_topic][raw_rule_key].keys():
for reply in deparsed["that"][raw_rule_topic][raw_rule_key]["reply"]:
raw_rule["reply"].append(reply)
if "condition" in deparsed["that"][raw_rule_topic][raw_rule_key].keys():
for reply in deparsed["that"][raw_rule_topic][raw_rule_key]["condition"]:
raw_rule["condition"].append(reply)
def interactive_mode():
# Get command line options.
options, remainder = [], []
try:
options, remainder = getopt.getopt(sys.argv[1:], 'dju', ['debug',
'json',
'utf8',
'log=',
'strict',
'nostrict',
'depth=',
'help'])
except:
print("Unrecognized options given, try " + sys.argv[0] + " --help")
exit()
# Handle the options.
debug, depth, strict = False, 50, True
with_json, help, log = False, False, None
utf8 = False
for opt in options:
if opt[0] == '--debug' or opt[0] == '-d':
debug = True
elif opt[0] == '--strict':
strict = True
elif opt[0] == '--nostrict':
strict = False
elif opt[0] == '--json':
with_json = True
elif opt[0] == '--utf8' or opt[0] == '-u':
utf8 = True
elif opt[0] == '--help' or opt[0] == '-h':
help = True
elif opt[0] == '--depth':
depth = int(opt[1])
elif opt[0] == '--log':
log = opt[1]
# Help?
if help:
print("""Usage: rivescript [options] <directory>
Options:
--debug, -d
Enable debug mode.
--log FILE
Log debug output to a file (instead of the console). Use this instead
of --debug.
--json, -j
Communicate using JSON. Useful for third party programs.
--strict, --nostrict
Enable or disable strict mode (enabled by default).
--depth=50
Set the recursion depth limit (default is 50).
--help
Display this help.
JSON Mode:
In JSON mode, input and output is done using JSON data structures. The
format for incoming JSON data is as follows:
{
'username': '******',
'message': 'Hello bot!',
'vars': {
'name': 'Aiden'
}
}
The format that would be expected from this script is:
{
'status': 'ok',
'reply': 'Hello, human!',
'vars': {
'name': 'Aiden'
}
}
If the calling program sends an EOF signal at the end of their JSON data,
this script will print its response and exit. To keep a session going,
send the string '__END__' on a line by itself at the end of your message.
The script will do the same after its response. The pipe can then be used
again for further interactions.""")
quit()
# Given a directory?
if len(remainder) == 0:
print("Usage: rivescript [options] <directory>")
print("Try rivescript --help")
quit()
root = remainder[0]
# Make the bot.
bot = RiveScript(
debug=debug,
strict=strict,
depth=depth,
utf8=utf8,
log=log
)
bot.load_directory(root)
bot.sort_replies()
# Interactive mode?
if with_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("""RiveScript Interpreter (Python) -- Interactive Mode"
---------------------------------------------------"
rivescript version: %s
Reply Root: %s
You are now chatting with the RiveScript bot. Type a message and press Return"
to send it. When finished, type '/quit' to exit the program."
Type '/help' for other options."
""" % (str(bot.VERSION()), root))
while True:
msg = _input("You> ")
# 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)
#!/usr/bin/python3
# Python 3 example
from rivescript import RiveScript
rs = RiveScript()
rs.load_directory("./brain")
rs.sort_replies()
print("""This is a bare minimal example for how to write your own RiveScript bot!
For a more full-fledged example, try running: `python rivescript brain`
This will run the built-in Interactive Mode of the RiveScript library. It has
some more advanced features like supporting JSON for communication with the
bot. See `python rivescript --help` for more info.
example3.py is just a simple script that loads the RiveScript documents from
the 'brain/' folder, and lets you chat with the bot.
Type /quit when you're done to exit this example.
""")
while True:
msg = input("You> ")
if msg == '/quit':
quit()
reply = rs.reply("localuser", msg)
print("Bot>", reply)
# vim:expandtab
# I.R.I.S.
# br4in
########## Imports #########
from rivescript import RiveScript
import time
from os import system
from speech_rec import get_command
from memory import read, write, get_reply
# Env variables
bot_name = 'AIris'
# Load RiveScript
rs = RiveScript()
rs.load_directory("./brain")
rs.sort_replies()
def say(reply):
output = system('say "{}" &'.format(reply))
def login():
log_name = raw_input('Username: '******'{}_>'.format(log_name))
class RiveBot(object):
"""An example RiveScript bot using callbacks to manage user session data.
This example assumes single user per RiveScript instance and as
such it's suitable for use in stateless services (e.g. in web apps
receiving webhooks). Just init, get reply and teardown. Of course,
it will also work in RTM implementations with custom longer-lived
bot threads.
Session state is persisted to a single JSON file. This wouldn't be
thread-safe in a concurrent environment (e.g. web server). In such
case it would be recommended to subclass SessionStore and implement
database persistence (preferably via one of great Python ORMs such
as SQLAlchemy or peewee).
"""
def __init__(self, script_dir, user, ss, debug=False):
self._user = user
self._redirect = None
# init RiveScript
self._rs = RiveScript(debug=debug)
self._rs.load_directory(script_dir)
self._rs.sort_replies()
# restore session
if isinstance(ss, SessionStore):
self._ss = ss
else:
raise RuntimeError("RiveBot init error: provided session store object is not a SessionStore instance.")
self._restore_session()
# register event callbacks
self._rs.on('topic', self._topic_cb)
self._rs.on('uservar', self._uservar_cb)
def _topic_cb(self, user, topic, redirect=None):
"""Topic callback.
This is a single-user-per-rive (stateless instance) scenario; in a multi-user
scenario within a single thread, callback functions should delegate the
execution to proper user session objects.
"""
log.debug("Topic callback: user={}, topic={}, redirect={}".format(user, topic, redirect))
self._session.set_topic(topic, redirect)
def _uservar_cb(self, user, name, value):
"""Topic callback. See comment for `_topic_cb()`"""
log.debug("User variable callback: user={}, name={}, value={}".format(user, name, value))
self._session.set_variable(name, value)
def _restore_session(self):
self._session = self._ss.load(self._user)
# set saved user variables
for name, value in self._session.variables():
self._rs.set_uservar(self._user, name, value)
# set saved topic
topic = self._session.get_topic()
if topic:
if '/' in topic:
topic, self._redirect = topic.split('/')
self._rs.set_topic(self._user, topic)
def _save_session(self):
self._ss.save(self._session)
def run(self):
log.info("RiveBot starting...")
if self._redirect:
# Repeat saved redirect so that the user gets the context
# after session restart.
redir_reply = self._rs.redirect(self._user, self._redirect)
print("bot> Welcome back!")
print("bot>", redir_reply)
while True:
msg = raw_input("{}> ".format(self._user))
if msg == '/quit':
self.stop()
break
reply = self._rs.reply(self._user, msg)
print("bot>", reply)
def stop(self):
log.info("RiveBot shutting down...")
print("\nbot> Bye.")
self._save_session()
from rivescript import RiveScript
bot = RiveScript(utf8=True)
bot.load_directory("./Body")
bot.sort_replies()
def reply(text: str) -> str:
res = bot.reply("localuser", text)
return res if res != "[ERR: No Reply Matched]" else ""
if __name__ == "__main__":
while True:
print(reply(input()))
from flask import Flask, render_template, jsonify, request, Response
from rivescript import RiveScript
import pymongo
from pymongo import MongoClient
import json
from bson import json_util
cluster = MongoClient("mongodb+srv://Omar:[email protected]/Callcenter?retryWrites=true&w=majority")
db = cluster["callcenter1"]
collection = db["food orders"]
app = Flask(__name__, template_folder='templates')
# initialize RiveScript stuff
bot = RiveScript()
bot.load_directory(os.path.join(os.getcwd(), 'brain'))
bot.sort_replies()
# setup log file
file_handler = FileHandler('error_log.log')
file_handler.setLevel(logging.ERROR)
file_handler.setFormatter(
Formatter('%(asctime)s,%(msecs)d %(levelname)-5s [%(filename)s:%(lineno)d] %(message)s',
datefmt='%d-%m-%Y:%H:%M:%S'
)
)
app.logger.addHandler(file_handler)
@app.route('/')
def onMessage(self, messageProtocolEntity):
#send receipt otherwise we keep receiving the same message over and over
client = MongoClient()
db = client.data
if True:
rs=RiveScript()
rs.load_directory("./brain")
rs.sort_replies()
messageOut = ""
#print(messageProtocolEntity.getType() )
if messageProtocolEntity.getType() == "text":
#self.output(message.getBody(), tag = "%s [%s]"%(message.getFrom(), formattedDate))
"""
c = check()
para = messageProtocolEntity.getBody()
messageOut =c.func(para)
"""
messageOut = messageProtocolEntity.getBody()+' '
print(messageOut)
elif messageProtocolEntity.getType() == "media":
#self.getMediaMessageBody(messageProtocolEntity)
if self.onMediaMessage(messageProtocolEntity) == 1:
messageOut = "location code one "
elif self.onMediaMessage(messageProtocolEntity) == 2:
messageOut = "image code one "
elif self.onMediaMessage(messageProtocolEntity) == 3:
messageOut = "vcard recieved "
else:
messageOut = "location code zero "
else:
messageOut = "Unknown message type %s " % messageProtocolEntity.getType()
print(messageOut.toProtocolTreeNode())
messageOut=formstring(messageOut)
print(messageOut)
reply=rs.reply("localuser",messageOut)
receipt = OutgoingReceiptProtocolEntity(messageProtocolEntity.getId(), messageProtocolEntity.getFrom(), 'read', messageProtocolEntity.getParticipant())
result = db.session.find({"from":messageProtocolEntity.getFrom()})
if result.count() == 1:
stime= datetime.datetime.now().hour*60+datetime.datetime.now().minute
print(stime)
if stime<=result[0]['expiry']:
#Customer in citizen
r = db.session.find({"from":messageProtocolEntity.getFrom()})
qid = r[0]['qid']
if messageProtocolEntity.getType() == "text":
db.query.update({"_id":qid},{"$set":{"text":db.query.find({"_id":qid})[0]['text']+[messageProtocolEntity.getBody()]}})
elif messageProtocolEntity.getMediaType() == "image":
db.query.update({"_id":qid},{"$set":{"image":db.query.find({"_id":qid})[0]['image']+[messageProtocolEntity.url]}})
elif messageProtocolEntity.getMediaType() == "location":
db.query.update({"_id":qid},{"$set":{"location":db.query.find({"_id":qid})[0]['location']+[[messageProtocolEntity.getLatitude(), messageProtocolEntity.getLongitude()]]}})
elif messageProtocolEntity.getMediaType() == "vcard":
db.query.update({"_id":qid},{"$set":{"vcard":db.query.find({"_id":qid})[0]['vcard']+[messageProtocolEntity.getCardData()]}})
else:
db.query.update({"_id":qid},{"$set":{"text":db.query.find({"_id":qid})[0]['text']+[messageProtocolEntity.getBody()]}})
outgoingMessageProtocolEntity = TextMessageProtocolEntity(reply,
to = messageProtocolEntity.getFrom())
self.toLower(receipt)
self.toLower(outgoingMessageProtocolEntity)
else:
r = db.session.find({"from":messageProtocolEntity.getFrom()})
qid = r[0]['qid']
db.session.remove({"from":messageProtocolEntity.getFrom()})
outgoingMessageProtocolEntity = TextMessageProtocolEntity("Your complaint id:"+str(qid)+"\n\nYour session has been expired!!\nYou need to register again.",to = messageProtocolEntity.getFrom())
self.toLower(receipt)
self.toLower(outgoingMessageProtocolEntity)
else:
outgoingMessageProtocolEntity = TextMessageProtocolEntity("I need your location to register you",
to = messageProtocolEntity.getFrom())
self.toLower(receipt)
self.toLower(outgoingMessageProtocolEntity)
from threading import Thread
from rivescript import RiveScript
bot = RiveScript(utf8=True)
bot.load_directory("./brain")
bot.sort_replies()
class Conversation(Thread):
def __init__(self, chat):
self.thread = Thread.__init__(self)
self.daemon = True
self.chat = chat
def run(self, user, username, message):
user = "******".format(user=user)
line = ":%s PRIVMSG #jtv :/w %s %s" % (user, username, message)
reply = bot.reply(username, message)
if reply == "[ERR: No reply matched]":
return
return str(reply)
from config import Config
from rivescript import RiveScript
from bot_interface.bot_interface import BotInterface
from message_processor.message_processor import ExternalApiParser, MessageProcessor
from nyt_interface.nyt_interface import NytimesApi
from pymongo import MongoClient
config = ConfigParser.ConfigParser()
config.read("local_test_config.cfg")
bot = BotInterface(Config.FB_API_VERSION, config.get('SECRET', 'fb_access_token'))
nyt_api = NytimesApi(config.get('NYTIMES', 'nyt_key'))
rive = RiveScript()
rive.load_directory(
os.path.join(os.path.dirname(__file__), "..", "rivescripts")
)
rive.sort_replies()
mongo = MongoClient()
mongo = mongo.app
external_api_parser = ExternalApiParser(config.get('WITAI', 'wit_key'),
rive, bot, nyt_api, mongo)
Config = {'DEBUG': True, 'NYT_NUM_ARTICLES_RETURNED': 3}
msgproc = MessageProcessor(bot, external_api_parser, Config)
recipient_id = config.get('SECRET', 'fb_test_recipient_id')
#! /usr/bin/python3
import json
import requests
import time
import urllib
from rivescript import RiveScript
# Initialise the bot
bot = RiveScript()
bot.load_directory("./eg/brain")
bot.sort_replies()
TOKEN = "586907789:AAHuE1tPNHyU9MZnmYoBhD48N7bJFcYy4NQ"
URL = "https://api.telegram.org/bot{}/".format(TOKEN)
def get_url(url):
response = requests.get(url)
content = response.content.decode("utf8")
return content
def get_json_from_url(url):
content = get_url(url)
js = json.loads(content)
return js
def get_updates(offset=None):
url = URL + "getUpdates?timeout=100"
class AdmiralBot(object):
"""Chatbot instance for Admiral."""
###
# Initialization and Configuration
###
def __init__(self, debug=False, config="settings.yml",
defaults="defaults.yml", log_console=True):
"""Initialize the Admiral chatbot.
Parameters:
* debug: Enable debug logging to the console.
* config: The configuration file to use (default settings.yml)
* defaults: The name of the default config file (defaults.yml)
* log_console: Write logs to the console (STDOUT) as well as to the
log file on disk (default True).
"""
# Configurable parameters.
self.debug = debug
self.config = config
self.config_defaults = defaults
# Internal state variables.
self.running = False # Whether we're up and running
self.c = dict() # App configuration
self.bots = dict() # Individual bot interfaces
self.rs = None # RiveScript brain
# Load the bot's config.
self.load_config()
self.log = Logger(filename=self.c.logging.status,
console=log_console,
log_format=self.c.logging.format)
if debug:
self.log.set_level(logging.DEBUG)
self.log.debug("Debug logging enabled.")
# Run post-config initialization routines.
self.setup()
def load_config(self):
"""Load the configuration file from disk."""
project_settings = YamlSettings(self.config_defaults, self.config,
default_section="admiral")
self.c = project_settings.get_settings()
###
# Initial Setup Steps
###
def setup(self):
"""Run the setup steps."""
self.log.info("Welcome to Admiral.")
# Initialize the RiveScript brain.
self.reload_brain()
# Scan through the interfaces and find active bots.
self.log.info("Setting up interfaces...")
for interface in self.c.interfaces:
if not interface.enabled:
continue
if interface.id in self.bots:
self.panic("Duplicate ID: you have two or more interfaces "
"that use the ID name `{}` in your bot settings. You "
"should pick a unique ID name for each interface!")
self.bots[interface.id] = interface
# Get the interface class.
module = Interface.import_interface(interface.interface)
self.bots[interface.id].inst = module(master=self)
self.bots[interface.id].inst.setup(interface)
def reload_brain(self):
"""(Re)load the RiveScript brain for the bot."""
self.log.info("Loading RiveScript brain from {}".format(
self.c.personality.replies
))
self.rs = RiveScript(
debug=self.c.debug.rivescript,
utf8=True,
)
self.rs.load_directory(self.c.personality.replies)
self.rs.sort_replies()
###
# Start, stop, run commands.
###
def start(self):
"""Start up all the bots."""
if not self.running:
for name, bot in self.bots.items():
bot.inst.connect()
self.running = True
def run(self):
"""Start and run the bot's main loop."""
self.start()
while self.running:
for name, bot in self.bots.items():
bot.inst.do_one_loop()
###
# Event handlers.
###
def on_message(self, bot, username, remote_username, message):
"""Handle a message from an end user.
Parameters:
* bot: A reference to the interface that received the message.
* username: A unique name for the end user, typically with the
interface name prefixed, like `SLACK-kirsle`
* remote_username: The 'real' username, as the interface knows it.
* message: The text of the user's message.
"""
# Load this user's variables.
self.load_uservars(username)
# Get a reply for the user.
reply = self.rs.reply(username, message)
# Log the transaction.
self.log_chat(username, message, reply)
# Store the user's variables.
self.save_uservars(username)
# Send the response back.
# TODO: handle queueing and delayed responses.
bot.send_message(remote_username, reply)
def log_chat(self, username, message, reply):
"""Log the chat transaction to disk."""
# Each user gets their own log directory.
sanitized = re.sub(r'[^A-Za-z0-9_\-@]+', '', username)
outdir = os.path.join("logs", "chats", sanitized)
outfile = os.path.join(outdir, "{}.log".format(sanitized))
if not os.path.isdir(outdir):
os.makedirs(outdir, mode=0o755)
self.log.info("[{}] {}".format(username, message))
self.log.info("[{}] {}".format(self.c.personality.name, reply))
with open(outfile, "a", encoding="utf-8") as fh:
today = datetime.datetime.today()
ts = today.strftime(self.c.logging.date_format)
fh.write("{today}\n"
"[{username}] {message}\n"
"[{bot}] {reply}\n\n".format(
today=ts,
username=username,
message=message,
bot=self.c.personality.name,
reply=reply,
))
def load_uservars(self, username):
"""Load a user's variables from disk."""
if not os.path.isdir("users"):
os.mkdir("users")
sanitized = re.sub(r'[^A-Za-z0-9_\-@]+', '', username)
filename = "users/{}.json".format(sanitized)
if not os.path.isfile(filename):
return
with open(filename, "r", encoding="utf-8") as fh:
data = fh.read()
try:
params = json.loads(data)
print(params)
for key, value in params.items():
if type(value) is str:
self.rs.set_uservar(username, key, value)
print("SET VAR:", username, key, value)
except:
pass
def save_uservars(self, username):
"""Save a user's variables to disk."""
if not os.path.isdir("users"):
os.mkdir("users")
sanitized = re.sub(r'[^A-Za-z0-9_\-@]+', '', username)
filename = "users/{}.json".format(sanitized)
with open(filename, "w", encoding="utf-8") as fh:
fh.write(json.dumps(self.rs.get_uservars(username)))
###
# Utility/Misc functions.
###
def panic(self, error):
"""Exit with a fatal error message."""
self.log.error(error)
raise RuntimeError(error)
from rivescript import RiveScript
bot = RiveScript()
bot.load_directory("D:\CurrentLooks\Projects\minor project\shopping-chatbot")
bot.sort_replies()
import os
sys.path.append(os.path.join(
os.path.dirname(__file__),
"..", "..",
))
sys.path.append(os.path.join(
os.path.dirname(__file__),
"..", "..",
"contrib", "redis",
))
from rivescript import RiveScript
from rivescript_redis import RedisSessionManager
bot = RiveScript(
session_manager=RedisSessionManager(),
)
bot.load_directory("../brain")
bot.sort_replies()
print("""RiveScript Redis Session Storage Example
This example uses a Redis server to store user variables. For the sake of the
example, choose a username to store your variables under. You can re-run this
script with the same username (or a different one!) and verify that your
variables are kept around!
Type '/quit' to quit.
""")
username = input("What is your username? ").strip()
from flask import request, g, make_response, jsonify
from rivescript import RiveScript
from . import Resource
from .. import schemas, config
import jwt
import os
import json
from googletrans import Translator
from wit import Wit
from .. import config
import datetime
# the access token for wit ai
access_token = "ABJWGG53QBEVM6UY6AUMBPNP42EQCXOZ"
client = Wit(access_token)
rs = RiveScript()
rs1 = RiveScript()
print(os.getcwd())
class Chatbot(Resource):
def wit_response(self, text):
message = "Analysing the code " + text["_text"] + " : "
entities = list(text["entities"].keys())
# print(entities)
# if the intent cannot be detected, redirect to rs
if "intent" not in entities:
return None
# using different ways to avoid mistranslate
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": "******",
"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)
class ChatBot:
def __init__(self, replies, **botvars):
self.logs = io.StringIO()
self.brain = RiveScript(debug=True, log=self.logs)
self.brain.load_directory(replies)
self.brain.sort_replies()
for key, value in botvars.items():
self.brain.set_variable(key, str(value))
def get_response(self, message, name, ID):
if self.brain.get_uservar(ID,
"name") is None or self.brain.get_uservar(
ID, "name") == "undefined":
self.brain.set_uservar(ID, "name", name)
try:
return self.brain.reply(ID, message, False), None
except Exception as exc:
return None, exc
from rivescript import RiveScript
bot = RiveScript(utf8=True)
bot.load_directory("./replies")
bot.sort_replies()
from rivescript import RiveScript
bot = RiveScript()
bot.load_directory("./")
bot.sort_replies()
while True:
msg = input('You> ')
if msg == '/quit':
quit()
reply = bot.reply("localuser", msg)
print('Bot>', reply)
def new(self, code, **kwargs):
"""Make a bot and stream in the code."""
self.rs = RiveScript(**kwargs)
self.extend(code)
bot.set_variable("shop", None)
return "Shclosed 😭"
def get_shop(rs, args):
shop = bot.get_variable("shop")
return "Shopen!!!" if shop else "Shclosed 😭"
celery = Celery('bot', broker=BROKER_URL)
# ==== rivescript bot setup ==== #
bot = RiveScript()
bot.load_directory("./bot/brain")
bot.sort_replies()
# ==== rivescript subroutines ==== #
# These functions can be used in the rivescript documents
bot.set_subroutine("set_jd", set_jd)
bot.set_subroutine("get_jd", get_jd)
bot.set_subroutine("set_shop", set_shop)
bot.set_subroutine("get_shop", get_shop)
# bot.set_subroutine("set_hashbrowns", functions.set_hashbrowns)
# bot.set_subroutine("get_hashbrowns", functions.get_hashbrowns)
# ==== message handling ==== #
from rivescript import RiveScript
bot = RiveScript(utf8=True)
bot.load_directory('brain')
bot.sort_replies()
def reply(user, message):
return bot.reply(user, message)
def logoutUser(user):
try:
bot.clear_uservars(user)
except:
print("User not found")
import re
import requests
from config import CONFIG
from fbmq import Attachment, Template, QuickReply, NotificationType
from fbpage import page
from rivescript import RiveScript
from rivescript_redis import RedisSessionManager
from util import topicos
from util import elimina_tildes
parentdir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
os.sys.path.insert(0, parentdir)
USER_SEQ = {}
bot = RiveScript(session_manager=RedisSessionManager())
bot.load_directory("./rs")
bot.sort_replies()
page.greeting("LinguaBot+, tu mejor opción para el asesoramiento del idioma inglés.")
page.show_starting_button("START_PAYLOAD")
#MÉTODOS MODIFICADOS Y/O CREADOS
@page.callback(['START_PAYLOAD'])
def start_callback(payload, event):
print("Let's start!")
from rivescript import RiveScript
from gevent import pywsgi
from flask import Flask, render_template, request, redirect
from redis_storage import RedisSessionStorage
import redis
#import logging
import gevent.monkey
gevent.monkey.patch_all()
rs = RiveScript(session_manager=RedisSessionStorage(),)
rs.load_directory("/home/luky/line3v2/rivescript_microsite/")
rs.sort_replies()
redisconn = redis.StrictRedis()
if __name__== "__main__":
print "Rivescript is online"
app = Flask(__name__)
@app.route('/reply', methods=['POST'])
def reply():
content = request.get_json()
print "reply:", content
return rs.reply(content['msisdn'], content['ask'])
print "starting gevent wsgi..."
pywsgi.WSGIServer(('', 3003), app).serve_forever()
#!/usr/bin/env python
from __future__ import unicode_literals, print_function, absolute_import
from six.moves import input
import sys
from rivescript import RiveScript
from redis_storage import RedisSessionStorage
bot = RiveScript(session_manager=RedisSessionStorage(), )
bot.load_directory("../brain")
bot.sort_replies()
print("""RiveScript Redis Session Storage Example
This example uses a Redis server to store user variables. For the sake of the
example, choose a username to store your variables under. You can re-run this
script with the same username (or a different one!) and verify that your
variables are kept around!
Type '/quit' to quit.
""")
username = input("What is your username? ").strip()
if len(username) == 0:
print("You need to enter one! This script will exit now.")
sys.exit(1)
while True:
message = input("You> ").strip()
if len(message) == 0:
continue
class Aplicacion(wx.Frame):
def __init__(self):
self.Ventana()
self.Agente()
# self.Respuesta("begin")
def Agente(self):
self.agente = RiveScript()
self.agente.load_directory("./recursos")
self.agente.sort_replies()
self.lector = Dispatch("SAPI.SpVoice")
if time.localtime().tm_hour < 12:
self.agente.set_variable("time", "dia")
else:
if time.localtime().tm_hour < 18:
self.agente.set_variable("time", "tarde")
else:
self.agente.set_variable("time", "noche")
def Ventana(self):
wx.Frame.__init__(self, None, style= wx.RESIZE_BORDER | wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX)
self.panel = wx.Panel(self)
self.texto = wx.TextCtrl(self.panel, style=wx.TE_MULTILINE | wx.TE_READONLY, size= (293,350), pos = (5,5))
self.linea = wx.TextCtrl(self.panel, style=wx.TE_NO_VSCROLL | TE_PROCESS_ENTER, size= (200,50), pos = (10,365))
self.boton = wx.BitmapButton(self.panel, bitmap = wx.Bitmap("recursos\_enviar.png"), pos = (220, 360))
self.etiqueta = wx.StaticText(self.panel, label = "Proyecto Inteligencia Artificial - ULA, A2012 ", pos = (5, 425))
self.Bind(wx.EVT_TEXT_ENTER, self.Pregunta, self.linea)
self.Bind(wx.EVT_BUTTON, self.Pregunta, self.boton)
self.linea.SetFocus()
self.SetTitle("Representante de Atencion al Cliente")
self.SetSize((320,480))
self.Centre()
self.Show()
def Pregunta(self, evento):
self.texto.AppendText(" "+ str(self.linea.GetValue()).capitalize() + "\n")
self.Respuesta(self.linea.GetValue().__str__())
def Respuesta(self, texto):
bot = self.agente.reply("rac", texto)
self.linea.Clear()
self.texto.AppendText(str(bot) + "\n")
self.lector.Speak(bot)
#!/usr/bin/python3
# Python 3 example
from rivescript import RiveScript
rs = RiveScript()
rs.load_directory("./eg/brain")
rs.sort_replies()
print(
"""This is a bare minimal example for how to write your own RiveScript bot!
For a more full-fledged example, try running: `python rivescript brain`
This will run the built-in Interactive Mode of the RiveScript library. It has
some more advanced features like supporting JSON for communication with the
bot. See `python rivescript --help` for more info.
example3.py is just a simple script that loads the RiveScript documents from
the 'brain/' folder, and lets you chat with the bot.
Type /quit when you're done to exit this example.
""")
while True:
msg = input("You> ")
if msg == '/quit':
quit()
reply = rs.reply("localuser", msg)
print("Bot>", reply)
See the accompanying README.md for instructions."""
# Manipulate sys.path to be able to import rivescript from this git repo.
# Otherwise you'd have to `pip install rivescript`
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
from flask import Flask, request, redirect
from rivescript import RiveScript
import twilio.twiml
# Set up the RiveScript bot. This loads the replies from "../brain", or,
# the "brain" folder in the "eg" folder of this git repository.
bot = RiveScript()
bot.load_directory(
os.path.join(os.path.dirname(__file__), "..", "brain")
)
bot.sort_replies()
app = Flask(__name__)
@app.route("/twilio", methods=["GET", "POST"])
def hello_rivescript():
"""Receive an inbound SMS and send a reply from RiveScript."""
from_number = request.values.get("From", "unknown")
message = request.values.get("Body")
reply = "(Internal error)"
class RiveScript_Py_Tests(RiveScriptTestCase):
def setUp(self):
super().setUp()
self.testdir = "__testdir__"
os.mkdir(self.testdir)
os.mkdir(os.path.join(self.testdir, "subdir"))
def writeit(filename, contents):
with open(os.path.join(self.testdir, filename), 'w') as f:
f.write(contents + '\n')
writeit("star.rive", """
+ *
- star
""")
writeit(
"sub.rive", """
! sub aya = a
! sub bee = b
""")
writeit(
os.path.join("subdir", "cont.rive"), """
+ a
- aa
+ b
- bb
""")
def tearDown(self):
shutil.rmtree(self.testdir)
def test_improve_code_coverage_rivescript(self):
from rivescript import __version__
from rivescript import RiveScript
self.assertEqual(RiveScript.VERSION(), __version__)
self.rs = RiveScript()
self.rs.load_directory(self.testdir)
self.rs.sort_replies()
self.reply("a", "aa")
self.reply("aya", "aa")
self.reply("bee", "bb")
self.reply("cee", "star")
self.rs = RiveScript()
self.rs.load_file(os.path.join(self.testdir, "star.rive"))
self.rs.load_file(os.path.join(self.testdir, "subdir", "cont.rive"))
self.rs.sort_replies()
self.reply("a", "aa")
self.reply("aya", "star")
self.new("""
! global g = gee
! var v = vee
+ g
- <env g>
+ v
- <bot v>
""")
self.reply("g", "gee")
self.reply("v", "vee")
self.rs.set_global("g", None)
self.rs.set_variable("v", None)
self.reply("g", "undefined")
self.reply("v", "undefined")
self.new("""
+ *
- star<set m=me><set u=you>
""")
self.reply("hi", "star")
self.assertContains(self.rs.get_uservars(),
{self.username: {
'm': "me",
'u': "you"
}})
self.rs.set_uservar("u2", "a", "aye")
self.rs.clear_uservars(self.username)
uv = self.rs.get_uservars()
self.assertNotIn(self.username, uv)
self.assertContains(uv, {"u2": {'a': "aye"}})
self.new("""
+ u
- <call>user</call>
> object user python
return rs.current_user()
< object
""")
self.reply('u', self.username)
self.assertEqual(self.rs.current_user(), None)
#!/usr/bin/python
# -*- coding: utf-8 -*-
from rivescript import RiveScript
rs = RiveScript(utf8 = True)
rs.load_directory("./cerveau")
rs.sort_replies()
while True:
msg = raw_input("Vous > ")
if msg == '/quit':
quit()
reply = u"{0}".format(rs.reply("localuser", msg))
print(u"Aria > {0}".format(reply))
def test_improve_code_coverage_rivescript(self):
from rivescript import __version__
from rivescript import RiveScript
self.assertEqual(RiveScript.VERSION(), __version__)
self.rs = RiveScript()
self.rs.load_directory(self.testdir)
self.rs.sort_replies()
self.reply("a", "aa")
self.reply("aya", "aa")
self.reply("bee", "bb")
self.reply("cee", "star")
self.rs = RiveScript()
self.rs.load_file(os.path.join(self.testdir, "star.rive"))
self.rs.load_file(os.path.join(self.testdir, "subdir", "cont.rive"))
self.rs.sort_replies()
self.reply("a", "aa")
self.reply("aya", "star")
self.new("""
! global g = gee
! var v = vee
+ g
- <env g>
+ v
- <bot v>
""")
self.reply("g", "gee")
self.reply("v", "vee")
self.rs.set_global("g", None)
self.rs.set_variable("v", None)
self.reply("g", "undefined")
self.reply("v", "undefined")
self.new("""
+ *
- star<set m=me><set u=you>
""")
self.reply("hi", "star")
self.assertContains(self.rs.get_uservars(),
{self.username: {
'm': "me",
'u': "you"
}})
self.rs.set_uservar("u2", "a", "aye")
self.rs.clear_uservars(self.username)
uv = self.rs.get_uservars()
self.assertNotIn(self.username, uv)
self.assertContains(uv, {"u2": {'a': "aye"}})
self.new("""
+ u
- <call>user</call>
> object user python
return rs.current_user()
< object
""")
self.reply('u', self.username)
self.assertEqual(self.rs.current_user(), None)
def __init__(self):
self.bot = RiveScript()
self.bot.load_directory("dialogues")
self.bot.sort_replies()
from rivescript import RiveScript
from bot_interface.bot_interface import BotInterface
from message_processor.message_processor import MessageProcessor, ExternalApiParser
from nyt_interface.nyt_interface import NytimesApi
app = Flask(__name__)
mongo = PyMongo(app)
app.config.from_object("config.DevelopmentConfig")
app.config.from_pyfile("local.cfg")
bot = BotInterface(app.config['FB_API_VERSION'], app.config['FB_ACCESS_TOKEN'])
nyt_api = NytimesApi(app.config['NYT_KEY'])
rive = RiveScript()
rive.load_directory(
os.path.join(os.path.dirname(__file__), "message_processor", "rivescripts")
)
rive.sort_replies()
# external_api_parser = ExternalApiParser(app.config['WIT_KEY'], app.config['API_AI_KEY'], bot, nyt_api)
external_api_parser = ExternalApiParser(app.config['WIT_KEY'], rive, bot, nyt_api, mongo)
msgproc = MessageProcessor(bot, external_api_parser, app.config)
@app.route("/")
def index():
return render_template('messenger.html')
# return success(status=200, message="Hello world from climatechangebot!")
class ImproveTestCoverage_Tests(RiveScriptTestCase):
def test_improve_code_coverage_brain(self):
self.new("""
+ *
- star{topic=empty}
> topic empty
< topic
""")
self.reply("hi", "star")
self.reply(
"hi",
"[ERR: No Reply Matched]") # Should give an "empty topic" warning
# Doesn't work! self.reply("hi", "star") # and put us back in "random"
self.new("""
+ *
@ recurse most deeply
""")
self.reply("recurse", "[ERR: Deep recursion detected]")
self.new(""" // Trying to hit a bunch of code here! :-)
+ *
- {random}star star{/random}<set var=var>{weight=2}
+ <input> <reply1> <get var>
* 1 <= 2 => <get var> <reply> <input1> <add num=2><mult num=3><sub num=2><div num=2><get num>
- Nope!
+ upper lower
- {uppercase}lower{/uppercase} {lowercase}UPPER{/lowercase}
+ blank random
- {random} {/random}blank
""")
self.reply("hi", "star")
self.reply("hi star var", "var star hi 2")
self.reply("upper lower", "LOWER upper")
self.reply("blank random", "blank")
from rivescript import RiveScript
from rivescript.exceptions import RepliesNotSortedError
self.rs = RiveScript()
self.rs.stream("""
+ *
- star
""")
try:
self.reply("hi", "Nope!")
except RepliesNotSortedError:
pass
def test_improve_code_coverage_parser(self):
self.new("""
+ * // Inline comment
- star // Another comment
""")
self.reply("hi", "star")
self.new("""
! global g = gee
! global debug = false
! global depth = 100
! global strict = true
! var v = vee
! array a = a b c
! sub g = a
! person v = b
// Now get rid of most of these
! global g = <undef>
! var v = <undef>
! array a = <undef>
! sub g = <undef>
! person v = <undef>
+ g
- g <env g>
+ v *
- <person> <bot v>
+ *
- star
+ @a arr
- a arr
""")
self.reply("g gee", "star")
self.reply("g", "g undefined")
self.reply("v v", "v undefined")
self.reply("a arr", "star")
#!/usr/bin/python
from rivescript import RiveScript
rs = RiveScript()
rs.load_file("replies.rive")
rs.sort_replies()
print """This is a bare minimal example for how to write your own RiveScript bot!
For a more full-fledged example, try running: `python rivescript brain`
This will run the built-in Interactive Mode of the RiveScript library. It has
some more advanced features like supporting JSON for communication with the
bot. See `python rivescript --help` for more info.
example.py is just a simple script that loads the RiveScript documents from
the 'brain/' folder, and lets you chat with the bot.
Type /quit when you're done to exit this example.
"""
while True:
msg = raw_input("You> ")
if msg == '/quit':
quit()
reply = rs.reply("localuser", msg)
print "Bot>", reply
# vim:expandtab
from matplotlib import pyplot
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
#Load model
pkl_filename = "model/pickle_model.pkl"
with open(pkl_filename, 'rb') as file:
model = pickle.load(file)
#Bot initialisation
file = os.path.dirname("__file__")
convo = os.path.join(file , 'convo')
bot = RiveScript()
bot.load_directory(convo)
bot.sort_replies()
while True:
msg = str(input("You> "))
if msg.find('gre') != -1:
gre = [int(i) for i in msg.split() if i.isdigit()]
print(gre)
if msg.find('cgpa') != -1:
cgpa = re.findall("\d+\.\d+", msg)
cgpa = [float(i) for i in cgpa]
print(cgpa)
if msg.find('toefl') != -1:
toefl = [int(i) for i in msg.split() if i.isdigit()]
from __future__ import print_function
from rivescript import RiveScript
rs = RiveScript()
rs.load_directory("./brain")
rs.sort_replies()
def lambda_handler(event, context):
""" Route the incoming request based on type (LaunchRequest, IntentRequest,
etc.) The JSON body of the request is provided in the event parameter.
"""
print("event.session.application.applicationId=" +
event['session']['application']['applicationId'])
"""
Uncomment this if statement and populate with your skill's application ID to
prevent someone else from configuring a skill that sends requests to this
function.
"""
# if (event['session']['application']['applicationId'] !=
# "amzn1.echo-sdk-ams.app.[unique-value-here]"):
# raise ValueError("Invalid Application ID")
if event['session']['new']:
on_session_started({'requestId': event['request']['requestId']},
event['session'])
if event['request']['type'] == "LaunchRequest":
return on_launch(event['request'], event['session'])
elif event['request']['type'] == "IntentRequest":
return on_intent(event['request'], event['session'])
#!/usr/bin/python3
# Python 3 example
from rivescript import RiveScript
from server_functions import get_random_user_id
import json
import re
import socket
import spell_checker_italian as spell
rs = RiveScript(utf8=True)
rs.unicode_punctuation = re.compile(r'[,!?;:]')
rs.load_directory("./brain/")
rs.sort_replies()
#rs.set_uservar(get_current_user(),'id',get_current_user())
def set_user_var(user,var,value):
"""
Imposta una variabile all'utente selezionato
:param user : l'utente a cui assegnare la variabile
:param var : il nome della variabile
:param value: il valore da assegnare
"""
rs.set_uservar(user,var,value)
def set_metadata(value, user_id='localuser', name='metadata'):
"""
Imposta la variabile 'metadata' all'utente selezionato
Usato per gestire i diversi tipi di richieste HTTP
from rivescript import RiveScript
def error_check(reply):
if "[ERR:" in reply:
return "I'm sorry, something went wrong."
else:
return reply
bot = RiveScript()
bot.load_directory("./Ania")
bot.sort_replies()
user = "******"
while True:
msg = input('You> ')
if msg == '/quit':
quit()
reply = bot.reply(user, msg)
reply = error_check(reply)
print("{}{}{}{}".format("\033[96m", "Ania> ", reply, "\033[0m"))
#!/usr/bin/python
import re
from flask import Flask, jsonify, render_template, request
from rivescript import RiveScript
from rivescript import sentences
rs = RiveScript(debug=False, utf8=True)
rs.load_directory("./brain_zh")
rs.sort_replies()
rs.train()
app = Flask(__name__)
@app.route('/reply')
def get_reply():
user = re.sub(ur'\W', '', request.remote_addr)
line = request.args.get('l','')
user = user.strip()
res = []
req = []
if user != '':
for msg in sentences(line):
if msg.strip() == '':
continue
reply = rs.reply(user, msg)
req.append(msg)
res.append(reply)
return jsonify(req=req, reply=res)
# create by fanfan on 2019/7/5 0005
#!/usr/bin/python3
# Python 3 example
from rivescript import RiveScript
rs = RiveScript(utf8=True, debug=True)
rs.load_directory("brain")
rs.sort_replies()
print(
"""This is a bare minimal example for how to write your own RiveScript bot!
For a more full-fledged example, try running: `python rivescript brain`
This will run the built-in Interactive Mode of the RiveScript library. It has
some more advanced features like supporting JSON for communication with the
bot. See `python rivescript --help` for more info.
example3.py is just a simple script that loads the RiveScript documents from
the 'brain/' folder, and lets you chat with the bot.
Type /quit when you're done to exit this example.
""")
while True:
msg = input("You> ")
if msg == '/quit':
quit()
reply = rs.reply("localuser", msg)
print("Bot>", reply)
# vim:expandtab
from rivescript import RiveScript
from bot_interface.bot_interface import BotInterface
from message_processor.message_processor import MessageProcessor, ExternalApiParser
from nyt_interface.nyt_interface import NytimesApi
app = Flask(__name__)
mongo = PyMongo(app)
app.config.from_object("config.DevelopmentConfig")
app.config.from_pyfile("local.cfg")
bot = BotInterface(app.config['FB_API_VERSION'], app.config['FB_ACCESS_TOKEN'])
nyt_api = NytimesApi(app.config['NYT_KEY'])
rive = RiveScript()
rive.load_directory(
os.path.join(os.path.dirname(__file__), "message_processor",
"rivescripts"))
rive.sort_replies()
# external_api_parser = ExternalApiParser(app.config['WIT_KEY'], app.config['API_AI_KEY'], bot, nyt_api)
external_api_parser = ExternalApiParser(app.config['WIT_KEY'], rive, bot,
nyt_api, mongo)
msgproc = MessageProcessor(bot, external_api_parser, app.config)
@app.route("/")
def index():
return render_template('messenger.html')
# return success(status=200, message="Hello world from climatechangebot!")
from linebot.exceptions import (InvalidSignatureError)
from linebot.models import (
MessageEvent, TextMessage, TextSendMessage, SourceUser, SourceGroup,
SourceRoom, TemplateSendMessage, ConfirmTemplate, MessageAction,
ButtonsTemplate, ImageCarouselTemplate, ImageCarouselColumn, URIAction,
PostbackAction, DatetimePickerAction, CameraAction, CameraRollAction,
LocationAction, CarouselTemplate, CarouselColumn, PostbackEvent,
StickerMessage, StickerSendMessage, LocationMessage, LocationSendMessage,
ImageMessage, VideoMessage, AudioMessage, FileMessage, UnfollowEvent,
FollowEvent, JoinEvent, LeaveEvent, BeaconEvent, FlexSendMessage,
BubbleContainer, ImageComponent, BoxComponent, TextComponent,
SpacerComponent, IconComponent, ButtonComponent, SeparatorComponent,
QuickReply, QuickReplyButton)
from linebot.exceptions import LineBotApiError
bot = RiveScript()
bot.load_file("data.rive")
bot.sort_replies()
app = Flask(__name__)
# create stemmer
factory = StemmerFactory()
stemmer = factory.create_stemmer()
# Developer Trial Mode
line_bot_api = LineBotApi('API_KEY')
handler = WebhookHandler('Channel')
def time_to_int(t):
#!/usr/bin/python3
# Python 3 example
from pprint import pprint
from rivescript import RiveScript
rs = RiveScript(True)
rs.load_directory("./brain")
rs.sort_replies()
print("""This is a bare minimal example for how to write your own RiveScript bot!
For a more full-fledged example, try running: `python rivescript brain`
This will run the built-in Interactive Mode of the RiveScript library. It has
some more advanced features like supporting JSON for communication with the
bot. See `python rivescript --help` for more info.
example3.py is just a simple script that loads the RiveScript documents from
the 'brain/' folder, and lets you chat with the bot.
Type /quit when you're done to exit this example.
""")
user = "******"
while True:
msg = input("You> ")
if msg == '/quit':
quit()
elif msg == '/dump':
See the accompanying README.md for instructions."""
# Manipulate sys.path to be able to import rivescript from this git repo.
# Otherwise you'd have to `pip install rivescript`
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
from flask import Flask, request, redirect
from rivescript import RiveScript
import twilio.twiml
# Set up the RiveScript bot. This loads the replies from "../brain", or,
# the "brain" folder in the "eg" folder of this git repository.
bot = RiveScript()
bot.load_directory(os.path.join(os.path.dirname(__file__), "..", "brain"))
bot.sort_replies()
app = Flask(__name__)
@app.route("/twilio", methods=["GET", "POST"])
def hello_rivescript():
"""Receive an inbound SMS and send a reply from RiveScript."""
from_number = request.values.get("From", "unknown")
message = request.values.get("Body")
reply = "(Internal error)"
# Get a reply from RiveScript.
from rivescript import RiveScript
bot = RiveScript()
bot.load_directory("../public/brain/")
bot.load_directory("../public/brain/commands")
bot.sort_replies()
while True:
msg = input("You> ")
if msg == "/quit":
quit()
reply = bot.reply("localuser", msg)
print("Bot>", reply)
def interactive_mode():
# Get command line options.
options, remainder = [], []
try:
options, remainder = getopt.getopt(sys.argv[1:], 'dju', [
'debug', 'json', 'utf8', 'log=', 'strict', 'nostrict', 'depth=',
'help'
])
except:
print("Unrecognized options given, try " + sys.argv[0] + " --help")
exit()
# Handle the options.
debug, depth, strict = False, 50, True
with_json, help, log = False, False, None
utf8 = False
for opt in options:
if opt[0] == '--debug' or opt[0] == '-d':
debug = True
elif opt[0] == '--strict':
strict = True
elif opt[0] == '--nostrict':
strict = False
elif opt[0] == '--json':
with_json = True
elif opt[0] == '--utf8' or opt[0] == '-u':
utf8 = True
elif opt[0] == '--help' or opt[0] == '-h':
help = True
elif opt[0] == '--depth':
depth = int(opt[1])
elif opt[0] == '--log':
log = opt[1]
# Help?
if help:
print("""Usage: rivescript [options] <directory>
Options:
--debug, -d
Enable debug mode.
--log FILE
Log debug output to a file (instead of the console). Use this instead
of --debug.
--json, -j
Communicate using JSON. Useful for third party programs.
--strict, --nostrict
Enable or disable strict mode (enabled by default).
--depth=50
Set the recursion depth limit (default is 50).
--help
Display this help.
JSON Mode:
In JSON mode, input and output is done using JSON data structures. The
format for incoming JSON data is as follows:
{
'username': '******',
'message': 'Hello bot!',
'vars': {
'name': 'Aiden'
}
}
The format that would be expected from this script is:
{
'status': 'ok',
'reply': 'Hello, human!',
'vars': {
'name': 'Aiden'
}
}
If the calling program sends an EOF signal at the end of their JSON data,
this script will print its response and exit. To keep a session going,
send the string '__END__' on a line by itself at the end of your message.
The script will do the same after its response. The pipe can then be used
again for further interactions.""")
quit()
# Given a directory?
if len(remainder) == 0:
print("Usage: rivescript [options] <directory>")
print("Try rivescript --help")
quit()
root = remainder[0]
# Make the bot.
bot = RiveScript(debug=debug,
strict=strict,
depth=depth,
utf8=utf8,
log=log)
bot.load_directory(root)
bot.sort_replies()
# Interactive mode?
if with_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("""RiveScript Interpreter (Python) -- Interactive Mode"
---------------------------------------------------"
rivescript version: %s
Reply Root: %s
You are now chatting with the RiveScript bot. Type a message and press Return"
to send it. When finished, type '/quit' to exit the program."
Type '/help' for other options."
""" % (str(bot.VERSION()), root))
while True:
msg = _input("You> ")
# 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)
#!/usr/bin/env python
# Manipulate sys.path to be able to import rivescript from this local git
# repository.
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
from rivescript import RiveScript
import json
bot = RiveScript()
bot.load_file("example.rive")
dep = bot.deparse()
print(json.dumps(dep, indent=2))
from rivescript import RiveScript
chatbot = RiveScript(utf8=True)
chatbot.prepare_brain_transplant()
chatbot.load_directory("application/bot_brain")
chatbot.sort_replies()
def Chat(user_msg):
if user_msg == "":
return "Please type a message"
else:
response = chatbot.reply("user", user_msg)
if response:
return response
else:
return "No reply, please try again"
#!/usr/bin/python
from rivescript import RiveScript
from rivescript import sentences
#rs = RiveScript(log='log.example', utf8=True)
rs = RiveScript(debug=False, utf8=True)
rs.load_directory("./brain_zh")
rs.sort_replies()
rs.train()
print """This is a bare minimal example for how to write your own RiveScript bot!
For a more full-fledged example, try running: `python rivescript brain`
This will run the built-in Interactive Mode of the RiveScript library. It has
some more advanced features like supporting JSON for communication with the
bot. See `python rivescript --help` for more info.
example.py is just a simple script that loads the RiveScript documents from
the 'brain/' folder, and lets you chat with the bot.
Type /quit when you're done to exit this example.
"""
while True:
s = raw_input("You> ")
if s == '/quit':
quit()
for msg, is_ask in sentences(s):
if msg.strip() == '':
if len(sys.argv) == 1:
print("Usage: 01-gamemode.py <list of users to whitelist>")
sys.exit(1)
debug = False
host, port, password = None, None, None
if sys.argv[1] == "--debug":
debug = True
host, port, password = sys.argv[2:5]
else:
host, port, password = sys.argv[1:4]
# Initialize the RiveScript bot.
# http://www.rivescript.com/
bot = RiveScript()
bot.stream("""
+ (hello|hi|hey|yo)
- Hello, <id>!
- Hi there, <id>!
- Hey, <id>!
+ (how are you|how you doing)
- Great, you?
- Good.
+ (good|great|awesome)
- Awesome!
+ (not good|not great)
- Aww. =(
