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.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)