def genDivideRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]] #divident
el2 = math2sc.variables_sc[operation[1]] #divisor
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #difference result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
#gen input sum parameters
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "произведение*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, sumNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), sumNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
def run_command(_params, _segment):
# trying to find command node
session = core.Kernel.session()
segment = core.Kernel.segment()
# getting answer sheaf node
command_sheaf = session.search_one_shot(session.sc_constraint_new(sc_core.constants.CONSTR_5_f_a_a_a_f,
keynodes.ui.init_user_cmd,
sc_core.pm.SC_A_CONST,
sc_core.pm.SC_N_CONST,
sc_core.pm.SC_A_CONST,
_params), True, 5)
if command_sheaf is None: return # do nothing
cmd = command_sheaf[2]
# check if it's command to play commands sequence
command = session.search_one_shot(session.sc_constraint_new(sc_core.constants.CONSTR_3_f_a_f,
key_cmd_user_play,
sc_core.pm.SC_A_CONST,
cmd), True, 3)
if command is None: return # do nothing
command = session.search_one_shot(session.sc_constraint_new(sc_core.constants.CONSTR_3_f_a_a,
cmd,
sc_core.pm.SC_A_CONST,
sc_core.pm.SC_N_CONST), True, 3)
if command is None: return # do nothing
cmd = command[2]
import suit.core.sc_utils as sc_utils
sc_utils.createPairPosPerm(session, segment, keynodes.ui.init_base_user_cmd, cmd, sc_core.pm.SC_CONST)
def translate_value(session, _segment, _value_node, _value):
"""Setup value \p _value to \p _value_node
@return: Return list of creates sc-elements
"""
v_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
bin_pair = sc_utils.createPairBinaryOrientFull(session, _segment, v_node, _value_node, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_value, bin_pair[0], sc.SC_CONST)
res = [v_node, a, keynodes.common.nrel_value]
res.extend(bin_pair)
vu_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, _segment, v_node, vu_node, sc.SC_CONST)
res.extend([vu_node, a])
# make identification
idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST)
bin_pair = sc_utils.createPairBinaryOrientFull(session, _segment, idtf_node, vu_node, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_identification, bin_pair[0], sc.SC_CONST)
res.extend([idtf_node, a, keynodes.common.nrel_identification])
res.extend(bin_pair)
# set value
val = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
sc_utils.setContentReal(session, _segment, val, _value)
a = sc_utils.createPairPosPerm(session, _segment, idtf_node, val, sc.SC_CONST)
a1 = sc_utils.createPairPosPerm(session, _segment, keynodes.common.rrel_dec_number, a, sc.SC_CONST)
res.extend([val, a, a1, keynodes.common.rrel_dec_number])
return res
def translate_value(_segment, _value_node, _value):
session = core.Kernel.session()
v_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
sheaf = sc_utils.createPairBinaryOrient(session, _segment, v_node,
_value_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_value,
sheaf, sc.SC_CONST)
vu_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, _segment, v_node, vu_node,
sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
geom_keynodes.Relation.rrel_cm2, a, sc.SC_CONST)
# make identification
idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST)
sheaf = sc_utils.createPairBinaryOrient(session, _segment, idtf_node,
vu_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
keynodes.common.nrel_identification, sheaf,
sc.SC_CONST)
# set value
val = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
sc_utils.setContentReal(session, _segment, val, _value)
a = sc_utils.createPairPosPerm(session, _segment, idtf_node, val,
sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
keynodes.common.rrel_dec_number, a, sc.SC_CONST)
def translate_quadrangle(_segment, _object, _params):
"""Translates circle object to sc-memory
"""
_addr = _object._getScAddr()
# include sc-element to points
session = core.Kernel.session()
addToSets(session, _segment, _addr, [
geom_keynodes.Objects.plane_quadrangle,
keynodes.info.stype_ext_obj_abstract
])
sides = _object.getSides()
for obj in sides:
sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr,
obj._getScAddr(), sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
geom_keynodes.Relation.nrel_side, sheaf,
sc.SC_CONST)
# build square relation
#sq_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
#sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, sq_node, sc.SC_CONST)
#sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_square, sheaf, sc.SC_CONST)
return True
def genEqualityRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
idtf = "равенство*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
eqNode = sc_utils.getElementByIdtf(idtf, segment)
if eqNode == None:
eqNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
eqNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, eqNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), eqNode,
setNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return el1
def translate_circle(_segment, _object, _params):
"""Translates circle object to sc-memory
"""
_addr = _object._getScAddr()
# include sc-element to points
session = core.Kernel.session()
addToSets(session, _segment, _addr, [geom_keynodes.Objects.circle, keynodes.info.stype_ext_obj_abstract])
# add relation to center point
addr_begin = _object.center_point._getScAddr()
if not sc_utils.checkOutBinaryPairAttr(session, _addr, geom_keynodes.Relation.nrel_center, sc.SC_CONST):
a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_begin, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_center, a1, sc.SC_CONST)
if not sc_utils.checkOutBinaryPairAttr(session, _addr, geom_keynodes.Relation.nrel_radius, sc.SC_CONST):
radius_obj = _object.getRadiusObject()
if radius_obj is not None:
a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, radius_obj._getScAddr(), sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_radius, a1, sc.SC_CONST)
# translate child points
translateChildPoints(session, _segment, _object)
# translate radius if it exist
return True
def createWindowFromNode(_node, _format, _is_edit):
"""Creates sc.g-window from sc.g-node
@param _node: node to create window from
@type _node: ScgNode
@param _format: sc-element that designate format for node content
@type _format: sc_global_addr
@param _is_edit: flag to create editor
@type _is_edit: boolean
@return: window object
@rtype: objects.ObjectSheet
"""
assert type(_node) is scg_objects.SCgNode
session = core.Kernel.session()
segment = core.Kernel.segment()
parent = _node.parent
# creating sc-element that designate window
el = _node._getScAddr()
if el is not None:
# FIXME: changing type for variable
session.change_type(el, sc.SC_N_CONST)
# else:
# el = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
sheet = objects.ObjectSheet()
if el is not None:
sheet._setScAddr(el)
sheet.hideContent()
logic = None
if _is_edit:
logic = core.Kernel.getSingleton().createEditor(_format)
else:
logic = core.Kernel.getSingleton().createViewer(_format)
# including window to formats set
sc_utils.createPairPosPerm(session, segment, _format, el, sc.SC_CONST)
sheet.setLogic(logic)
parent.addChild(sheet)
sheet.setPosition(_node.getPosition())
# FIXME: removing for old window types
_node._relinkToObject(sheet)
parent._deleteObject(_node)
# need to remove
if _format.this == keynodes.ui.format_scgx.this:
import suit.core.layout.LayoutGroupForceDirected as layout
sheet.setLayoutGroup(layout.LayoutGroupForceSimple())
# linking by relation with parent
# sheaf = sc_utils.createPairBinaryOrient(session, segment, parent._getScAddr(), el, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, segment, keynodes.ui.nrel_child_window, sheaf, sc.SC_CONST)
return sheet
def calculate_graph_prop(_params, _segment):
kernel = core.Kernel.getSingleton()
session = kernel.session()
segment = kernel.segment()
# check type
question = session.search_one_shot(session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f,
keynodes.questions.initiated,
sc.SC_A_CONST,
sc.SC_N_CONST,
sc.SC_A_CONST,
_params), True, 5)
assert question is not None
question = question[2]
global graph_prop_calculators
for question_type, calculator, relation in graph_prop_calculators:
# check command type
if sc_utils.checkIncToSets(session, question, [question_type], sc.SC_CONST):
graph = session.search_one_shot(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
question,
sc.SC_A_CONST,
sc.SC_N_CONST), True, 3)
if graph is None:
return
graph = graph[2]
if not sc_utils.checkIncToSets(session, graph, [graph_keynodes.Common.graph], sc.SC_CONST):
return
g = Graph(segment, graph)
g.makeNxGraph()
result = calculator(g.graphNx)
if result is None:
raise RuntimeWarning("Calculator can't calculate value")
value = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
bin_rel = sc_utils.createPairBinaryOrientFull(session, segment, graph, value, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, segment, relation, bin_rel[0], sc.SC_CONST)
elements = translate_value(session, segment, value, result)
elements.extend([value, graph, a, relation])
elements.extend(bin_rel)
answer = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
for el in elements:
sc_utils.createPairPosPerm(session, segment, answer, el, sc.SC_CONST)
sc_utils.makeAnswer(session, segment, question, answer)
def translate_line_sec(_segment, _object, _params):
"""Translates line section to sc-memory
"""
_addr = _object._getScAddr()
session = core.Kernel.session()
if not _addr:
_addr = sc_utils.createNodeStruct(session, _segment, sc.SC_CONST)
_object._setScAddr(_addr)
addToSets(session, _segment, _addr,
[geom_keynodes.Objects.line_sector, keynodes.info.stype_struct])
# end begin points
addr_begin = _object.getBegin()._getScAddr()
addr_end = _object.getEnd()._getScAddr()
assert addr_begin and addr_end
a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_begin,
sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
geom_keynodes.Relation.nrel_border_point, a1,
sc.SC_CONST)
a2 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_end,
sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
geom_keynodes.Relation.nrel_border_point, a2,
sc.SC_CONST)
# check if line have length and build it value
# set value if it exists
# if _object.getLength() is not None:
# len_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
# sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, len_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_length, sheaf, sc.SC_CONST)
#
# len_val_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
# sheaf = sc_utils.createPairBinaryOrient(session, _segment, len_val_node, len_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_value, sheaf, sc.SC_CONST)
#
# len_val_cm_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
# a = sc_utils.createPairPosPerm(session, _segment, len_val_node, len_val_cm_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.rrel_cm, a, sc.SC_CONST)
#
# idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST)
# sheaf = sc_utils.createPairBinaryOrient(session, _segment, idtf_node, len_val_cm_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_identification, sheaf, sc.SC_CONST)
#
# dec_val_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
# session.set_content_real(dec_val_node, _object.getLength())
# a = sc_utils.createPairPosPerm(session, _segment, idtf_node, dec_val_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, keynodes.common.rrel_dec_number, a, sc.SC_CONST)
# translate child points
translateChildPoints(session, _segment, _object)
return True
def addToSets(_session, _segment, _addr, _sets):
"""Create positive pair between each element of \p _sets list and \p _addr
"""
for _set in _sets:
if not sc_utils.checkIncToSets(
_session, _addr, [_set],
sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
sc_utils.createPairPosPerm(_session, _segment, _set, _addr,
sc.SC_CONST)
def genSumRelation(session, segment, operation, _result):
"""
@param session: session
@param segment: list of segments to search objects in
@param operation: sum operation and list of operands
@param _result: a node which the result of translation
@return: a node that represents the result of summ
"""
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def buildUserAtomQuestion(sc_qustions, sc_q_objects):
# узел вопроса
q_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
# добавляем во множество вопрос
session.gen3_f_a_f(segment, sc_key.questions.question, q_node,
sc.SC_A_CONST | sc.SC_POS)
# добавляем во множество атомарный вопрос
session.gen3_f_a_f(segment, sc_key.questions.atom, q_node,
sc.SC_A_CONST | sc.SC_POS)
# добавляем типы вопросов
for sc_q in sc_qustions:
session.gen3_f_a_f(segment, sc_q, q_node, sc.SC_A_CONST | sc.SC_POS)
# добавляем объекты вопроса
for sc_o in sc_q_objects:
session.gen3_f_a_f(segment, q_node, sc_o, sc.SC_A_CONST | sc.SC_POS)
# добавляем автора (пользователь)
authors_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment, authors_node,
sc_core.Kernel.getSingleton().getUserAddr(),
sc.SC_CONST)
authors_pair_sheaf = sc_utils.createPairBinaryOrient(
session, segment, q_node, authors_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment, sc_key.common.nrel_authors,
authors_pair_sheaf, sc.SC_CONST)
# добавляем окна для вывода
output_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
output_count = 0
it = session.create_iterator(
session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
sc_key.ui.set_output_windows, sc.SC_ARC, 0),
True)
while not it.is_over():
sc_utils.createPair(session, segment, output_node, it.value(2),
session.get_type(it.value(1)))
output_count += 1
it.next()
if output_count == 0:
sc_utils.createPairPosPerm(session, segment, output_node,
kernel.getMainWindow()._getScAddr(),
sc.SC_CONST)
#sc_utils.copySet(session, sc_key.ui.set_output_windows, output_node, segment)
# link output windows set to question
output_sheaf = sc_utils.createPairBinaryOrient(session, segment,
output_node, q_node,
sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment,
sc_key.ui.nrel_set_of_output_windows,
output_sheaf, sc.SC_CONST)
# initiate question
sc_utils.createPairPosPerm(session, segment, sc_key.questions.initiated,
q_node, sc.SC_CONST)
return q_node
def translate_line_sec(_segment, _object, _params):
"""Translates line section to sc-memory
"""
_addr = _object._getScAddr()
session = core.Kernel.session()
if not _addr:
_addr = sc_utils.createNodeStruct(session, _segment, sc.SC_CONST)
_object._setScAddr(_addr)
addToSets(session, _segment, _addr, [geom_keynodes.Objects.line_sector, keynodes.info.stype_struct])
# end begin points
addr_begin = _object.getBegin()._getScAddr()
addr_end = _object.getEnd()._getScAddr()
assert addr_begin and addr_end
a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_begin, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_border_point, a1, sc.SC_CONST)
a2 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_end, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_border_point, a2, sc.SC_CONST)
# check if line have length and build it value
# set value if it exists
# if _object.getLength() is not None:
# len_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
# sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, len_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_length, sheaf, sc.SC_CONST)
#
# len_val_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
# sheaf = sc_utils.createPairBinaryOrient(session, _segment, len_val_node, len_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_value, sheaf, sc.SC_CONST)
#
# len_val_cm_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
# a = sc_utils.createPairPosPerm(session, _segment, len_val_node, len_val_cm_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.rrel_cm, a, sc.SC_CONST)
#
# idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST)
# sheaf = sc_utils.createPairBinaryOrient(session, _segment, idtf_node, len_val_cm_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_identification, sheaf, sc.SC_CONST)
#
# dec_val_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
# session.set_content_real(dec_val_node, _object.getLength())
# a = sc_utils.createPairPosPerm(session, _segment, idtf_node, dec_val_node, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, _segment, keynodes.common.rrel_dec_number, a, sc.SC_CONST)
# translate child points
translateChildPoints(session, _segment, _object)
return True
def translateChildPoints(_session, _segment, _object):
"""Translate points, that lies on \p _object
"""
assert isinstance(_object, geom_objects.GeometryAbstractObject)
obj_addr = _object._getScAddr()
assert obj_addr is not None
for _point, _pos in _object.getPoints():
pt_addr = _point._getScAddr()
assert pt_addr is not None
if not sc_utils.checkIncToSets(_session, pt_addr, [obj_addr], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
sc_utils.createPairPosPerm(_session, _segment, obj_addr, pt_addr, sc.SC_CONST)
def gen_function(name, params, session, segment, _result):
"""
@param name: function name
@param params: list of function params
@param _result: an output node of the translator
@return:
"""
#gen function node
idtf = name + "*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
funcNode = sc_utils.getElementByIdtf(idtf, segment)
if funcNode == None:
funcNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
funcNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, funcNode,
sc.SC_CONST)
#gen args set
argsSet = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, argsSet,
sc.SC_CONST)
for x in params:
param = math2sc.variables_sc[x]
arc = sc_utils.createPair(session, core.Kernel.segment(), argsSet,
param, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, param,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc,
sc.SC_CONST)
pass
#gen relation arc
result = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
relation = sc_utils.createPair(session, core.Kernel.segment(), argsSet,
result, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
arc = sc_utils.createPair(session, core.Kernel.segment(), funcNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc,
sc.SC_CONST)
return result
def makeScGraph(self):
"""Construct sc representation of netwokX graph
@return: Return sc_addr of structure, that include all elements of generated sc-graph construction
"""
assert self.graphSc is None
assert self.graphNx is not None
_session = core.Kernel.session()
result = sc_utils.createNode(_session, self.segment, sc.SC_CONST, "element")
self.graphSc = sc_utils.createNode(_session, self.segment, sc.SC_CONST, "struct")
a = sc_utils.createPairPosPerm(_session, self.segment, graph_keynodes.Common.graph, self.graphSc, sc.SC_CONST)
res_list = [self.graphSc, a]
nx2sc = {}
# create all nodes
for node in self.graphNx.nodes():
sc_node = sc_utils.createNode(_session, self.segment, sc.SC_CONST, "element")
nx2sc[node] = sc_node
# append into graph with vertex attribute
a = sc_utils.createPairPosPerm(_session, self.segment, self.graphSc, sc_node, sc.SC_CONST)
a1 = sc_utils.createPairPosPerm(_session, self.segment, graph_keynodes.Common.rrel_vertex, a, sc.SC_CONST)
res_list.extend([sc_node, a, a1])
# create edges
for edge in self.graphNx.edges():
sc_edge = sc_utils.createNodeSheaf(_session, self.segment, sc.SC_CONST)
# append into graph with edge attribute
a = sc_utils.createPairPosPerm(_session, self.segment, self.graphSc, sc_edge, sc.SC_CONST)
a1 = sc_utils.createPairPosPerm(_session, self.segment, graph_keynodes.Common.rrel_edge, a, sc.SC_CONST)
# setup begin and end objects
beg, end = edge
a2 = sc_utils.createPairPosPerm(_session, self.segment, sc_edge, nx2sc[beg], sc.SC_CONST)
a3 = sc_utils.createPairPosPerm(_session, self.segment, sc_edge, nx2sc[end], sc.SC_CONST)
res_list.extend([sc_edge, a, a1, a2, a3])
res_list.extend([graph_keynodes.Common.rrel_edge,
graph_keynodes.Common.rrel_vertex,
graph_keynodes.Common.graph
])
# create result set
for r in res_list:
sc_utils.createPairPosPerm(_session, self.segment, result, r, sc.SC_CONST)
return result
def translate_length(_segment, _object):
session = core.Kernel.session()
_value = _object.getPropertyValue(geom_objects.GeometryAbstractObject.PropLength)
_addr = _object._getScAddr()
# build square relation
if not sc_utils.checkOutBinaryPairAttr(session, _addr, geom_keynodes.Relation.nrel_length, sc.SC_CONST):
p_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, p_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_length, sheaf, sc.SC_CONST)
translate_value(_segment, p_node, _value)
else:
pass
def buildUserAtomQuestion(sc_qustions, sc_q_objects):
# узел вопроса
q_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
# добавляем во множество вопрос
session.gen3_f_a_f(segment, sc_key.questions.question, q_node, sc.SC_A_CONST | sc.SC_POS)
# добавляем во множество атомарный вопрос
session.gen3_f_a_f(segment, sc_key.questions.atom, q_node, sc.SC_A_CONST | sc.SC_POS)
# добавляем типы вопросов
for sc_q in sc_qustions:
session.gen3_f_a_f(segment, sc_q, q_node, sc.SC_A_CONST | sc.SC_POS)
# добавляем объекты вопроса
for sc_o in sc_q_objects:
session.gen3_f_a_f(segment, q_node, sc_o, sc.SC_A_CONST | sc.SC_POS)
# добавляем автора (пользователь)
authors_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment, authors_node,
sc_core.Kernel.getSingleton().getUserAddr(), sc.SC_CONST)
authors_pair_sheaf = sc_utils.createPairBinaryOrient(session, segment,
q_node, authors_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment, sc_key.common.nrel_authors,
authors_pair_sheaf, sc.SC_CONST)
# добавляем окна для вывода
output_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
output_count = 0
it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
sc_key.ui.set_output_windows,
sc.SC_ARC,
0), True)
while not it.is_over():
sc_utils.createPair(session, segment, output_node, it.value(2), session.get_type(it.value(1)))
output_count += 1
it.next()
if output_count == 0:
sc_utils.createPairPosPerm(session, segment, output_node, kernel.getMainWindow()._getScAddr(), sc.SC_CONST )
#sc_utils.copySet(session, sc_key.ui.set_output_windows, output_node, segment)
# link output windows set to question
output_sheaf = sc_utils.createPairBinaryOrient(session, segment, output_node,
q_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment, sc_key.ui.nrel_set_of_output_windows,
output_sheaf, sc.SC_CONST)
# initiate question
sc_utils.createPairPosPerm(session, segment, sc_key.questions.initiated,
q_node, sc.SC_CONST)
return q_node
def genMultiplyRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "произведение*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def translate_impl(self, _input, _output):
"""Translator implementation
"""
# translating objects
objs = objects.ScObject._sc2Objects(_input)
assert len(objs) > 0
sheet = objs[0]
assert type(sheet) is objects.ObjectSheet
segment = sheet.getTmpSegment()
errors = []
session = core.Kernel.session()
# getting objects, that need to be translated
trans_obj = []
for obj in sheet.getChilds():
_addr = obj._getScAddr()
if _addr is None:
trans_obj.append(obj)
# remove old translation data
else:
if _addr.seg == segment:
obj._setScAddr(None)
session.erase_el(_addr)
# resolve sc_addrs
for obj in trans_obj:
_resolve_sc_addr(segment, obj)
# make translation
for obj in trans_obj:
errors = []
char_stream = antlr3.ANTLRStringStream(obj)
lexer = Lexer(char_stream)
parser = Parser(antlr3.CommonTokenStream(lexer))
parser.formula()
kernel = core.Kernel.getSingleton()
session = kernel.session()
segment = kernel.segment()
for node in parser.nodeList:
sc_utils.createPairPosPerm(session, segment,_output,node , sc.SC_CONST)
return errors
def translateChildPoints(_session, _segment, _object):
"""Translate points, that lies on \p _object
"""
assert isinstance(_object, geom_objects.GeometryAbstractObject)
obj_addr = _object._getScAddr()
assert obj_addr is not None
for _point, _pos in _object.getPoints():
pt_addr = _point._getScAddr()
assert pt_addr is not None
if not sc_utils.checkIncToSets(
_session, pt_addr, [obj_addr],
sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
sc_utils.createPairPosPerm(_session, _segment, obj_addr, pt_addr,
sc.SC_CONST)
def translete_congr(_segment, _obj1, _obj2):
# check if it have relation
session = core.Kernel.session()
res = sc_utils.searchPairsBinaryNoOrient(session, _obj1._getScAddr(), _obj2._getScAddr(), sc.SC_CONST)
if res is not None:
for result in res:
if sc_utils.checkIncToSets(session, result[2], [geom_keynodes.Relation.nrel_congr], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
return
# create new relation
a = sc_utils.createPairBinaryNoOrient(session, _segment, _obj1._getScAddr(), _obj2._getScAddr(), sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_congr, a, sc.SC_CONST)
return
def translate_impl(self, _input, _output):
"""Translator implementation
"""
# translating objects
objs = objects.ScObject._sc2Objects(_input)
assert len(objs) > 0
sheet = objs[0]
assert type(sheet) is objects.ObjectSheet
segment = sheet.getTmpSegment()
errors = []
session = core.Kernel.session()
# getting objects, that need to be translated
trans_obj = []
for obj in sheet.getChilds():
_addr = obj._getScAddr()
if _addr is None:
trans_obj.append(obj)
# remove old translation data
else:
if _addr.seg == segment:
obj._setScAddr(None)
session.erase_el(_addr)
# resolve sc_addrs
for obj in trans_obj:
_resolve_sc_addr(segment, obj)
# make translation
for obj in trans_obj:
errors = []
char_stream = antlr3.ANTLRStringStream(obj)
lexer = Lexer(char_stream)
parser = Parser(antlr3.CommonTokenStream(lexer))
parser.formula()
kernel = core.Kernel.getSingleton()
session = kernel.session()
segment = kernel.segment()
for node in parser.nodeList:
sc_utils.createPairPosPerm(session, segment, _output, node,
sc.SC_CONST)
return errors
def translate_value(session, _segment, _value_node, _value):
"""Setup value \p _value to \p _value_node
@return: Return list of creates sc-elements
"""
v_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
bin_pair = sc_utils.createPairBinaryOrientFull(session, _segment, v_node,
_value_node, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, _segment,
keynodes.common.nrel_value, bin_pair[0],
sc.SC_CONST)
res = [v_node, a, keynodes.common.nrel_value]
res.extend(bin_pair)
vu_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, _segment, v_node, vu_node,
sc.SC_CONST)
res.extend([vu_node, a])
# make identification
idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST)
bin_pair = sc_utils.createPairBinaryOrientFull(session, _segment,
idtf_node, vu_node,
sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, _segment,
keynodes.common.nrel_identification,
bin_pair[0], sc.SC_CONST)
res.extend([idtf_node, a, keynodes.common.nrel_identification])
res.extend(bin_pair)
# set value
val = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
sc_utils.setContentReal(session, _segment, val, _value)
a = sc_utils.createPairPosPerm(session, _segment, idtf_node, val,
sc.SC_CONST)
a1 = sc_utils.createPairPosPerm(session, _segment,
keynodes.common.rrel_dec_number, a,
sc.SC_CONST)
res.extend([val, a, a1, keynodes.common.rrel_dec_number])
return res
def genDifferenceRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]] #minuend
el2 = math2sc.variables_sc[operation[1]] #subtrahend
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #difference result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
#gen input sum parameters
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, res,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
el1, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def translate_quadrangle(_segment, _object, _params):
"""Translates circle object to sc-memory
"""
_addr = _object._getScAddr()
# include sc-element to points
session = core.Kernel.session()
addToSets(session, _segment, _addr, [geom_keynodes.Objects.plane_quadrangle, keynodes.info.stype_ext_obj_abstract])
sides = _object.getSides()
for obj in sides:
sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, obj._getScAddr(), sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_side, sheaf, sc.SC_CONST)
# build square relation
#sq_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
#sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr, sq_node, sc.SC_CONST)
#sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_square, sheaf, sc.SC_CONST)
return True
def translate_length(_segment, _object):
session = core.Kernel.session()
_value = _object.getPropertyValue(
geom_objects.GeometryAbstractObject.PropLength)
_addr = _object._getScAddr()
# build square relation
if not sc_utils.checkOutBinaryPairAttr(
session, _addr, geom_keynodes.Relation.nrel_length, sc.SC_CONST):
p_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
sheaf = sc_utils.createPairBinaryOrient(session, _segment, _addr,
p_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
geom_keynodes.Relation.nrel_length, sheaf,
sc.SC_CONST)
translate_value(_segment, p_node, _value)
else:
pass
def genSumRelation(session, segment, operation, _result):
"""
@param session: session
@param segment: list of segments to search objects in
@param operation: sum operation and list of operands
@param _result: a node which the result of translation
@return: a node that represents the result of summ
"""
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, sumNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), sumNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
def gen_function(name, params, session, segment, _result):
"""
@param name: function name
@param params: list of function params
@param _result: an output node of the translator
@return:
"""
#gen function node
idtf = name+"*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
funcNode = sc_utils.getElementByIdtf(idtf, segment)
if funcNode == None:
funcNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, funcNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, funcNode, sc.SC_CONST)
#gen args set
argsSet = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, argsSet, sc.SC_CONST)
for x in params:
param = math2sc.variables_sc[x]
arc = sc_utils.createPair(session, core.Kernel.segment(), argsSet, param, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, param, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc, sc.SC_CONST)
pass
#gen relation arc
result = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
relation = sc_utils.createPair(session, core.Kernel.segment(), argsSet, result, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
arc = sc_utils.createPair(session,core.Kernel.segment(), funcNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc, sc.SC_CONST)
return result
def translate_value(_segment, _value_node, _value):
session = core.Kernel.session()
v_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
sheaf = sc_utils.createPairBinaryOrient(session, _segment, v_node, _value_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_value, sheaf, sc.SC_CONST)
vu_node = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, _segment, v_node, vu_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.rrel_cm2, a, sc.SC_CONST)
# make identification
idtf_node = sc_utils.createNodeSheaf(session, _segment, sc.SC_CONST)
sheaf = sc_utils.createPairBinaryOrient(session, _segment, idtf_node, vu_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, keynodes.common.nrel_identification, sheaf, sc.SC_CONST)
# set value
val = sc_utils.createNodeElement(session, _segment, sc.SC_CONST)
sc_utils.setContentReal(session, _segment, val, _value)
a = sc_utils.createPairPosPerm(session, _segment, idtf_node, val, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, keynodes.common.rrel_dec_number, a, sc.SC_CONST)
def translate_circle(_segment, _object, _params):
"""Translates circle object to sc-memory
"""
_addr = _object._getScAddr()
# include sc-element to points
session = core.Kernel.session()
addToSets(
session, _segment, _addr,
[geom_keynodes.Objects.circle, keynodes.info.stype_ext_obj_abstract])
# add relation to center point
addr_begin = _object.center_point._getScAddr()
if not sc_utils.checkOutBinaryPairAttr(
session, _addr, geom_keynodes.Relation.nrel_center, sc.SC_CONST):
a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr,
addr_begin, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
geom_keynodes.Relation.nrel_center, a1,
sc.SC_CONST)
if not sc_utils.checkOutBinaryPairAttr(
session, _addr, geom_keynodes.Relation.nrel_radius, sc.SC_CONST):
radius_obj = _object.getRadiusObject()
if radius_obj is not None:
a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr,
radius_obj._getScAddr(),
sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
geom_keynodes.Relation.nrel_radius, a1,
sc.SC_CONST)
# translate child points
translateChildPoints(session, _segment, _object)
# translate radius if it exist
return True
def negation(self, ):
node = None
atom2 = None
try:
try:
# logic_gram.g:47:2: ( '!' atom )
# logic_gram.g:47:3: '!' atom
pass
self.match(self.input, 13, self.FOLLOW_13_in_negation121)
self._state.following.append(self.FOLLOW_atom_in_negation123)
atom2 = self.atom()
self._state.following.pop()
#action start
node= self.session.create_el(self.segment, sc.SC_CONST)
atomNode=atom2
self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment, logic_keynodes.Relation.nrel_negation, node, sc.SC_CONST))
self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment, node, atomNode, sc.SC_CONST))
self.nodeList.append(node)
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
def genEqualityRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
idtf = "равенство*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
eqNode = sc_utils.getElementByIdtf(idtf, segment)
if eqNode == None:
eqNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, eqNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, eqNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), eqNode, setNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return el1
def translete_congr(_segment, _obj1, _obj2):
# check if it have relation
session = core.Kernel.session()
res = sc_utils.searchPairsBinaryNoOrient(session, _obj1._getScAddr(),
_obj2._getScAddr(), sc.SC_CONST)
if res is not None:
for result in res:
if sc_utils.checkIncToSets(
session, result[2], [geom_keynodes.Relation.nrel_congr],
sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
return
# create new relation
a = sc_utils.createPairBinaryNoOrient(session,
_segment, _obj1._getScAddr(),
_obj2._getScAddr(), sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment,
geom_keynodes.Relation.nrel_congr, a,
sc.SC_CONST)
return
def translate_object(_segment, _object, _params):
"""Translates specified geometry object to SC-code.
@param _segment: segment to translate object in
@type _segment: sc_segment
@param _object: geometry object to translate
@type _object: SCgObject or SCgPair
@param _params: additional parameters to translate object. It contains list of sc-elements, that
designates semantic types for specified object. sc-element, that designate translated object will be included to
sets from _params
@type _params: list
@return: if object translated successfully, then return True, else - False
@rtype: bool
"""
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
if isinstance(_object, chem_objects.ChemistryAtom):
_addr = session.create_el(_segment, sc.SC_N_CONST)
sc_utils.createPairPosPerm(session, _segment, getattr(chem_keynodes, "atom_%s" % _object._name), _addr, sc.SC_CONST)
_object._setScAddr(_addr)
elif isinstance(_object, chem_objects.ChemistryLink):
_addr = session.create_el(_segment, sc.SC_N_CONST)
sc_utils.createPairPosPerm(session, _segment, chem_keynodes.link, _addr, sc.SC_CONST)
addr_begin = _object.getBegin()._getScAddr()
addr_end = _object.getEnd()._getScAddr()
assert addr_begin and addr_end
a1 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_begin, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, chem_keynodes.linked_atom, a1, sc.SC_CONST)
a2 = sc_utils.createPairBinaryOrient(session, _segment, _addr, addr_end, sc.SC_CONST)
sc_utils.createPairPosPerm(session, _segment, chem_keynodes.linked_atom, a2, sc.SC_CONST)
_object._setScAddr(_addr)
return True
def buildUserAtomQuestion(sc_qustions, sc_q_objects):
# узел вопроса
q_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
# добавляем во множество вопрос
session.gen3_f_a_f(segment, sc_key.questions.question, q_node,
sc.SC_A_CONST | sc.SC_POS)
# добавляем во множество атомарный вопрос
session.gen3_f_a_f(segment, sc_key.questions.atom, q_node,
sc.SC_A_CONST | sc.SC_POS)
# добавляем типы вопросов
for sc_q in sc_qustions:
session.gen3_f_a_f(segment, sc_q, q_node, sc.SC_A_CONST | sc.SC_POS)
# добавляем объекты вопроса
for sc_o in sc_q_objects:
session.gen3_f_a_f(segment, q_node, sc_o, sc.SC_A_CONST | sc.SC_POS)
# добавляем автора (пользователь)
authors_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment, authors_node,
sc_core.Kernel.getSingleton().getUserAddr(),
sc.SC_CONST)
authors_pair_sheaf = sc_utils.createPairBinaryOrient(
session, segment, q_node, authors_node, sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment, sc_key.common.nrel_authors,
authors_pair_sheaf, sc.SC_CONST)
# добавляем окна для вывода
output_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
sc_utils.copySet(session, sc_key.ui.set_output_windows, output_node,
segment)
# link output windows set to question
output_sheaf = sc_utils.createPairBinaryOrient(session, segment,
output_node, q_node,
sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment,
sc_key.ui.nrel_set_of_output_windows,
output_sheaf, sc.SC_CONST)
# initiate question
sc_utils.createPairPosPerm(session, segment, sc_key.questions.initiated,
q_node, sc.SC_CONST)
return q_node
def get_arguments_set(_session, _seg):
"""Builds set of command aguments
@param _session: session to work with sc-memory
@type _session: sc_session
@param _seg: segment to create set in
@type _seg: sc_segment
@return: tuple (sc_addr of arguments set, list of elements that need to be added to question)
@rtype: tuple
"""
args_set = sc_utils.createNodeElement(_session, _seg, sc.SC_CONST)
elements = []
# appending arguments to set
kernel = core.Kernel.getSingleton()
arg_objs = kernel.getArguments()
for obj in arg_objs:
_addr = obj._getScAddr()
elements.append(sc_utils.createPairPosPerm(_session, _seg, args_set, _addr, sc.SC_CONST))
elements.append(_addr)
return args_set, elements
def get_sel_elements_set(_session, _seg):
""" Builds set of selected elements in active window
@param _session: session to work with memory
@type _session: sc_session
@param _seg: segment to create set in
@type _seg: sc_segment
@return: tuple (sc_addr of selected elements set, list of elements that need to be added to question)
@rtype: tuple
"""
sel_set = sc_utils.createNodeElement(_session, _seg, sc.SC_CONST)
elements = []
# appending selected elements to set
kernel = core.Kernel.getSingleton()
sel_objs = kernel.rootSheet.getSelected()
for obj in sel_objs:
_addr = obj._getScAddr()
elements.append(sc_utils.createPairPosPerm(_session, _seg, sel_set, _addr, sc.SC_CONST))
elements.append(_addr)
return sel_set, elements
def generate_exppressions(_xmlnode, tag, session, segment):
"""
Process math tag. Generate relations between variables and numbers
"""
global parse_result
while len(stack) > 0:
parse_result.append(stack.pop(-1))
#generate unary expressions
for var in variables:
varname = var[0]
while len(var[1]) > 0:
op = var[1].pop(0)
expr = op + var[0]
key = var[0]
var[0] = expr
for operation in operations:
for arg in operation[1]:
if arg == key:
operation[1][operation[1].index(key)] = expr
for elem in parse_result:
if elem == key:
parse_result[parse_result.index(key)] = expr
if op == "-":
#generate unary minus relation
#find unary minus relation node, if not find create
idtf = "обратное число*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
unMinusNode = sc_utils.getElementByIdtf(idtf, segment)
if unMinusNode == None:
unMinusNode = session.create_el_idtf(
core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session,
core.Kernel.segment(),
param, unMinusNode,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el,
unMinusNode, sc.SC_CONST)
#gen node for result
varSC = variables_sc[key]
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #node for result
pair = sc_utils.createPair(
session, core.Kernel.segment(), varSC, res,
sc.SC_CONST) #arc between processed node and result
relBelong = sc_utils.createPair(session, core.Kernel.segment(),
unMinusNode, pair, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el, res,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el, pair,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el,
relBelong, sc.SC_CONST)
variables_sc[expr] = res
#generate operations
expr = ""
for elem in parse_result:
if (not elem in operation_priority.keys()
and not elem in functions.keys()):
stack.append(elem)
else:
op = elem
if (op not in functions.keys()):
operand1 = stack.pop(-1)
operand2 = stack.pop(-1)
expr = operand2 + op + operand1
stack.append(expr)
if op in binary_expression_gen.keys():
gen_operation = binary_expression_gen[op]
res = gen_operation(session, segment, [operand2, operand1],
el)
variables_sc[expr] = res
else:
translation_errors.append("Unsupported operation")
else:
operands = []
expr = op + "("
for i in range(0, functions[op], 1):
operands.append(stack.pop(-1))
expr += operands[-1]
expr += ","
expr += ")"
stack.append(expr)
res = f_generator.gen_function(op, operands, session, segment,
el)
variables_sc[expr] = res
return
def translate_impl(self, _input, _output):
"""Translator implementation
"""
errors = []
objs = objects.ScObject._sc2Objects(_input)
assert len(objs) > 0
sheet = objs[0]
assert isinstance(sheet, objects.ObjectSheet)
seg = sheet.getTmpSegment()
import suit.core.sc_utils as sc_utils
errors = []
session = core.Kernel.session()
# getting data and translate to sc
field = sheet.getLogic().field
print field
# remove old objects
for layer in field.layers:
for item in layer.items:
_addr = item._getScAddr()
if _addr is not None:
if _addr.seg.this == seg.this:
item._setScAddr(None)
session.erase_el(_addr)
classifier = field.classifier
_segs = [seg.get_full_uri()]
_segs.extend(env.search_segments)
for layer in field.layers:
for item in layer.items:
# if (not item.type in classifier.TYPES_TOWN):
# continue
# creating node in sc-memory
_addr = sc_utils.createNodeElement(session, seg, sc.SC_CONST)
item._setScAddr(_addr)
if (item.type in classifier.TYPES_TOWN):
sc_utils.createPairPosPerm(session, seg,
map_keynodes.ObjectType.town,
_addr, sc.SC_CONST)
elif (item.type in classifier.TYPES_RAILWAY):
sc_utils.createPairPosPerm(session, seg,
map_keynodes.ObjectType.railway,
_addr, sc.SC_CONST)
elif item.type == classifier.TYPE_DISTRICT:
sc_utils.createPairPosPerm(
session, seg, map_keynodes.ObjectType.district, _addr,
sc.SC_CONST)
elif item.type == classifier.TYPE_AREA:
sc_utils.createPairPosPerm(session, seg,
map_keynodes.ObjectType.area,
_addr, sc.SC_CONST)
elif item.type in classifier.TYPES_ROAD:
sc_utils.createPairPosPerm(session, seg,
map_keynodes.ObjectType.road,
_addr, sc.SC_CONST)
for atribute in item.attributes:
if ((atribute in classifier.atributes)
and (item.attributes[atribute] != "")):
_atr = sc_utils.getElementByIdtf(
classifier.atributes[atribute], _segs)
if _atr is None:
_atr = sc_utils.createNodeRoleRelation(
session, seg, sc.SC_CONST)
session.set_idtf(_atr,
classifier.atributes[atribute])
_val = sc_utils.getElementByIdtf(
item.attributes[atribute], _segs)
if _val is None:
_val = sc_utils.createNodeElement(
session, seg, sc.SC_CONST)
session.set_idtf(_val, item.attributes[atribute])
#print classifier.atributes[atribute], item.attributes[atribute]
pair = sc_utils.createPairPosPerm(
session, seg, _addr, _val, sc.SC_CONST)
sc_utils.createPairPosPerm(session, seg, _atr, pair,
sc.SC_CONST)
return errors
def createWindowFromNode(_node, _format, _is_edit):
"""Creates sc.g-window from sc.g-node
@param _node: node to create window from
@type _node: ScgNode
@param _format: sc-element that designate format for node content
@type _format: sc_global_addr
@param _is_edit: flag to create editor
@type _is_edit: boolean
@return: window object
@rtype: objects.ObjectSheet
"""
assert type(_node) is scg_objects.SCgNode
session = core.Kernel.session()
segment = core.Kernel.segment()
parent = _node.parent
# creating sc-element that designate window
el = _node._getScAddr()
if el is not None:
# FIXME: changing type for variable
session.change_type(el, sc.SC_N_CONST)
# else:
# el = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
sheet = objects.ObjectSheet()
if el is not None:
sheet._setScAddr(el)
sheet.hideContent()
logic = None
if _is_edit:
logic = core.Kernel.getSingleton().createEditor(_format)
else:
logic = core.Kernel.getSingleton().createViewer(_format)
# including window to formats set
sc_utils.createPairPosPerm(session, segment, _format, el, sc.SC_CONST)
sheet.setLogic(logic)
parent.addChild(sheet)
sheet.setPosition(_node.getPosition())
# FIXME: removing for old window types
_node._relinkToObject(sheet)
parent._deleteObject(_node)
# need to remove
if _format.this == keynodes.ui.format_scgx.this:
import suit.core.layout.LayoutGroupForceDirected as layout
sheet.setLayoutGroup(layout.LayoutGroupForceSimple())
# linking by relation with parent
# sheaf = sc_utils.createPairBinaryOrient(session, segment, parent._getScAddr(), el, sc.SC_CONST)
# sc_utils.createPairPosPerm(session, segment, keynodes.ui.nrel_child_window, sheaf, sc.SC_CONST)
return sheet
def generate_output_windows_set(_session, _segment, _parent_window):
"""Generates output windows set
@param _session: session to work with sc-memory
@type _session: MThreadSession
@param _segment: segment in sc-memory to work in
@type _segment: sc_segment
@param _parent_window: parent window object
@type _parent_window: ObjectSheet
@return: output windows set
@rtype: sc_global_addr
"""
import srs_engine.sc_utils as sc_utils
# preparing for sc-machine working (translating it to SC-code)
output_windows_set = sc_utils.createNodeElement(_session, _segment, sc.SC_CONST)
kernel = core.Kernel.getSingleton()
output_windows = kernel.getOutputWindows()
import srs_engine.objects as objects
for _addr, _exists, _edit in output_windows:
window_node = _addr
if not _exists:
# creating new window
window = objects.ObjectSheet()
window.hideContent()
if _edit:
try:
window.setLogic(kernel.createEditor(_addr))
except:
print "There are no editor for addr %s" % (str(_addr))
window.setLogic(kernel.createViewer(_addr))
else:
window.setLogic(kernel.createViewer(_addr))
kernel.mainWindow.addChild(window)
sc_utils.createPairPosPerm(_session, _segment, _addr, window._getScAddr(), sc.SC_CONST)
window_node = window._getScAddr()
# test
if _addr.this == keynodes.ui.format_scgx.this:
import srs_engine.layout.LayoutGroupForceDirected as layout
window.setLayoutGroup(layout.LayoutGroupForceSimple())
else:
# test
fmt = sc_utils.getContentFormat(_session, _addr)
if fmt and fmt.this == keynodes.ui.format_scgx.this:
import srs_engine.layout.LayoutGroupForceDirected as layout
# FIXME: thinking about multiply objects for sc_addr
windows = objects.ScObject._sc2Objects(_addr)
assert len(windows) > 0
window = windows[0]
if window.getLayoutGroup() is None:
window.setLayoutGroup(layout.LayoutGroupForceSimple())
sc_utils.createPairPosPerm(_session, _segment, output_windows_set, window_node, sc.SC_CONST)
# # test
# import srs_engine.objects as objects
# sheet = objects.ObjectSheet()
# sheet.hideContent()
#
# sheet.setLogic(kernel.createEditor(keynodes.ui.format_scgx))
# kernel.rootSheet.addChild(sheet)
# sc_utils.createPair(_session, kernel.segment(), keynodes.ui.format_scgx, sheet._getScAddr(), sc.SC_A_CONST | sc.SC_POS)
# kernel.setRootSheet(sheet)
#
# import srs_engine.layout.LayoutGroupForceDirected as layout
# sheet.setLayoutGroup(layout.LayoutGroupForceSimple())
# # test
#
# sc_utils.createPairPosPerm(_session, _segment, output_windows_set, sheet._getScAddr(), sc.SC_CONST)
return output_windows_set
def translate_impl(self, _input, _output):
"""Translator implementation
"""
# translating objects
objs = objects.ScObject._sc2Objects(_input)
assert len(objs) > 0
sheet = objs[0]
assert type(sheet) is objects.ObjectSheet
segment = sheet.getTmpSegment()
errors = []
session = core.Kernel.session()
# getting objects, that need to be translated
trans_obj = []
for obj in sheet.getChilds():
_addr = obj._getScAddr()
if _addr is None:
trans_obj.append(obj)
# remove old translation data
else:
if _addr.seg == segment:
obj._setScAddr(None)
#session.erase_el(_addr)
trans_obj.append(obj)
# sort objects to nodes and edges
verticies = []
edges = []
for obj in trans_obj:
if isinstance(obj, graph_objects.GraphVertex):
verticies.append(obj)
elif isinstance(obj, graph_objects.GraphLink):
edges.append(obj)
graph = sc_utils.createNode(session, segment, sc.SC_CONST, "struct")
sc_utils.createPairPosPerm(session, segment, graph_keynodes.Common.graph, graph, sc.SC_CONST)
# create all nodes
for node in verticies:
sc_node = sc_utils.createNode(session, segment, sc.SC_CONST, "element")
node._setScAddr(sc_node)
# append into graph with vertex attribute
a = sc_utils.createPairPosPerm(session, segment, graph, sc_node, sc.SC_CONST)
a1 = sc_utils.createPairPosPerm(session, segment, graph_keynodes.Common.rrel_vertex, a, sc.SC_CONST)
# create edges
for edge in edges:
sc_edge = sc_utils.createNodeSheaf(session, segment, sc.SC_CONST)
# append into graph with edge attribute
a = sc_utils.createPairPosPerm(session, segment, graph, sc_edge, sc.SC_CONST)
a1 = sc_utils.createPairPosPerm(session, segment, graph_keynodes.Common.rrel_edge, a, sc.SC_CONST)
# setup begin and end objects
beg = edge.getBegin()._getScAddr()
end = edge.getEnd()._getScAddr()
a2 = sc_utils.createPairPosPerm(session, segment, sc_edge, beg, sc.SC_CONST)
a3 = sc_utils.createPairPosPerm(session, segment, sc_edge, end, sc.SC_CONST)
edge._setScAddr(sc_edge)
print "Translation errors:"
for obj, error in errors:
print error
return errors
def calculate_graph_element_prop(_params, _segment):
kernel = core.Kernel.getSingleton()
session = kernel.session()
segment = kernel.segment()
# check type
question = session.search_one_shot(
session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f,
keynodes.questions.initiated, sc.SC_A_CONST,
sc.SC_N_CONST, sc.SC_A_CONST, _params), True,
5)
assert question is not None
question = question[2]
global graph_prop_calculators
for question_type, calculator, relation in graph_element_prop_calculators:
# check command type
if sc_utils.checkIncToSets(session, question, [question_type],
sc.SC_CONST):
element = session.search_one_shot(
session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
question, sc.SC_A_CONST,
sc.SC_N_CONST), True, 3)
if element is None:
return
element = element[2]
graph = None
arc = None
it = session.create_iterator(
session.sc_constraint_new(sc_constants.CONSTR_3_a_a_f,
sc.SC_NODE,
sc.SC_A_CONST | sc.SC_POS, element),
True)
while not it.is_over():
if sc_utils.checkIncToSets(session, it.value(0),
[graph_keynodes.Common.graph],
sc.SC_CONST):
graph = it.value(0)
arc = it.value(1)
break
it.next()
if graph is None:
continue
# make graph and calculate property value
g = Graph(segment, graph)
sc2obj = g.makeNxGraph()
result = calculator(g.graphNx, sc2obj[str(element.this)])
#
if result is None:
raise RuntimeWarning("Calculator can't calculate value")
value = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
bin_rel = sc_utils.createPairBinaryOrientFull(
session, segment, arc, value, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, segment, relation,
bin_rel[0], sc.SC_CONST)
elements = translate_value(session, segment, value, result)
elements.extend([value, graph, a, relation])
elements.extend(bin_rel)
answer = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
for el in elements:
sc_utils.createPairPosPerm(session, segment, answer, el,
sc.SC_CONST)
sc_utils.makeAnswer(session, segment, question, answer)
def calculate_graph_prop(_params, _segment):
kernel = core.Kernel.getSingleton()
session = kernel.session()
segment = kernel.segment()
# check type
question = session.search_one_shot(
session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f,
keynodes.questions.initiated, sc.SC_A_CONST,
sc.SC_N_CONST, sc.SC_A_CONST, _params), True,
5)
assert question is not None
question = question[2]
global graph_prop_calculators
for question_type, calculator, relation in graph_prop_calculators:
# check command type
if sc_utils.checkIncToSets(session, question, [question_type],
sc.SC_CONST):
graph = session.search_one_shot(
session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
question, sc.SC_A_CONST,
sc.SC_N_CONST), True, 3)
if graph is None:
return
graph = graph[2]
if not sc_utils.checkIncToSets(session, graph,
[graph_keynodes.Common.graph],
sc.SC_CONST):
return
g = Graph(segment, graph)
g.makeNxGraph()
result = calculator(g.graphNx)
if result is None:
raise RuntimeWarning("Calculator can't calculate value")
value = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
bin_rel = sc_utils.createPairBinaryOrientFull(
session, segment, graph, value, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, segment, relation,
bin_rel[0], sc.SC_CONST)
elements = translate_value(session, segment, value, result)
elements.extend([value, graph, a, relation])
elements.extend(bin_rel)
answer = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
for el in elements:
sc_utils.createPairPosPerm(session, segment, answer, el,
sc.SC_CONST)
sc_utils.makeAnswer(session, segment, question, answer)
def genPowerRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "возведение в степень*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
powNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, powNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), powNode,
setNode, sc.SC_CONST)
baseIdtf = "основание_"
baseIdtf = sc_utils.utf8ToCp1251(str(baseIdtf))
baseNode = sc_utils.getElementByIdtf(baseIdtf, segment)
if baseNode == None:
baseNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
baseIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, baseNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), baseNode, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
expIdtf = "показатель_"
expIdtf = sc_utils.utf8ToCp1251(str(expIdtf))
expNode = sc_utils.getElementByIdtf(expIdtf, segment)
if expNode == None:
expNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
expIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, expNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), expNode, arc2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
powerIdtf = "результат_"
powerIdtf = sc_utils.utf8ToCp1251(str(powerIdtf))
powerNode = sc_utils.getElementByIdtf(powerIdtf, segment)
if powerNode == None:
powerNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
powerIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, powerNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), powerNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def translate_impl(self, _input, _output):
"""Translator implementation
"""
# FIXME: append type changing. Element type will be changing, if it is temporary segment
# or is in semantic equivalent construction set
# FIXME: think about multiply windows for one sc-element
objs = objects.ScObject._sc2Objects(_input)
assert len(objs) > 0
sheet = objs[0]
assert isinstance(sheet, objects.ObjectSheet)
seg = sheet.getTmpSegment()
errors = []
session = core.Kernel.session()
import suit.core.sc_utils as sc_utils
# removing old objects
# for obj in sheet.getChilds():
# _addr = obj._getScAddr()
# if _addr is not None:
# if _addr.seg.this == seg.this or isinstance(obj, scg_objects.SCgPair):
# obj._setScAddr(None)
# session.erase_el(_addr)
# getting objects, that need to be translated
trans_obj = []
for obj in sheet.getChilds():
if obj._getScAddr() is None:
trans_obj.append(obj)
if not isinstance(obj, objects.ObjectSheet):
# translating objects
obj_type = obj.getType()
if obj_type == "sheet": continue
if not translate_rules.has_key(obj_type):
errors.append((obj, "There are no any rules for type %s" % obj_type))
else:
#try:
func, obj_type, params = translate_rules[obj_type]
func(seg, obj, obj_type, params)
#except:
# import sys
# errors.append((obj, "Error: %s" % str(sys.exc_info()[0])))
else:
# sheet translation
translate_object(seg, obj, sc.SC_NODE, [])
content_type, content_data, content_format = obj.getContent()
assert content_type is not objects.ObjectSheet.CT_Unknown
addr = obj._getScAddr()
assert addr is not None
if content_type == objects.ObjectSheet.CT_String:
session.set_content_str(addr, content_data)
elif content_type == objects.ObjectSheet.CT_Real:
session.set_content_real(addr, content_data)
elif content_type == objects.ObjectSheet.CT_Int:
session.set_content_int(addr, content_data)
elif content_type == objects.ObjectSheet.CT_Binary:
pass # FIXME: add binary content
sc_utils.createPairPosPerm(session, seg, content_format, addr, sc.SC_CONST)
# linking objects
noorient_pairs = ['pair/-/-/-/const', 'pair/-/-/-/var', 'pair/-/-/-/meta']
orient_pairs = ['pair/-/-/orient/const', 'pair/-/-/orient/var', 'pair/-/-/orient/meta']
for obj in trans_obj:
obj_type = obj.getType()
# check if object is orient pair
isPair = obj_type.startswith("pair")
isOrient = False
isNoorient = False
# skipping no pair objects
if not isPair: continue
if obj_type in noorient_pairs:
isNoorient = True
if obj_type in orient_pairs:
isOrient = True
el = obj._getScAddr()
if isOrient or isNoorient:
_const = sc.SC_CONST
if obj_type.find('var') != -1:
_const = sc.SC_VAR
elif obj_type.find('meta') != -1:
_const = sc.SC_METAVAR
# generating arguments
a1 = sc_utils.createPairPosPerm(session, seg, el, obj.getBegin()._getScAddr(), _const)
a2 = sc_utils.createPairPosPerm(session, seg, el, obj.getEnd()._getScAddr(), _const)
obj.additionalScAddrs = [a1, a2]
if isOrient:
p1 = sc_utils.createPairPosPerm(session, seg, keynodes.n_1, a1, _const)
p2 = sc_utils.createPairPosPerm(session, seg, keynodes.n_2, a2, _const)
obj.additionalScAddrs.extend([p1, p2])
else:
# set begin and end objects for pair
session.set_beg(el, obj.getBegin()._getScAddr())
session.set_end(el, obj.getEnd()._getScAddr())
return errors
def init_cmd(session, segment, sheet, _menu_item_addr, _general_formul, _cmd_class_set, _init_set):
"""Initialize question/command from template
@param session: Session to work with sc-memory
@param segment: Segment to create sc-constructions
@param sheet: Current root sheet (command initiated from it)
@param _menu_item_addr: sc-element that designate command (question) menu item
@type _menu_item_addr: sc_addr
@param _general_formul: sc-element that designate general formulation relation (different for questions and commands)
@type _general_formul: sc_addr
@param _cmd_class_set: sc-element that designate class of commands (used to search command node in template)
@type _cmd_class_set: sc_addr
@param _init_set: sc-element that designate initiated commands set (different for commands and questions)
@type _init_set: sc_addr
"""
kernel = core.Kernel.getSingleton()
# getting question template
q_templ = sc_utils.searchOneShotBinPairAttrToNode(session, _menu_item_addr, _general_formul, sc.SC_CONST)
if not q_templ:
raise RuntimeWarning("Question '%s' haven't template" % _caption)
return
# getting question node
it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f,
_cmd_class_set,
sc.SC_ARC,
sc.SC_NODE,
sc.SC_ARC,
q_templ), True)
question_node = None
while not it.is_over():
if sc_utils.checkIncToSets(session, it.value(2), [q_templ], 0):
question_node = it.value(2)
break
it.next()
if question_node is None:
raise RuntimeError("Can't get command (question) node for a '%s' command" % str(_menu_item_addr))
# creating question using template:
# * iterate through elements of template set
# * making values of parameters cmd_desc_..., add that values to addit_elements map
# * replace var elements to const elements
# * replace meta elements to var elements
# * link replaced arcs
params = {}
addit_elements = {} # additional elements we need to add into question after params setup
elements = []
pairs = []
it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
q_templ,
sc.SC_A_CONST | sc.SC_POS,# | sc.SC_PERMANENT,
0), True)
while not it.is_over():
_el = it.value(2)
elements.append(_el)
# selected elements
if _el.this == keynodes.ui.arg_set.this:
params[str(_el.this)], elms = get_arguments_set(session, segment)
addit_elements[str(_el.this)] = elms
elif _el.this == keynodes.ui.arg_set_only.this: # place just set node into question node
params[str(_el.this)], elms = get_arguments_set(session, segment)
elif _el.this == keynodes.ui.arg_all_el.this:
params[str(_el.this)], elms = get_all_elements_set(session, segment)
elif _el.this == keynodes.ui.arg_cur_window.this:
params[str(_el.this)] = sheet
elif _el.this == keynodes.ui.arg_1.this:
arguments = core.Kernel.getSingleton().getArguments()
if len(arguments) > 0:
params[str(_el.this)] = arguments[0]._getScAddr()
elif _el.this == keynodes.ui.arg_2.this:
arguments = core.Kernel.getSingleton().getArguments()
if len(arguments) > 1:
params[str(_el.this)] = arguments[1]._getScAddr()
elif _el.this == keynodes.ui.arg_3.this:
arguments = core.Kernel.getSingleton().getArguments()
if len(arguments) > 1:
params[str(_el.this)] = arguments[2]._getScAddr()
# elif _el.this == keynodes.ui.cmd_desc_curr_window.this:
# params[str(_el.this)] = kernel.rootSheet._getScAddr()
else:
el_type = session.get_type(_el)
idtf = session.get_idtf(_el)
if not sc_utils.isSystemId(idtf) or (el_type & sc.SC_CONST):
params[str(_el.this)] = _el
else:
# recreate var and meta elements using rules:
# * var -> const
# * meta -> var
post_type = 0
if el_type & sc.SC_VAR:
post_type = sc.SC_CONST
elif el_type & sc.SC_META:
post_type = sc.SC_VAR
else:
raise RuntimeWarning("Unknown const type for element '%s'" % str(_el))
if el_type & sc.SC_ARC:
pairs.append(_el)
params[str(_el.this)] = session.create_el(segment, sc.SC_ARC | post_type)
elif el_type & sc.SC_NODE:
params[str(_el.this)] = session.create_el(segment, sc.SC_NODE | post_type)
# TODO: copy structure types for elements
it.next()
# add selected set to question set
q_node_new = params[str(question_node.this)]
if sc_utils.checkIncToSets(session, keynodes.ui.arg_set, [question_node], sc.SC_POS | sc.SC_VAR) and sc_utils.checkIncToSets(session, keynodes.ui.arg_set, [q_templ], sc.SC_POS | sc.SC_CONST):
# make pairs to additional elements
for el in addit_elements[str(keynodes.ui.arg_set.this)]:
assert sc_utils.createPairPosPerm(session, segment, q_node_new, el, sc.SC_CONST)
# linking arcs
for pair in pairs:
# get begin and end elements
_beg = session.get_beg(pair)
_end = session.get_end(pair)
if params.has_key(str(_beg.this)):
_beg = params[str(_beg.this)]
if params.has_key(str(_end.this)):
_end = params[str(_end.this)]
pair_new = params[str(pair.this)]
session.set_beg(pair_new, _beg)
session.set_end(pair_new, _end)
# make authors set
authors_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
sc_utils.createPairPosPerm(session, segment, authors_node, core.Kernel.getSingleton().getUserAddr(), sc.SC_CONST)
assert authors_node is not None
authors_pair_sheaf = sc_utils.createPairBinaryOrient(session, segment, params[str(question_node.this)], authors_node, sc.SC_CONST)
assert authors_pair_sheaf is not None
assert sc_utils.createPairPosPerm(session, segment, keynodes.common.nrel_authors, authors_pair_sheaf, sc.SC_CONST)
# make output windows set
output_node = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
assert output_node is not None
# sc_utils.copySet(session, keynodes.ui.set_output_windows, output_node, segment)
output_count = 0
it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
keynodes.ui.set_output_windows,
sc.SC_ARC,
0), True)
while not it.is_over():
sc_utils.createPair(session, segment, output_node, it.value(2), session.get_type(it.value(1)))
output_count += 1
it.next()
if output_count == 0:
sc_utils.createPairPosPerm(session, segment, output_node, kernel.getMainWindow()._getScAddr(), sc.SC_CONST )
# link output windows set to question
output_sheaf = sc_utils.createPairBinaryOrient(session, segment, output_node, params[str(question_node.this)], sc.SC_CONST)
assert output_sheaf is not None
sc_utils.createPairPosPerm(session, segment, keynodes.ui.nrel_set_of_output_windows, output_sheaf, sc.SC_CONST)
# initiate question
assert sc_utils.createPairPosPerm(session, segment, _init_set, params[str(question_node.this)], sc.SC_CONST) is not None
def translate_object(_segment, _object, _type, _params):
"""Translates specified scg-object to SC-code.
@param _segment: segment to translate object in
@type _segment: sc_segment
@param _object: scg-object to translate
@type _object: SCgObject or SCgPair
@param _type: object type
@type _type: sc_type
@param _params: additional parameters to translate object. It contains list of sc-elements, that
designates semantic types for specified object. sc-element, that designate translated object will be included to
sets from _params
@type _params: list
@return: if object translated successfully, then return True, else - False
@rtype: bool
"""
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
# getting node idtf
idtf = _object.getText()
sc_object = None
el = None
isUri = False
created = False
# if idtf empty, then creating new element
if idtf is None:
el = session.create_el(_segment, _type)
created = True
else:
# encode idtf to cp1251
idtf = sc_utils.utf8ToCp1251(str(idtf))
# check if idtf if full uri
isUri = idtf.startswith('/')
# trying to find object by idtf, if it doesn't exists, then creating it
try:
if el is None:
if isUri:
el = session.find_el_full_uri(idtf)
if el is None:
el = session.create_el_full_uri(idtf, _type)[1]
created = True
else:
_segs = [_segment.get_full_uri()]
_segs.extend(env.search_segments)
# trying to find element
el = sc_utils.getElementByIdtf(idtf, _segs)
if el is None:
el = session.create_el_idtf(_segment, _type, idtf)[1]
created = True
except:
import sys, traceback
print sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
return False
assert el is not None
_object._setScAddr(el)
_object.setMerged(not created)
# including to sets for structure type
for param in _params:
sc_utils.createPairPosPerm(session, _segment, param, el, sc.SC_CONST)
return True
def expression(self, ):
node = None
a = None
b = None
try:
try:
# logic_gram.g:23:2: (a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom )
# logic_gram.g:23:3: a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom
pass
#action start
revers=None
relation=None
#action end
self._state.following.append(self.FOLLOW_atom_in_expression49)
a = self.atom()
self._state.following.pop()
# logic_gram.g:26:10: ( '^' | '&' | ( '->' | '<-' ) | '<->' )
alt2 = 4
LA2 = self.input.LA(1)
if LA2 == 6:
alt2 = 1
elif LA2 == 7:
alt2 = 2
elif LA2 == 8 or LA2 == 9:
alt2 = 3
elif LA2 == 10:
alt2 = 4
else:
nvae = NoViableAltException("", 2, 0, self.input)
raise nvae
if alt2 == 1:
# logic_gram.g:26:11: '^'
pass
self.match(self.input, 6, self.FOLLOW_6_in_expression52)
#action start
relation=logic_keynodes.Relation.nrel_disjunction
#action end
elif alt2 == 2:
# logic_gram.g:27:3: '&'
pass
self.match(self.input, 7, self.FOLLOW_7_in_expression57)
#action start
relation=logic_keynodes.Relation.nrel_conjunction
#action end
elif alt2 == 3:
# logic_gram.g:28:3: ( '->' | '<-' )
pass
# logic_gram.g:28:3: ( '->' | '<-' )
alt1 = 2
LA1_0 = self.input.LA(1)
if (LA1_0 == 8) :
alt1 = 1
elif (LA1_0 == 9) :
alt1 = 2
else:
nvae = NoViableAltException("", 1, 0, self.input)
raise nvae
if alt1 == 1:
# logic_gram.g:28:4: '->'
pass
self.match(self.input, 8, self.FOLLOW_8_in_expression64)
elif alt1 == 2:
# logic_gram.g:28:9: '<-'
pass
self.match(self.input, 9, self.FOLLOW_9_in_expression66)
#action start
revers=True
#action end
#action start
relation=logic_keynodes.Relation.nrel_implication
#action end
elif alt2 == 4:
# logic_gram.g:29:3: '<->'
pass
self.match(self.input, 10, self.FOLLOW_10_in_expression75)
#action start
relation=logic_keynodes.Relation.nrel_equivalence
#action end
self._state.following.append(self.FOLLOW_atom_in_expression84)
b = self.atom()
self._state.following.pop()
#action start
if relation==logic_keynodes.Relation.nrel_implication:
if revers:
a,b=b,a
node=sc_utils.createPairBinaryOrient(self.session, self.segment, a ,b, sc.SC_CONST)
else:
node=sc_utils.createPairBinaryNoOrient(self.session, self.segment, a ,b, sc.SC_CONST)
self.nodeList.append(node)
self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment,relation, node, sc.SC_CONST))
#action end
except RecognitionException, re:
self.reportError(re)
self.recover(self.input, re)
finally:
pass
return node
def calculate_graph_element_prop(_params, _segment):
kernel = core.Kernel.getSingleton()
session = kernel.session()
segment = kernel.segment()
# check type
question = session.search_one_shot(session.sc_constraint_new(sc_constants.CONSTR_5_f_a_a_a_f,
keynodes.questions.initiated,
sc.SC_A_CONST,
sc.SC_N_CONST,
sc.SC_A_CONST,
_params), True, 5)
assert question is not None
question = question[2]
global graph_prop_calculators
for question_type, calculator, relation in graph_element_prop_calculators:
# check command type
if sc_utils.checkIncToSets(session, question, [question_type], sc.SC_CONST):
element = session.search_one_shot(session.sc_constraint_new(sc_constants.CONSTR_3_f_a_a,
question,
sc.SC_A_CONST,
sc.SC_N_CONST), True, 3)
if element is None:
return
element = element[2]
graph = None
arc = None
it = session.create_iterator(session.sc_constraint_new(sc_constants.CONSTR_3_a_a_f,
sc.SC_NODE,
sc.SC_A_CONST | sc.SC_POS,
element), True)
while not it.is_over():
if sc_utils.checkIncToSets(session, it.value(0), [graph_keynodes.Common.graph], sc.SC_CONST):
graph = it.value(0)
arc = it.value(1)
break
it.next()
if graph is None:
continue
# make graph and calculate property value
g = Graph(segment, graph)
sc2obj = g.makeNxGraph()
result = calculator(g.graphNx, sc2obj[str(element.this)])
#
if result is None:
raise RuntimeWarning("Calculator can't calculate value")
value = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
bin_rel = sc_utils.createPairBinaryOrientFull(session, segment, arc, value, sc.SC_CONST)
a = sc_utils.createPairPosPerm(session, segment, relation, bin_rel[0], sc.SC_CONST)
elements = translate_value(session, segment, value, result)
elements.extend([value, graph, a, relation])
elements.extend(bin_rel)
answer = sc_utils.createNodeElement(session, segment, sc.SC_CONST)
for el in elements:
sc_utils.createPairPosPerm(session, segment, answer, el, sc.SC_CONST)
sc_utils.makeAnswer(session, segment, question, answer)
def genPowerRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "возведение в степень*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, powNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, powNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), powNode, setNode, sc.SC_CONST)
baseIdtf = "основание_"
baseIdtf = sc_utils.utf8ToCp1251(str(baseIdtf))
baseNode = sc_utils.getElementByIdtf(baseIdtf, segment)
if baseNode == None:
baseNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, baseIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, baseNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), baseNode, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
expIdtf = "показатель_"
expIdtf = sc_utils.utf8ToCp1251(str(expIdtf))
expNode = sc_utils.getElementByIdtf(expIdtf, segment)
if expNode == None:
expNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, expIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, expNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), expNode, arc2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
powerIdtf = "результат_"
powerIdtf = sc_utils.utf8ToCp1251(str(powerIdtf))
powerNode = sc_utils.getElementByIdtf(powerIdtf, segment)
if powerNode == None:
powerNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, powerIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, powerNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), powerNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
def translate_impl(self, _input, _output):
"""Translator implementation
"""
# FIXME: append type changing. Element type will be changing, if it is temporary segment
# or is in semantic equivalent construction set
# FIXME: think about multiply windows for one sc-element
objs = objects.ScObject._sc2Objects(_input)
assert len(objs) > 0
sheet = objs[0]
assert isinstance(sheet, objects.ObjectSheet)
seg = sheet.getTmpSegment()
errors = []
session = core.Kernel.session()
import suit.core.sc_utils as sc_utils
# removing old objects
# for obj in sheet.getChilds():
# _addr = obj._getScAddr()
# if _addr is not None:
# if _addr.seg.this == seg.this or isinstance(obj, scg_objects.SCgPair):
# obj._setScAddr(None)
# session.erase_el(_addr)
# getting objects, that need to be translated
trans_obj = []
for obj in sheet.getChilds():
if obj._getScAddr() is None:
trans_obj.append(obj)
if not isinstance(obj, objects.ObjectSheet):
# translating objects
obj_type = obj.getType()
if obj_type == "sheet": continue
if not translate_rules.has_key(obj_type):
errors.append(
(obj,
"There are no any rules for type %s" % obj_type))
else:
#try:
func, obj_type, params = translate_rules[obj_type]
func(seg, obj, obj_type, params)
#except:
# import sys
# errors.append((obj, "Error: %s" % str(sys.exc_info()[0])))
else:
# sheet translation
translate_object(seg, obj, sc.SC_NODE, [])
content_type, content_data, content_format = obj.getContent(
)
assert content_type is not objects.ObjectSheet.CT_Unknown
addr = obj._getScAddr()
assert addr is not None
if content_type == objects.ObjectSheet.CT_String:
session.set_content_str(addr, content_data)
elif content_type == objects.ObjectSheet.CT_Real:
session.set_content_real(addr, content_data)
elif content_type == objects.ObjectSheet.CT_Int:
session.set_content_int(addr, content_data)
elif content_type == objects.ObjectSheet.CT_Binary:
pass # FIXME: add binary content
sc_utils.createPairPosPerm(session, seg, content_format,
addr, sc.SC_CONST)
# linking objects
noorient_pairs = [
'pair/-/-/-/const', 'pair/-/-/-/var', 'pair/-/-/-/meta'
]
orient_pairs = [
'pair/-/-/orient/const', 'pair/-/-/orient/var',
'pair/-/-/orient/meta'
]
for obj in trans_obj:
obj_type = obj.getType()
# check if object is orient pair
isPair = obj_type.startswith("pair")
isOrient = False
isNoorient = False
# skipping no pair objects
if not isPair: continue
if obj_type in noorient_pairs:
isNoorient = True
if obj_type in orient_pairs:
isOrient = True
el = obj._getScAddr()
if isOrient or isNoorient:
_const = sc.SC_CONST
if obj_type.find('var') != -1:
_const = sc.SC_VAR
elif obj_type.find('meta') != -1:
_const = sc.SC_METAVAR
# generating arguments
a1 = sc_utils.createPairPosPerm(session, seg, el,
obj.getBegin()._getScAddr(),
_const)
a2 = sc_utils.createPairPosPerm(session, seg, el,
obj.getEnd()._getScAddr(),
_const)
obj.additionalScAddrs = [a1, a2]
if isOrient:
p1 = sc_utils.createPairPosPerm(session, seg, keynodes.n_1,
a1, _const)
p2 = sc_utils.createPairPosPerm(session, seg, keynodes.n_2,
a2, _const)
obj.additionalScAddrs.extend([p1, p2])
else:
# set begin and end objects for pair
session.set_beg(el, obj.getBegin()._getScAddr())
session.set_end(el, obj.getEnd()._getScAddr())
return errors
def translate_object(_segment, _object, _type, _params):
"""Translates specified scg-object to SC-code.
@param _segment: segment to translate object in
@type _segment: sc_segment
@param _object: scg-object to translate
@type _object: SCgObject or SCgPair
@param _type: object type
@type _type: sc_type
@param _params: additional parameters to translate object. It contains list of sc-elements, that
designates semantic types for specified object. sc-element, that designate translated object will be included to
sets from _params
@type _params: list
@return: if object translated successfully, then return True, else - False
@rtype: bool
"""
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
# getting node idtf
idtf = _object.getText()
sc_object = None
el = None
isUri = False
created = False
# if idtf empty, then creating new element
if idtf is None:
el = session.create_el(_segment, _type)
created = True
else:
# encode idtf to cp1251
idtf = sc_utils.utf8ToCp1251(str(idtf))
# check if idtf if full uri
isUri = idtf.startswith('/')
# trying to find object by idtf, if it doesn't exists, then creating it
try:
if el is None:
if isUri:
el = session.find_el_full_uri(idtf)
if el is None:
el = session.create_el_full_uri(idtf, _type)[1]
created = True
else:
_segs = [_segment.get_full_uri()]
_segs.extend(env.search_segments)
# trying to find element
el = sc_utils.getElementByIdtf(idtf, _segs)
if el is None:
el = session.create_el_idtf(_segment, _type, idtf)[1]
created = True
except:
import sys, traceback
print sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
return False
assert el is not None
_object._setScAddr(el)
_object.setMerged(not created)
# including to sets for structure type
for param in _params:
sc_utils.createPairPosPerm(session, _segment, param, el, sc.SC_CONST)
return True
