def get(self, addr):
ctx = ScMemoryContext.Create('ContentHandler_{}'.format(addr))
link_addr = ScAddr(int(addr))
# try to find mime and get content
templ = ScTemplate()
templ.TripleWithRelation(
link_addr,
ScType.EdgeDCommonVar,
ScType.NodeVar >> '_format',
ScType.EdgeAccessVarPosPerm,
Keynodes.Get(Keynodes.NrelFormat))
templ.TripleWithRelation(
'_format',
ScType.EdgeDCommonVar,
ScType.Link >> '_mime',
ScType.EdgeAccessVarPosPerm,
Keynodes.Get(Keynodes.NrelMimeType))
searchRes = ctx.HelperSearchTemplate(templ)
if searchRes.Size() > 0:
mime = ctx.GetLinkContent(searchRes[0]['_mime']).AsString()
data = ctx.GetLinkContent(link_addr)
bdata = data.AsBinary().tobytes()
self.set_header('Content-Type', mime)
self.write(bdata)
self.finish()
def _loggedin(self, user):
email = user['email']
if len(email) == 0:
return
database = db.DataBase()
u = database.get_user_by_email(email)
key = None
if u:
key = database.create_user_key()
u.key = key
database.update_user(u)
else:
role = 0
supers = tornado.options.options.super_emails
if supers and (email in supers):
r = database.get_role_by_name('super')
if r:
role = r.id
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
sc_session = logic.ScSession(self, sctp_client, keys)
key = database.add_user(name=user['name'],
email=email,
avatar=user['picture'],
role=role)
self.set_secure_cookie(self.cookie_user_key, key, 1)
def post(self):
result = '[]'
with SctpClientInstance() as sctp_client:
cmd_addr = ScAddr.parse_from_string(self.get_argument(
u'cmd', None))
# parse arguments
first = True
arg = None
arguments = []
idx = 0
while first or (arg is not None):
arg = ScAddr.parse_from_string(
self.get_argument(u'%d_' % idx, None))
if arg is not None:
# check if sc-element exist
if sctp_client.check_element(arg):
arguments.append(arg)
else:
return logic.serialize_error(
404, "Invalid argument: %s" % arg)
first = False
idx += 1
keys = Keynodes(sctp_client)
result = logic.do_command(sctp_client, keys, cmd_addr, arguments,
self)
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def get(self):
result = '{}'
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
# get user sc-addr
sc_session = logic.ScSession(self, sctp_client, keys)
user_addr = sc_session.get_sc_addr()
if sc_session.email:
is_authenticated = True
else:
is_authenticated = False
roles = []
if is_authenticated:
user_kb_node = sc_session.get_user_kb_node_by_email()
if user_kb_node is not None:
roles = self.get_user_roles(sctp_client, user_kb_node,
keys)
result = {
'sc_addr': user_addr.to_int(),
'is_authenticated': is_authenticated,
'current_lang': sc_session.get_used_language().to_int(),
'default_ext_lang': sc_session.get_default_ext_lang().to_int(),
'email': sc_session.email,
'roles': roles
}
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def post(self):
# parse arguments
first = True
arg = None
arguments = []
idx = 0
while first or (arg is not None):
arg_str = u'%d_' % idx
arg = self.get_argument(arg_str, None)
if arg is not None:
arguments.append(arg)
first = False
idx += 1
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
sc_session = logic.ScSession(self, sctp_client, keys)
res = {}
for addr in arguments:
tooltip = logic.find_tooltip(ScAddr.parse_from_string(addr),
sctp_client, keys,
sc_session.get_used_language())
res[addr] = tooltip
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(res))
def register_user(self, email, user_name):
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
links = sctp_client.find_links_with_content(str(email))
if links and len(links) == 1:
user = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F,
ScElementType.sc_type_node | ScElementType.sc_type_const,
ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
links[0],
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.nrel_email]
)
if user and user[0] and user[0][0]:
results = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_F,
keys[KeynodeSysIdentifiers.Myself],
ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
user[0][0],
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.nrel_registered_user]
)
if results is None:
self.gen_registred_user_relation(sctp_client, keys, user[0][0])
else:
user_node = self.create_ui_user_node_at_kb(sctp_client, keys, email, user_name)
self.gen_registred_user_relation(sctp_client, keys, user_node)
else:
user_node = self.create_ui_user_node_at_kb(sctp_client, keys, email, user_name)
self.gen_registred_user_relation(sctp_client, keys, user_node)
def logout_user_from_kb(self):
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
sc_session = logic.ScSession(self, sctp_client, keys)
links = sctp_client.find_links_with_content(str(sc_session.email))
if links and len(links) == 1:
user = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F,
ScElementType.sc_type_node | ScElementType.sc_type_const,
ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
links[0],
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.nrel_email]
)
results = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_F,
keys[KeynodeSysIdentifiers.Myself],
ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
user[0][0],
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.nrel_authorised_user]
)
if results and results[0] and results[0][1]:
sctp_client.erase_element(results[0][1])
def get(self):
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
langs = logic.get_languages_list(keys[KeynodeSysIdentifiers.languages], sctp_client)
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(langs))
def post(self):
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
sc_session = logic.ScSession(self, sctp_client, keys)
ai = apiai.ApiAI(tornado.options.options.apiai_client_access_token,
tornado.options.options.apiai_subscription_key)
request = ai.text_request()
query = self.get_argument('query', u'')
request.query = query.encode('utf-8')
# TODO: make universal language selection
keynode_lang_ru = keys[KeynodeSysIdentifiers.lang_ru]
used_lang = sc_session.get_used_language()
if (used_lang == keynode_lang_ru):
request.lang = 'ru'
else:
request.lang = 'en'
response = request.getresponse()
result = '[]'
apiRes = json.loads(response.read())
actionResult = apiRes['result']
cmd_addr = sctp_client.find_element_by_system_identifier(
str(actionResult['action']))
if cmd_addr:
arguments = []
parameters = actionResult['parameters']
idx = 1
found = True
while found:
key = 'ui_arg_%d' % idx
idx = idx + 1
found = False
try:
arg_addr = logic.get_by_identifier_translated(
used_lang, keys, sctp_client,
str(parameters[key].encode('utf-8')))
if arg_addr is not None:
arguments.append(arg_addr)
found = True
except KeyError:
break
result = logic.do_command(sctp_client, keys, cmd_addr,
arguments, self)
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def post(self):
lang_addr = ScAddr.parse_from_string(self.get_argument(u'lang_addr', None))
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
sc_session = logic.ScSession(self, sctp_client, keys)
sc_session.set_current_lang_mode(lang_addr)
self.finish()
def get(self):
sctp_client = new_sctp_client()
keys = Keynodes(sctp_client)
langs = logic.get_languages_list(keys[KeynodeSysIdentifiers.languages], sctp_client)
sctp_client.shutdown()
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(langs))
def OnInitialize(self, params):
print('Initialize HTTP module')
print('Initialize keynodes')
Keynodes.Init(__ctx__)
# TODO: parse port
port = 8090
self.server = ServerThread(self)
self.server.start()
def get(self):
result = None
# get arguments
substr = self.get_argument('substr', None)
# connect to redis an try to find identifiers
r = redis.StrictRedis(host = tornado.options.options.redis_host,
port = tornado.options.options.redis_port,
db = tornado.options.options.redis_db_idtf)
result = {}
sys = []
main = []
common = []
max_n = tornado.options.options.idtf_serach_limit
# first of all need to find system identifiers
cursor = 0
while True:
reply = r.scan(cursor, u"idtf:*%s*" % substr, 200)
if not reply or len(reply) == 0:
break
cursor = int(reply[0])
if cursor == 0:
break
for idtf in reply[1]:
if len(sys) == max_n and len(main) == max_n and len(common) == max_n:
break
rep = r.get(idtf)
utf = idtf.decode('utf-8')
addr = ScAddr.parse_binary(rep)
if utf.startswith(u"idtf:sys:") and len(sys) < max_n:
sys.append([addr.to_id(), utf[9:]])
elif utf.startswith(u"idtf:main:") and len(main) < max_n:
main.append([addr.to_id(), utf[10:]])
elif utf.startswith(u"idtf:common:") and len(common) < max_n:
common.append([addr.to_id(), utf[12:]])
sctp_client = new_sctp_client()
keys = Keynodes(sctp_client)
keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf]
keynode_nrel_system_identifier = keys[KeynodeSysIdentifiers.nrel_system_identifier]
keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf]
result[keynode_nrel_system_identifier.to_id()] = sys
result[keynode_nrel_main_idtf.to_id()] = main
result[keynode_nrel_idtf.to_id()] = common
sctp_client.shutdown()
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def post(self):
lang_addr = ScAddr.parse_from_string(self.get_argument(u'lang_addr', None))
sctp_client = new_sctp_client()
keys = Keynodes(sctp_client)
sc_session = logic.ScSession(self, sctp_client, keys)
sc_session.set_current_lang_mode(lang_addr)
sctp_client.shutdown()
self.set_header("Content-Type", "application/json")
self.finish()
def get(self):
result = '{}'
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
keynode_ui_main_menu = keys[KeynodeSysIdentifiers.ui_main_menu]
keynode_ui_external_languages = keys[
KeynodeSysIdentifiers.ui_external_languages]
keynode_languages = keys[KeynodeSysIdentifiers.languages]
# try to find main menu node
cmds = logic.parse_menu_command(keynode_ui_main_menu, sctp_client,
keys)
if cmds is None:
cmds = {}
# try to find available output languages
res_out_langs = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_3F_A_A,
keynode_ui_external_languages,
ScElementType.sc_type_arc_pos_const_perm,
ScElementType.sc_type_node | ScElementType.sc_type_const)
out_langs = []
if (res_out_langs is not None):
for items in res_out_langs:
out_langs.append(items[2].to_int())
# try to find available output natural languages
langs = logic.get_languages_list(keynode_languages, sctp_client)
langs_str = []
for l in langs:
langs_str.append(l.to_int())
# get user sc-addr
sc_session = logic.ScSession(self, sctp_client, keys)
user_addr = sc_session.get_sc_addr()
result = {
'menu_commands': cmds,
'languages': langs_str,
'external_languages': out_langs,
'user': {
'sc_addr': user_addr.to_int(),
'is_authenticated': False,
'current_lang': sc_session.get_used_language().to_int(),
'default_ext_lang':
sc_session.get_default_ext_lang().to_int()
}
}
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def get(self):
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
keynode_ui_main_menu = keys[KeynodeSysIdentifiers.ui_main_menu]
keynode_ui_external_languages = keys[KeynodeSysIdentifiers.ui_external_languages]
keynode_languages = keys[KeynodeSysIdentifiers.languages]
# try to find main menu node
cmds = []
logic.find_atomic_commands(keynode_ui_main_menu, sctp_client, keys, cmds)
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(cmds))
def get(self):
result = '{}'
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
# get user sc-addr
sc_session = logic.ScSession(self, sctp_client, keys)
user_addr = sc_session.get_sc_addr()
result = {
'sc_addr': user_addr.to_int(),
'is_authenticated': False,
'current_lang': sc_session.get_used_language().to_int(),
'default_ext_lang': sc_session.get_default_ext_lang().to_int()
}
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def get(self):
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format]
keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype]
# parse arguments
addr = ScAddr.parse_from_string(self.get_argument('addr', None))
if addr is None:
return serialize_error(self, 404, 'Invalid arguments')
result = sctp_client.get_link_content(addr)
if result is None:
return serialize_error(self, 404, 'Content not found')
self.set_header("Content-Type", logic.get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client))
self.finish(result)
def post(self):
sctp_client = new_sctp_client()
# parse arguments
first = True
arg = None
arguments = []
idx = 0
while first or (arg is not None):
arg_str = u'%d_' % idx
arg = ScAddr.parse_from_string(self.get_argument(arg_str, None))
if arg is not None:
arguments.append(arg)
first = False
idx += 1
keys = Keynodes(sctp_client)
keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format]
keynode_format_txt = keys[KeynodeSysIdentifiers.format_txt]
result = {}
for arg in arguments:
# try to resolve format
format = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F,
arg,
ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
ScElementType.sc_type_node | ScElementType.sc_type_const,
ScElementType.sc_type_arc_pos_const_perm,
keynode_nrel_format
)
if format is not None:
result[arg.to_id()] = format[0][2].to_id()
else:
result[arg.to_id()] = keynode_format_txt.to_id()
sctp_client.shutdown()
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def authorise_user(self, email):
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
links = sctp_client.find_links_with_content(str(email))
if links and len(links) == 1:
user = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F,
ScElementType.sc_type_node | ScElementType.sc_type_const,
ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
links[0],
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.nrel_email]
)
bin_arc_authorised = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
keys[KeynodeSysIdentifiers.Myself], user[0][0])
sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.nrel_authorised_user], bin_arc_authorised)
def post(self):
result = None
# get arguments
idx = 1
arguments = []
arg = ''
while arg is not None:
arg = self.get_argument(u'%d_' % idx, None)
if arg is not None:
arguments.append(arg)
idx += 1
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
sc_session = logic.ScSession(self, sctp_client, keys)
used_lang = sc_session.get_used_language()
result = {}
# get requested identifiers for arguments
for addr_str in arguments:
addr = ScAddr.parse_from_string(addr_str)
if addr is None:
self.clear()
self.set_status(404)
self.finish('Can\'t parse sc-addr from argument: %s' %
addr_str)
found = False
idtf_value = logic.get_identifier_translated(
addr, used_lang, keys, sctp_client)
if idtf_value:
result[addr_str] = idtf_value
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def post(self):
result = '[]'
with SctpClientInstance() as sctp_client:
cmd_addr = ScAddr.parse_from_string(self.get_argument(u'cmd', None))
# parse arguments
first = True
arg = None
arguments = []
idx = 0
while first or (arg is not None):
arg = ScAddr.parse_from_string(self.get_argument(u'%d_' % idx, None))
if arg is not None:
# check if sc-element exist
if sctp_client.check_element(arg):
arguments.append(arg)
else:
return serialize_error(404, "Invalid argument: %s" % arg)
first = False
idx += 1
if (len(arguments) > 0) and (cmd_addr is not None):
keys = Keynodes(sctp_client)
keynode_ui_rrel_commnad = keys[KeynodeSysIdentifiers.ui_rrel_commnad]
keynode_ui_rrel_command_arguments = keys[KeynodeSysIdentifiers.ui_rrel_command_arguments]
keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result]
keynode_ui_command_generate_instance = keys[KeynodeSysIdentifiers.ui_command_generate_instance]
keynode_ui_command_initiated = keys[KeynodeSysIdentifiers.ui_command_initiated]
keynode_ui_command_finished = keys[KeynodeSysIdentifiers.ui_command_finished]
keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result]
keynode_ui_user = keys[KeynodeSysIdentifiers.ui_user]
keynode_nrel_authors = keys[KeynodeSysIdentifiers.nrel_authors]
keynode_question_initiated = keys[KeynodeSysIdentifiers.question_initiated]
keynode_question = keys[KeynodeSysIdentifiers.question]
keynode_system_element = keys[KeynodeSysIdentifiers.system_element]
keynode_nrel_ui_nrel_command_lang_template = keys[KeynodeSysIdentifiers.nrel_ui_nrel_command_lang_template]
keynode_languages = keys[KeynodeSysIdentifiers.languages]
keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf]
# create command in sc-memory
inst_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const)
logic.append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_addr)
arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_generate_instance, inst_cmd_addr)
logic.append_to_system_elements(sctp_client, keynode_system_element, arc)
inst_cmd_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, cmd_addr)
logic.append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_arc)
arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_commnad, inst_cmd_arc)
logic.append_to_system_elements(sctp_client, keynode_system_element, arc)
# create arguments
args_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const)
logic.append_to_system_elements(sctp_client, keynode_system_element, args_addr)
args_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, args_addr)
logic.append_to_system_elements(sctp_client, keynode_system_element, args_arc)
arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_command_arguments, args_arc)
logic.append_to_system_elements(sctp_client, keynode_system_element, arc)
idx = 1
for arg in arguments:
arg_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, args_addr, arg)
logic.append_to_system_elements(sctp_client, keynode_system_element, arg_arc)
if arg_arc is None:
return serialize_error(self, 404, 'Error while create "create_instance" command')
idx_addr = sctp_client.find_element_by_system_identifier(str(u'rrel_%d' % idx))
if idx_addr is None:
return serialize_error(self, 404, 'Error while create "create_instance" command')
idx += 1
arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, idx_addr, arg_arc)
logic.append_to_system_elements(sctp_client, keynode_system_element, arc)
wait_time = 0
wait_dt = 0.1
# initialize command
arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_initiated, inst_cmd_addr)
cmd_finished = logic.check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client)
while cmd_finished is None:
time.sleep(wait_dt)
wait_time += wait_dt
if wait_time > tornado.options.options.event_wait_timeout:
return serialize_error(self, 404, 'Timeout waiting for "create_instance" command finished')
cmd_finished = logic.check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client)
# get command result
cmd_result = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F,
inst_cmd_addr,
ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
ScElementType.sc_type_node | ScElementType.sc_type_const,
ScElementType.sc_type_arc_pos_const_perm,
keynode_ui_nrel_command_result
)
if cmd_result is None:
return serialize_error(self, 404, 'Can\'t find "create_instance" command result')
cmd_result = cmd_result[0][2]
# @todo support all possible commands
# try to find question node
question = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F,
keynode_question,
ScElementType.sc_type_arc_pos_const_perm,
ScElementType.sc_type_node | ScElementType.sc_type_const,
ScElementType.sc_type_arc_pos_const_perm,
cmd_result
)
if question is None:
return serialize_error(self, 404, "Can't find question node")
question = question[0][2]
logic.append_to_system_elements(sctp_client, keynode_system_element, question)
# generate main identifiers
langs = logic.get_languages_list(keynode_languages, sctp_client)
if langs:
templates = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F,
cmd_addr,
ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
ScElementType.sc_type_link,
ScElementType.sc_type_arc_pos_const_perm,
keynode_nrel_ui_nrel_command_lang_template
)
if templates:
generated = {}
identifiers = {}
# get identifiers
for l in langs:
identifiers[str(l)] = {}
for a in arguments:
idtf_value = logic.get_identifier_translated(a, l, keys, sctp_client)
if idtf_value:
identifiers[str(l)][str(a)] = idtf_value
for t in templates:
input_arcs = sctp_client.iterate_elements(
SctpIteratorType.SCTP_ITERATOR_3A_A_F,
ScElementType.sc_type_node | ScElementType.sc_type_const | ScElementType.sc_type_node_class,
ScElementType.sc_type_arc_pos_const_perm,
t[2])
if input_arcs:
for arc in input_arcs:
for l in langs:
if not generated.has_key(str(l)) and arc[0] == l:
lang_idtfs = identifiers[str(l)]
# get content of link
data = sctp_client.get_link_content(t[2]).decode('utf-8')
if data:
for idx in xrange(len(arguments)):
value = arguments[idx].to_id()
if lang_idtfs.has_key(str(arguments[idx])):
value = lang_idtfs[str(arguments[idx])]
data = data.replace(u'$ui_arg_%d' % (idx + 1), value)
# generate identifier
idtf_link = sctp_client.create_link()
sctp_client.set_link_content(idtf_link, str(data.encode('utf-8')))
sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, l, idtf_link)
bin_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const,
question, idtf_link)
sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm,
keynode_nrel_main_idtf, bin_arc)
generated[str(l)] = True
# create author
sc_session = logic.ScSession(self, sctp_client, keys)
user_node = sc_session.get_sc_addr()
if not user_node:
return serialize_error(self, 404, "Can't resolve user node")
arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_user, user_node)
logic.append_to_system_elements(sctp_client, keynode_system_element, arc)
author_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, user_node)
logic.append_to_system_elements(sctp_client, keynode_system_element, author_arc)
arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_authors, author_arc)
logic.append_to_system_elements(sctp_client, keynode_system_element, arc)
# initiate question
arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_question_initiated, question)
logic.append_to_system_elements(sctp_client, keynode_system_element, arc)
# first of all we need to wait answer to this question
#print sctp_client.iterate_elements(SctpIteratorType.SCTP_ITERATOR_3F_A_A, keynode_question_initiated, 0, 0)
result = { 'question': question.to_id() }
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def get(self):
result = None
# get arguments
substr = self.get_argument('substr', None)
# connect to redis an try to find identifiers
r = redis.StrictRedis(host=tornado.options.options.redis_host,
port=tornado.options.options.redis_port,
db=tornado.options.options.redis_db_idtf)
result = {}
sys = []
main = []
common = []
max_n = tornado.options.options.idtf_serach_limit
def appendSorted(array, data):
if len(array) > 0:
idx = 0
inserted = False
for idx in xrange(len(array)):
if len(array[idx][1]) > len(data[1]):
array.insert(idx, data)
inserted = True
break
idx = idx + 1
if not inserted and len(array) < max_n:
array.append(data)
if (len(array) > max_n):
array.pop()
else:
array.append(data)
# first of all need to find system identifiers
cursor = 0
while True:
reply = r.scan(cursor, u"idtf:*%s*" % substr, 1000)
if not reply or len(reply) == 0:
break
cursor = int(reply[0])
for idtf in reply[1]:
if len(sys) == max_n and len(main) == max_n and len(
common) == max_n:
break
rep = r.get(idtf)
utf = idtf.decode('utf-8')
addr = ScAddr.parse_binary(rep)
if utf.startswith(u"idtf:sys:") and len(sys) < max_n:
appendSorted(sys, [addr.to_int(), utf[9:]])
elif utf.startswith(u"idtf:main:") and len(main) < max_n:
appendSorted(main, [addr.to_int(), utf[10:]])
elif utf.startswith(u"idtf:common:") and len(common) < max_n:
appendSorted(common, [addr.to_int(), utf[12:]])
if cursor == 0:
break
with SctpClientInstance() as sctp_client:
keys = Keynodes(sctp_client)
keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf]
keynode_nrel_system_identifier = keys[
KeynodeSysIdentifiers.nrel_system_identifier]
keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf]
result['sys'] = sys
result['main'] = main
result['common'] = common
self.set_header("Content-Type", "application/json")
self.finish(json.dumps(result))
def post(self):
with SctpClientInstance() as sctp_client:
question_addr = ScAddr.parse_from_string(
self.get_argument(u'question', None))
format_addr = ScAddr.parse_from_string(
self.get_argument(u'format', None))
keys = Keynodes(sctp_client)
keynode_nrel_answer = keys[
KeynodeSysIdentifiers.question_nrel_answer]
keynode_nrel_translation = keys[
KeynodeSysIdentifiers.nrel_translation]
keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format]
keynode_system_element = keys[KeynodeSysIdentifiers.system_element]
# try to find answer for the question
wait_time = 0
wait_dt = 0.1
answer = logic.find_answer(question_addr, keynode_nrel_answer,
sctp_client)
while answer is None:
time.sleep(wait_dt)
wait_time += wait_dt
if wait_time > tornado.options.options.event_wait_timeout:
return logic.serialize_error(self, 404,
'Timeout waiting for answer')
answer = logic.find_answer(question_addr, keynode_nrel_answer,
sctp_client)
if answer is None:
return logic.serialize_error(self, 404, 'Answer not found')
answer_addr = answer[0][2]
# try to find translation to specified format
result_link_addr = logic.find_translation_with_format(
answer_addr, format_addr, keynode_nrel_format,
keynode_nrel_translation, sctp_client)
# if link addr not found, then run translation of answer to specified format
if result_link_addr is None:
trans_cmd_addr = sctp_client.create_node(
ScElementType.sc_type_node | ScElementType.sc_type_const)
logic.append_to_system_elements(sctp_client,
keynode_system_element,
trans_cmd_addr)
arc_addr = sctp_client.create_arc(
ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr,
answer_addr)
logic.append_to_system_elements(sctp_client,
keynode_system_element,
arc_addr)
arc_addr = sctp_client.create_arc(
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.ui_rrel_source_sc_construction],
arc_addr)
logic.append_to_system_elements(sctp_client,
keynode_system_element,
arc_addr)
arc_addr = sctp_client.create_arc(
ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr,
format_addr)
logic.append_to_system_elements(sctp_client,
keynode_system_element,
arc_addr)
arc_addr = sctp_client.create_arc(
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.ui_rrel_output_format],
arc_addr)
logic.append_to_system_elements(sctp_client,
keynode_system_element,
arc_addr)
# add into translation command set
arc_addr = sctp_client.create_arc(
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.ui_command_translate_from_sc],
trans_cmd_addr)
logic.append_to_system_elements(sctp_client,
keynode_system_element,
arc_addr)
# initialize command
arc_addr = sctp_client.create_arc(
ScElementType.sc_type_arc_pos_const_perm,
keys[KeynodeSysIdentifiers.ui_command_initiated],
trans_cmd_addr)
logic.append_to_system_elements(sctp_client,
keynode_system_element,
arc_addr)
# now we need to wait translation result
wait_time = 0
translation = logic.find_translation_with_format(
answer_addr, format_addr, keynode_nrel_format,
keynode_nrel_translation, sctp_client)
while translation is None:
time.sleep(wait_dt)
wait_time += wait_dt
if wait_time > tornado.options.options.event_wait_timeout:
return logic.serialize_error(
self, 404,
'Timeout waiting for answer translation')
translation = logic.find_translation_with_format(
answer_addr, format_addr, keynode_nrel_format,
keynode_nrel_translation, sctp_client)
if translation is not None:
result_link_addr = translation
# if result exists, then we need to return it content
if result_link_addr is not None:
result = json.dumps({"link": result_link_addr.to_int()})
self.set_header("Content-Type", "application/json")
self.finish(result)
