def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.init = self.created
self.characters = []
def _GetSamplesJSON(self, request, key, update=False):
templates = self.template_data_source_factory.Create(
request, key + '/samples.html')
if key == 'apps' or key == 'extensions':
cache_url = None
if key == 'apps':
cache_url = '/trunk/' + key
else:
cache_url = '/' + templates._branch_info['current'] + '/' + key
logging.info('Serving API request %s' % cache_url)
data = ResponseCache.Get(cache_url)
age = ResponseCache.GetAge(cache_url)
need_update = (age > datetime.timedelta(1))
logging.info('Cache age: %s' % str(age))
if data is not None and not (update == True
and need_update == True):
return data
else:
content = []
try:
logging.info('Trying to generate samples.json for %s' %
cache_url)
content = templates._samples_data_source.GetAsJSON(key)
except:
logging.getLogger('slave-samples-api').exception(
'Error generating samples!')
pass
if len(content) > 0:
logging.info('samples.json saved for %s' % cache_url)
ResponseCache.Set(cache_url, content)
return content
def post_response(body): # noqa: E501
"""Annotate a response
# noqa: E501
:param body: Object that provides annotation information
:type body:
:rtype: object
"""
response_cache = ResponseCache()
response_cache.store_callback(body)
return 'received!'
def get_response(response_id): # noqa: E501
"""Request a previously stored response from the server
# noqa: E501
:param response_id: Identifier of the response to return
:type response_id: str
:rtype: Response
"""
response_cache = ResponseCache()
envelope = response_cache.get_response(response_id)
return envelope
def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.init = self.created
self.characters = []
dirname = os.path.join(HISTORY_DIR, self.created.strftime('%Y%m%d'))
test_dirname = os.path.join(TEST_HISTORY_DIR, self.created.strftime('%Y%m%d'))
self.fname = os.path.join(dirname, '{}.csv'.format(self.sid))
self.test_fname = os.path.join(test_dirname, '{}.csv'.format(self.sid))
self.dump_file = None
self.removed = False
self.active = False
self.last_active_time = None
self.test = False
def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.init = self.created
self.characters = []
def __init__(self, sid):
self.sid = sid
self.session_context = SessionContext()
self.cache = ResponseCache()
self.created = dt.datetime.utcnow()
self.characters = []
dirname = os.path.join(HISTORY_DIR, self.created.strftime('%Y%m%d'))
test_dirname = os.path.join(
TEST_HISTORY_DIR, self.created.strftime('%Y%m%d'))
self.fname = os.path.join(dirname, '{}.csv'.format(self.sid))
self.test_fname = os.path.join(test_dirname, '{}.csv'.format(self.sid))
self.dump_file = None
self.closed = False
self.active = False
self.last_active_time = None
self.test = False
self.last_used_character = None
self.open_character = None
def _ask_characters(characters, question, lang, session):
global response_caches
chat_tries = 0
if session not in response_caches:
response_caches[session] = ResponseCache()
cache = response_caches.get(session)
weights = [c.weight for c in characters]
_question = question.lower().strip()
_question = ' '.join(_question.split()) # remove consecutive spaces
num_tier = len(characters)
while chat_tries < MAX_CHAT_TRIES:
chat_tries += 1
_responses = [c.respond(_question, lang, session) for c in characters]
for r in _responses:
assert isinstance(r, dict), "Response must be a dict"
answers = [r.get('text', '') for r in _responses]
# Each tier has weight*100% chance to be selected.
# If the chance goes to the last tier, it will be selected anyway.
for idx, answer in enumerate(answers):
if not answer:
continue
if random.random() < weights[idx]:
if cache.check(_question, answer):
cache.add(_question, answer)
return _responses[idx]
c = get_character('sophia_pickup')
if c is not None:
chat_tries = 0
while chat_tries < MAX_CHAT_TRIES:
chat_tries += 1
if random.random() > 0.7:
_response = c.respond('early random pickup', lang, session)
_response['state'] = 'early random pickup'
else:
_response = c.respond('mid random pickup', lang, session)
_response['state'] = 'mid random pickup'
answer = _response.get('text', '')
if cache.check(_question, answer):
cache.add(_question, answer)
return _response
_response = {}
answer = "Sorry, I can't answer that"
_response['text'] = answer
_response['botid'] = "dummy"
_response['botname'] = "dummy"
cache.add(_question, answer)
return _response
def _OriginalGet(self, path, request, response):
templates = self.template_data_source_factory.Create(request, path)
content = None
try:
if fnmatch(path, 'extensions/examples/*.zip'):
content = self.example_zipper.Create(
path[len('extensions/'):-len('.zip')])
response.headers['content-type'] = 'application/zip'
elif path.startswith('extensions/examples/'):
mimetype = mimetypes.guess_type(path)[0] or 'text/plain'
content = self.content_cache.GetFromFile(
'%s/%s' %
(svn_constants.DOCS_PATH, path[len('extensions/'):]),
binary=_IsBinaryMimetype(mimetype))
response.headers['content-type'] = 'text/plain'
elif path.startswith('static/'):
content = self._FetchStaticResource(path, response)
elif path.endswith('.html'):
content = templates.Render(path)
except FileNotFoundError as e:
logging.warning(e)
response.headers['x-frame-options'] = 'sameorigin'
if content is None:
response.set_status(404)
response.out.write(templates.Render('404'))
else:
if not content:
logging.error('%s had empty content' % path)
response.headers['cache-control'] = 'max-age=300'
response.out.write(content)
cache_url = '/' + templates._branch_info['current'] + '/' + path
if isinstance(content, unicode):
ResponseCache.Set(cache_url, content.encode('utf-8'))
else:
ResponseCache.Set(cache_url, content)
def _GetDocsHTML(self, request, path, update=False):
templates = self.template_data_source_factory.Create(request, path)
cache_url = '/' + templates._branch_info['current'] + '/' + path
logging.info('Serving API request %s' % cache_url)
data = ResponseCache.Get(cache_url)
age = ResponseCache.GetAge(cache_url)
need_update = (age > datetime.timedelta(1))
logging.info('Cache age: %s' % str(age))
if data is not None and not (update == True and need_update == True):
return data
else:
content = ''
try:
logging.info('Trying to render %s' % cache_url)
content = templates.Render(path)
except:
logging.getLogger('slave-docs-api').exception(
'Error rendering HTML!')
pass
if len(content) > 0:
logging.info('HTML saved for %s' % cache_url)
ResponseCache.Set(cache_url, content.encode('utf-8'))
return content
def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.characters = []
dirname = os.path.join(HISTORY_DIR, self.created.strftime('%Y%m%d'))
test_dirname = os.path.join(
TEST_HISTORY_DIR, self.created.strftime('%Y%m%d'))
self.fname = os.path.join(dirname, '{}.csv'.format(self.sid))
self.test_fname = os.path.join(test_dirname, '{}.csv'.format(self.sid))
self.dump_file = None
self.closed = False
self.active = False
self.last_active_time = None
self.test = False
self.last_used_character = None
self.open_character = None
class Session(object):
def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.init = self.created
self.characters = []
def add(self, question, answer, **kwargs):
self.cache.add(question, answer, **kwargs)
def reset(self):
self.dump()
self.cache.clean()
self.init = dt.datetime.now()
for c in self.characters:
try:
c.refresh(self.sid)
except NotImplementedError:
pass
def check(self, question, answer, lang):
return self.cache.check(question, answer, lang)
def dump(self):
if not os.path.isdir(DIRNAME):
os.makedirs(DIRNAME)
fname = os.path.join(DIRNAME, '{}.csv'.format(self.sid))
self.cache.dump(fname)
def get_session_data(self):
return self.sdata
def since_idle(self):
if self.cache.last_time is not None:
return (dt.datetime.now() - self.cache.last_time).seconds
else:
return (dt.datetime.now() - self.created).seconds
def since_reset(self):
return (dt.datetime.now() - self.init).seconds
def __repr__(self):
return "<Session {} init {} active {}>".format(self.sid, self.init,
self.cache.last_time)
class Session(object):
def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.init = self.created
self.characters = []
def add(self, question, answer, **kwargs):
self.cache.add(question, answer, **kwargs)
def reset(self):
self.dump()
self.cache.clean()
self.init = dt.datetime.now()
for c in self.characters:
try:
c.refresh(self.sid)
except NotImplementedError:
pass
def check(self, question, answer, lang):
return self.cache.check(question, answer, lang)
def dump(self):
if not os.path.isdir(DIRNAME):
os.makedirs(DIRNAME)
fname = os.path.join(DIRNAME, '{}.csv'.format(self.sid))
self.cache.dump(fname)
def get_session_data(self):
return self.sdata
def since_idle(self):
if self.cache.last_time is not None:
return (dt.datetime.now() - self.cache.last_time).seconds
else:
return (dt.datetime.now() - self.created).seconds
def since_reset(self):
return (dt.datetime.now() - self.init).seconds
def __repr__(self):
return "<Session {} init {} active {}>".format(
self.sid, self.init, self.cache.last_time)
def _HandleSamplesAPI(self, channel_name, real_path):
if real_path.startswith(url_constants.SLAVE_SAMPLES_API_BASE_URL):
key = real_path[len(url_constants.SLAVE_SAMPLES_API_BASE_URL):]
if key == 'apps' or key == 'extensions':
self.response.headers['content-type'] = 'text/plain'
cache_url = None
if key == 'apps':
cache_url = '/trunk/' + key
else:
cache_url = '/' + channel_name + '/' + key
logging.info('Serving API request %s' % cache_url)
data = ResponseCache.Get(cache_url)
if data is None:
self.response.out.write('[]')
logging.error('No samples data. Please regenerate it manually.')
else:
self.response.out.write(data)
else:
self.response.set_status(404)
else:
self.response.set_status(404)
class Session(object):
def __init__(self, sid):
self.sid = sid
self.session_context = SessionContext()
self.cache = ResponseCache()
self.created = dt.datetime.utcnow()
self.characters = []
dirname = os.path.join(HISTORY_DIR, self.created.strftime('%Y%m%d'))
test_dirname = os.path.join(
TEST_HISTORY_DIR, self.created.strftime('%Y%m%d'))
self.fname = os.path.join(dirname, '{}.csv'.format(self.sid))
self.test_fname = os.path.join(test_dirname, '{}.csv'.format(self.sid))
self.dump_file = None
self.closed = False
self.active = False
self.last_active_time = None
self.test = False
self.last_used_character = None
self.open_character = None
def set_test(self, test):
if test:
logger.info("Set test session")
self.test = test
def add(self, record):
if not self.closed:
report_logger.warn("chatbot_log", extra={'data': record})
self.cache.add(record)
self.dump()
self.last_active_time = self.cache.last_time
self.active = True
return True
return False
def rate(self, rate, idx):
return self.cache.rate(rate, idx)
def update(self, idx, **kwargs):
return self.cache.update(idx, **kwargs)
def set_characters(self, characters):
self.characters = characters
for c in self.characters:
if c.type != TYPE_AIML:
continue
prop = c.get_properties()
context = {}
for key in ['weather', 'location', 'temperature']:
if key in prop:
context[key] = prop.get(key)
now = dt.datetime.utcnow()
context['time'] = dt.datetime.strftime(now, '%I:%M %p')
context['date'] = dt.datetime.strftime(now, '%B %d %Y')
try:
c.set_context(self, context)
except Exception as ex:
pass
def close(self):
self.reset()
self.closed = True
def reset(self):
self.cache.clean()
self.last_used_character = None
self.open_character = None
for c in self.characters:
try:
c.refresh(self)
except NotImplementedError:
pass
def check(self, question, answer):
return self.cache.check(question, answer)
def dump(self):
if self.test:
self.dump_file = self.test_fname
else:
self.dump_file = self.fname
return self.test or self.cache.dump(self.dump_file)
def since_idle(self, since):
if self.last_active_time is not None:
return (since - self.last_active_time).total_seconds()
else:
return (since - self.created).total_seconds()
def __repr__(self):
return "<Session {} created {} active {}>".format(
self.sid, self.created, self.cache.last_time)
import os
import sys
import json
import ast
from response_cache import ResponseCache
if len(sys.argv) < 2:
print(
"DANGER! Run reinitialize_database.pl with the parameter 'yes' if you really want to delete and re-create the Response database"
)
sys.exit(0)
if sys.argv[1] != 'yes':
print(
"If you really want to delete and re-create the feedback/Message database, use:"
)
print(" python reinitialize_database.py yes")
sys.exit(0)
#### Create an RTX Feedback management object
response_cache = ResponseCache()
#### Purge and re-create the database
response_cache.create_database()
response_cache.prepopulate_database()
#### Connect to the database
response_cache.connect()
class Session(object):
def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.characters = []
dirname = os.path.join(HISTORY_DIR, self.created.strftime('%Y%m%d'))
test_dirname = os.path.join(
TEST_HISTORY_DIR, self.created.strftime('%Y%m%d'))
self.fname = os.path.join(dirname, '{}.csv'.format(self.sid))
self.test_fname = os.path.join(test_dirname, '{}.csv'.format(self.sid))
self.dump_file = None
self.closed = False
self.active = False
self.last_active_time = None
self.test = False
self.last_used_character = None
self.open_character = None
def set_test(self, test):
if test:
logger.info("Set test session")
self.test = test
def add(self, question, answer, **kwargs):
if not self.closed:
self.cache.add(question, answer, **kwargs)
self.dump()
self.last_active_time = self.cache.last_time
self.active = True
return True
return False
def rate(self, rate, idx):
return self.cache.rate(rate, idx)
def set_characters(self, characters):
self.characters = characters
for c in self.characters:
if c.type != TYPE_AIML:
continue
prop = c.get_properties()
context = {}
for key in ['weather', 'location', 'temperature']:
if key in prop:
context[key] = prop.get(key)
now = dt.datetime.now()
context['time'] = dt.datetime.strftime(now, '%I:%M %p')
context['date'] = dt.datetime.strftime(now, '%B %d %Y')
try:
c.set_context(self, context)
except Exception as ex:
pass
def close(self):
self.reset()
self.closed = True
def reset(self):
self.cache.clean()
self.last_used_character = None
self.open_character = None
for c in self.characters:
try:
c.refresh(self)
except NotImplementedError:
pass
def check(self, question, answer):
return self.cache.check(question, answer)
def dump(self):
if self.test:
self.dump_file = self.test_fname
else:
self.dump_file = self.fname
return self.test or self.cache.dump(self.dump_file)
def get_session_data(self):
return self.sdata
def since_idle(self, since):
if self.last_active_time is not None:
return (since - self.last_active_time).total_seconds()
else:
return (since - self.created).total_seconds()
def __repr__(self):
return "<Session {} created {} active {}>".format(
self.sid, self.created, self.cache.last_time)
class Session(object):
def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.characters = []
dirname = os.path.join(HISTORY_DIR, self.created.strftime('%Y%m%d'))
test_dirname = os.path.join(
TEST_HISTORY_DIR, self.created.strftime('%Y%m%d'))
self.fname = os.path.join(dirname, '{}.csv'.format(self.sid))
self.test_fname = os.path.join(test_dirname, '{}.csv'.format(self.sid))
self.dump_file = None
self.closed = False
self.active = False
self.last_active_time = None
self.test = False
self.last_used_character = None
self.open_character = None
def set_test(self, test):
if test:
logger.info("Set test session")
self.test = test
def add(self, question, answer, **kwargs):
if not self.closed:
self.cache.add(question, answer, **kwargs)
self.dump()
self.last_active_time = self.cache.last_time
self.active = True
if mongoclient is not None and mongoclient.client is not None:
chatlog = {'Question': question, "Answer": answer}
chatlog.update(kwargs)
try:
mongocollection = mongoclient.client['chatbot']['chatlogs']
result = mongocollection.insert_one(chatlog)
logger.info("Added chatlog to mongodb, id %s", result.inserted_id)
except Exception as ex:
mongoclient.client = None
logger.error(traceback.format_exc())
logger.warn("Deactivate mongodb")
return True
return False
def rate(self, rate, idx):
return self.cache.rate(rate, idx)
def set_characters(self, characters):
self.characters = characters
for c in self.characters:
if c.type != TYPE_AIML:
continue
prop = c.get_properties()
context = {}
for key in ['weather', 'location', 'temperature']:
if key in prop:
context[key] = prop.get(key)
now = dt.datetime.now()
context['time'] = dt.datetime.strftime(now, '%I:%M %p')
context['date'] = dt.datetime.strftime(now, '%B %d %Y')
try:
c.set_context(self, context)
except Exception as ex:
pass
def close(self):
self.reset()
self.closed = True
def reset(self):
self.cache.clean()
self.last_used_character = None
self.open_character = None
for c in self.characters:
try:
c.refresh(self)
except NotImplementedError:
pass
def check(self, question, answer):
return self.cache.check(question, answer)
def dump(self):
if self.test:
self.dump_file = self.test_fname
else:
self.dump_file = self.fname
return self.test or self.cache.dump(self.dump_file)
def get_session_data(self):
return self.sdata
def since_idle(self, since):
if self.last_active_time is not None:
return (since - self.last_active_time).total_seconds()
else:
return (since - self.created).total_seconds()
def __repr__(self):
return "<Session {} created {} active {}>".format(
self.sid, self.created, self.cache.last_time)
class Session(object):
def __init__(self, sid):
self.sid = sid
self.sdata = SessionData()
self.cache = ResponseCache()
self.created = dt.datetime.now()
self.init = self.created
self.characters = []
dirname = os.path.join(HISTORY_DIR, self.created.strftime('%Y%m%d'))
test_dirname = os.path.join(TEST_HISTORY_DIR, self.created.strftime('%Y%m%d'))
self.fname = os.path.join(dirname, '{}.csv'.format(self.sid))
self.test_fname = os.path.join(test_dirname, '{}.csv'.format(self.sid))
self.dump_file = None
self.removed = False
self.active = False
self.last_active_time = None
self.test = False
def set_test(self, test):
if test:
logger.info("Set test session")
self.test = test
def add(self, question, answer, **kwargs):
if not self.removed:
self.cache.add(question, answer, **kwargs)
self.last_active_time = self.cache.last_time
self.active = True
return True
return False
def rate(self, rate, idx):
return self.cache.rate(rate, idx)
def reset(self):
self.active = False
self.dump()
self.cache.clean()
self.init = dt.datetime.now()
for c in self.characters:
try:
c.refresh(self.sid)
except NotImplementedError:
pass
def check(self, question, answer, lang):
return self.cache.check(question, answer, lang)
def dump(self):
if self.test:
self.dump_file = self.test_fname
else:
self.dump_file = self.fname
return self.cache.dump(self.dump_file)
def get_session_data(self):
return self.sdata
def since_idle(self, since):
if self.last_active_time is not None:
return (since - self.last_active_time).total_seconds()
else:
return (since - self.created).total_seconds()
def __repr__(self):
return "<Session {} init {} active {}>".format(
self.sid, self.init, self.cache.last_time)
