def process():
ctext = request.form['ctext']
key = resolver(ctext)['key']
plaintext = resolver(ctext)['text']
if key and plaintext:
return jsonify({'key': key,
'text': plaintext})
return jsonify({'error' : 'Missing data!'})
def call_and_build(self):
ret = {self.results_key:{}}
working = ret[self.results_key]
for key, kwargs in self._calls:
if self.pages:
self.result = self.callGAPIpages(key.service, **kwargs)
else:
try:
self.result = self.callGAPI(key.service, **kwargs)
except Exception as e:
ret['errors']['error':'An error occurred']
# TODO: make key name of kind of traceback
continue
if key.sub_keys:
for k in key.sub_keys:
try:
value = resolver.resolver(k, self.result)
except resolver.NotPresentInValue:
continue
subkey_post_callable = key.sub_key_post_dict.get(k)
if subkey_post_callable:
value = subkey_post_callable(value)
# Just use the last part of the resolve path
key_name = k.split('.')[-1]
working[key_name] = self.normalize_value(value)
else:
if '.' in key.key:
try:
value = resolver.resolver(key.key, self.result)
except resolver.NotPresentInValue:
ret[self.error_key]['notPresentNevermind'].append(key.key)
continue
else:
try:
value = resolver.resolver(key.resolve_path, self.result)
except resolver.NotPresentInValue:
ret[self.error_key]['programming': "{} not in self.result, did you forget to set self.default_resolve_path to None?"]
continue
if isinstance(value, dict):
working.update({k:self.normalize_value(v) for k,v in value.items()})
elif isinstance(value, list):
working[key.key] = [self.normalize_value(v) for v in value]
else:
if key.post:
value = key.post(value)
working[key.key] = self.normalize_value(value)
return ret
def check_hash_code_and_call_resolver(hash_code, resolver):
if hash_code == "" or hash_code is None:
abort(http.HTTPStatus.INTERNAL_SERVER_ERROR, "Please include dashboard hashcode")
result = resolver(hash_code)
if "errorMessage" in result:
abort(http.HTTPStatus.INTERNAL_SERVER_ERROR, result["errorMessage"])
return result
def process_equation(tokens_list: List[PolyRows], argv):
__print_row_equation(
"Red for modification and green for the movement of the token.\nThe full equation refactored",
tokens_list, argv, "")
tokens_list = [token for token in tokens_list if token.coef != 0]
tokens_list = __reset_position(tokens_list)
for i, token in enumerate(tokens_list):
token.create_term(i)
__print_row_equation(
"The equation without all the null degree and coefficient and the signs simplified",
tokens_list, argv, "")
while __operator_finder(tokens_list, ["*", "/"]):
calculate_operator(tokens_list, 0)
__print_row_equation(
"The equation with all the multiplication's term simplified",
tokens_list, argv, "")
for i, token in enumerate(tokens_list):
token.change_sign_form_equal(i)
token.change = True
__print_row_equation("The equation with all term in the same side",
tokens_list, argv, "red")
tokens_list = sorted(tokens_list,
key=lambda token: token.degree,
reverse=True)
tokens_list = __reset_position(tokens_list)
for i, token in enumerate(tokens_list):
token.create_term(i)
__print_row_equation("The equation sorted by degree", tokens_list, argv)
while __operator_finder(
tokens_list,
["+", "-"]) and not __definitive_form_checker(tokens_list):
calculate_operator(tokens_list, 1)
__print_row_equation(
"The equation with all the addition's term simplified", tokens_list,
argv)
tokens_list = [token for token in tokens_list if token.coef != 0]
tokens_list = __reset_position(tokens_list)
for i, token in enumerate(tokens_list):
token.create_term(i)
__print_row_equation(
"The equation without all the null degree and coefficient and the signs simplified",
tokens_list, argv)
return resolver(tokens_list)
def main():
resv = resolver.resolver(name='/simple_rpc/test')
resv.add_registry(type='etcd', host='127.0.0.1', port=2379)
# resv.add_registry(type='consul', host='127.0.0.1', port=8500)
# resv.add_registry(type='zookeeper', host='127.0.0.1', port=2181)
# resv.add_registry(type='redis', host='127.0.0.1', port=6379)
resv.resolving()
while 1:
try:
channel = resv.get_channel()
if channel != None:
stub = pb2_grpc.HelloServiceStub(channel)
response = stub.Echo(pb2.Payload(data='hello'))
print(response)
time.sleep(1)
except:
continue
def _create_connection(address, timeout=object(), source_address=None, iplist=None):
"""Connect to *address* and return the socket object.
Convenience function. Connect to *address* (a 2-tuple ``(host,
port)``) and return the socket object. Passing the optional
*timeout* parameter will set the timeout on the socket instance
before attempting to connect. If no *timeout* is supplied, the
global default timeout setting returned by :func:`getdefaulttimeout`
is used. If *source_address* is set it must be a tuple of (host, port)
for the socket to bind as a source address before making the connection.
An host of '' or port 0 tells the OS to use the default.
"""
import resolver
host, port = address
err = None
if not iplist:
iplist = resolver.resolver(host)
if len(iplist) > 1:
random.shuffle(iplist)
iplist = sorted(iplist, key=lambda item: item[0])
for res in iplist:
af, addr = res
sock = None
try:
sock = socket.socket(af)
if timeout is not object():
sock.settimeout(timeout)
if source_address:
sock.bind(source_address)
sock.connect((addr, port))
return sock
except socket.error as _:
err = _
if sock is not None:
sock.close()
if err is not None:
raise err
else:
raise socket.error("getaddrinfo returns an empty list")
def resolve_deps(self, packages):
'''Resolve dependencies for the list of Package-instances, return a
resolver.transactions instance.'''
dep_resolver = resolver.resolver( self.reader, self.regexp_filter,
self.pkgdrv, self.download_file,
self.log )
try:
transactions = dep_resolver.solve_deps( packages )
info = ""
for transaction in transactions.values():
for package in transaction.values():
info = info + \
"\n\t%s: %s, version %s release %s" % \
(package.flag, package.name,
package.version, package.release)
if info != "":
message = "Packages to install/upgrade:%s" % info
self.log.write_log(message)
self.log.write_stdout(message)
except (resolver.DependencyError, resolver.ParseError), errmsg:
raise ResolveException, errmsg
def resolve_deps(self, packages):
'''Resolve dependencies for the list of Package-instances, return a
resolver.transactions instance.'''
dep_resolver = resolver.resolver(self.reader, self.regexp_filter,
self.pkgdrv, self.download_file,
self.log)
try:
transactions = dep_resolver.solve_deps(packages)
info = ""
for transaction in transactions.values():
for package in transaction.values():
info = info + \
"\n\t%s: %s, version %s release %s" % \
(package.flag, package.name,
package.version, package.release)
if info != "":
message = "Packages to install/upgrade:%s" % info
self.log.write_log(message)
self.log.write_stdout(message)
except (resolver.DependencyError, resolver.ParseError), errmsg:
raise ResolveException, errmsg
def listen(self, user_say, user_id, agent_name):
# query=''
# agent_name=input("Please enter the agent name -->")
resolve_ob = resolver()
# while(query!="n"):
# query=input("You-->")
# resolved_query=resolve_ob.resolve(query,agent_name)
# response=chatterbot.get_response(resolved_query['resolved_query'])
# print("response---->",response)
# print("resolved_query-->",resolved_query)
self.out['id'] = str(uuid.uuid4())
ts = time.time()
timestamp = datetime.datetime.fromtimestamp(ts).strftime(
'%Y-%m-%d %H:%M:%S')
self.out['timestamp'] = timestamp
self.out['lang'] = "en"
self.out['result'] = {}
self.out['result']['source'] = agent_name
self.out['result']['resolvedQuery'] = user_say
resolved_query = resolve_ob.resolve(user_say, agent_name)
intentName = chatterbot.get_response(
resolved_query['resolved_query']
) #passing resolved query for the brain to classify intent name
print("intentName:", intentName)
pickle_filename4intents = str("./Agents/" + agent_name + "/" +
agent_name + "_intents.pickle")
pickle_in = open(pickle_filename4intents, "rb")
agent_intents = pickle.load(pickle_in)
pp = pprint.PrettyPrinter(indent=2, depth=6)
# pp.pprint(agent_intents)
if intentName in agent_intents:
self.out['result']['score'] = intentName.confidence
if "actionNparam" in agent_intents[intentName]:
self.out['result']['action'] = agent_intents[intentName][
'actionNparam']['action']
else:
self.out['result']['action'] = ""
self.out['result']['parameters'] = {}
self.out['result']['contexts'] = []
self.out['result']['metadata'] = {}
self.out['result']['fulfillment'] = {}
msg = {}
self.out['result']['fulfillment']['messages'] = []
# self.out['result']['metadata']['intentId']=agent_intents[intentName]['intentId']
# self.load_action_n_param()
if agent_intents[intentName]["fulfillment"][
"enable_webhook_4_intent"] == True:
self.out['result']['metadata']['webhookUsed'] = True
else:
self.out['result']['metadata']['webhookUsed'] = False
if agent_intents[intentName]["fulfillment"][
"enable_webhook_4_slot_filling"] == True:
self.out['result']['metadata'][
'webhookForSlotFillingUsed'] = True
else:
self.out['result']['metadata'][
'webhookForSlotFillingUsed'] = False
self.out['result']['metadata']['intentName'] = str(intentName)
if agent_intents[intentName]["fulfillment"] == 'y':
self.out['result']['fulfillment']['speech'] = ""
msg['type'] = 0
msg['speech'] = ""
self.out['result']['fulfillment']['messages'].append(msg)
else:
#check required parameters
'''fetch response for the triggered intent in a random fashion if it contains
a required param deal with the prompt'''
self.out['result']['fulfillment']['speech'] = (random.choice(
agent_intents[intentName]['responses']))
msg['speech'] = self.out['result']['fulfillment']['speech']
self.out['result']['fulfillment']['messages'].append(msg)
# status={}
pp.pprint(self.out)
from object.function import reduce_functions, print_functions
from parser.dotspec import dotspec_constant_parser, dotspec_function_parser
from parser.dottm import dottm_parser
from printer.cpp import cpp_printer
from resolver import resolver
from utils import log, option_parser
import re
from printer.basic import basic_printer
from parser.header import header_parser
parser = option_parser()
(o, a) = parser.parse_args()
# Registering the Resolver as the default DTD Resolver
xml_parser = etree.XMLParser(load_dtd=True)
xml_parser.resolvers.add(resolver())
etree.set_default_parser(xml_parser)
class source(object):
def __init__(self, library_name, parser, **kwargs):
self.library_name = library_name
self.parser = parser(self.library_name)
self.files = []
if 'index' in kwargs:
local_file = resolver.cache(kwargs['index'])
root = html.parse(local_file)
uris = root.xpath(kwargs['xpath'])
self.files.extend([ kwargs['base'] + f for f in filter(lambda x : re.match(kwargs['regexp'], x), uris) ])
self.files.sort()
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 27 12:07:58 2018
@author: vipkumar
"""
from chatterbot import ChatBot
from resolver import resolver
chatterbot = ChatBot("Approval_engine",
read_only=True,
logic_adapters=[{
'import_path':
'chatterbot.logic.BestMatch'
}, {
'import_path':
'chatterbot.logic.LowConfidenceAdapter',
'threshold':
0.50,
'default_response':
'I am sorry, but I do not understand.'
}])
query = ''
agent_name = input("Please enter the agent name -->")
resolve_ob = resolver()
while (query != "n"):
query = input("You-->")
resolved_query = resolve_ob.resolve(query, agent_name)
response = chatterbot.get_response(resolved_query['resolved_query'])
print("response---->", response)
print("resolved_query-->", resolved_query)
