simple aDOT graph implementation, Selectors and funcs rework

.vscode/settings.json

+{
+    "python.testing.unittestArgs": [
+        "-v",
+        "-s",
+        "./tests",
+        "-p",
+        "test_*.py"
+    ],
+    "python.testing.pytestEnabled": false,
+    "python.testing.nosetestsEnabled": false,
+    "python.testing.unittestEnabled": true
+}
\ No newline at end of file

comsdk/edge.py

 import comsdk.aux as aux
 from comsdk.communication import CommunicationError
+from comsdk.graph import Func
 
 from mako.template import Template
 import os
@@ -64,16 +65,19 @@ class Edge(object):
         self._morphism(proxy_data)
         self.postprocess(data)
 
-class DummyEdge(Edge):
-    def __init__(self):
-        super().__init__(None, None)
+# class DummyEdge(Edge):
+    # def __init__(self):
+        # super().__init__(None, None)
+# 
+    # def predicate(self, data, dynamic_keys_mapping={}):
+        # return True
+# 
+    # def morph(self, data, dynamic_keys_mapping={}):
+        # self.preprocess(data)
+        # self.postprocess(data)
 
-    def predicate(self, data, dynamic_keys_mapping={}):
-        return True
-
-    def morph(self, data, dynamic_keys_mapping={}):
-        self.preprocess(data)
-        self.postprocess(data)
+def DummyEdge():
+    return Edge(Func(), Func())
 
 class ExecutableProgramEdge(Edge):
     '''

comsdk/graph.py

@@ -14,14 +14,17 @@ class Func():
         'func', 
         'name'
     )
-    def __init__(self, module="", name="", dummy=True,func=None):
+    def __init__(self, module="", name="", dummy=False,func=None):
         self.module = module
         self.name = name
+        if module =="" or name =="":
+            dummy = True
         if func is not None:
             self.func = func
         elif dummy:
             self.func = lambda data: data
         else: 
+            print(module, name, "loading")
             self.func = getattr(imp.import_module(module), name)
 
     def __str__(self):
@@ -31,9 +34,11 @@ class Selector(Func):
     __slots__=(
         'ntransf'
     )
-    def __init__(self, ntransf, module="", name="", dummy=True):
+    def __init__(self, ntransf, module="", name="", dummy=False):
+        if module=="" and name =="":
+            dummy = True
         self.ntransf = ntransf
-        super().__init__(module, name, func=(lambda x: [True for i in range(ntransf)]) if dummy else None, dummy=False)
+        super().__init__(module, name, func=(lambda x: [True for i in range(ntransf)]) if dummy else None)
 
 
 class Transfer:
@@ -132,7 +137,7 @@ class State:
                  ):
         self.name = name
         self.parallelization_policy = SerialParallelizationPolicy() if parallelization_policy is None else parallelization_policy
-        self.selector = lambda  x: True if selector is None else selector
+        self.selector = Selector(1) if selector is None else selector
         self.array_keys_mapping = array_keys_mapping
         self.input_edges_number = 0
         self.looped_edges_number = 0
@@ -144,12 +149,12 @@ class State:
 
     def idle_run(self, idle_run_type, branching_states_history):
         def __sort_by_order(tr):
-            print(tr.edge.order)
+            # print(tr.edge.order)
             return tr.edge.order
         self.transfers.sort(key = __sort_by_order)
         print(self.name)
         for t in self.transfers:
-            print("\t", t.edge.pred_name, t.edge.morph_name)
+            print("\t", t.edge.order, t.edge.pred_name, t.edge.morph_name)
         if self._proxy_state is not None:
             return self._proxy_state.idle_run(idle_run_type, branching_states_history)
         if idle_run_type == IdleRunType.INIT:
@@ -209,11 +214,13 @@ class State:
         dynamic_keys_mapping = build_dynamic_keys_mapping(implicit_parallelization_info)
         for transfer in self.transfers:
             predicate_values.append(transfer.edge.predicate(data, dynamic_keys_mapping))
-        selected_edge_indices = self.selector.func(predicate_values)
-        if not selected_edge_indices:
+        selected_edges = self.selector.func(predicate_values)
+        print(selected_edges)
+        if not selected_edges:
             raise GraphUnexpectedTermination(
                 'State {}: Predicate values {} do not conform selection policy'.format(self.name, predicate_values))
-        selected_transfers = [self.transfers[i] for i in selected_edge_indices]
+        selected_transfers = [self.transfers[i] for i, _ in enumerate(selected_edges) if selected_edges[i]==True]
+        print( selected_transfers)
         return self.parallelization_policy.make_transfer_func(selected_transfers,
                                                          array_keys_mapping=self.array_keys_mapping,
                                                          implicit_parallelization_info=implicit_parallelization_info,), \
@@ -276,9 +283,10 @@ class SerialParallelizationPolicy:
 
     def make_transfer_func(self, morphisms, array_keys_mapping=None, implicit_parallelization_info=None):
         def _morph(data):
+            print("\tmorphisms:",len(morphisms))
             if array_keys_mapping is None:
                 dynamic_keys_mapping = build_dynamic_keys_mapping(implicit_parallelization_info)
-                next_morphs = [partial(morphism.morph, dynamic_keys_mapping=dynamic_keys_mapping) for morphism in morphisms]
+                next_morphs = [partial(morphism.transfer, dynamic_keys_mapping=dynamic_keys_mapping) for morphism in morphisms]
                 next_impl_para_infos = [implicit_parallelization_info for _ in morphisms]
  #               print('\t\t {}'.format(implicit_parallelization_infos))
             else:

comsdk/parser.py

@@ -2,9 +2,10 @@ import re
 import copy
 import importlib as imp
 
-from comsdk.graph import Graph, Func, State
+from comsdk.graph import Graph, Func, State, Selector
 from comsdk.edge import Edge
 
+
 class Params():
     __slots__=(
         'module',
@@ -15,7 +16,8 @@ class Params():
         'morphism',
         'parallelism',
         'comment',
-        'order'
+        'order',
+        'subgraph'
     )
     def __init__(self):
         for slot in self.__slots__:
@@ -40,17 +42,9 @@ class GraphFactory():
         self.states = {}
         self.tocpp = tocpp
     
-    def add_state(self, statename, selectorname=None):
-        if selectorname is not None:
-            sp = entities[selectorname]
-            if self.tocpp:
-                sel_f = Func(sp.module, sp.entry_func, dummy=True)
-            else:
-                sel_f = Func(sp.module, sp.entry_func, getattr(imp.import_module(sp.module), sp.entry_func))
-        else:
-            sel_f = Func()
+    def add_state(self, statename):
         if statename not in self.states:
-            newstate = State(statename, selector=sel_f)
+            newstate = State(statename)
             self.states[statename] = newstate
     
     def _create_morphism(self, morphname=None):
@@ -91,6 +85,14 @@ class GraphFactory():
         # print("{} --{}-{}--> {}".format(st1, pred, entr, st2))
 
     def build(self):
+        for s in self.states:
+            if s in entities and entities[s].selector is not None:
+                if self.tocpp:
+                    self.states[s].selector = Selector(len(self.states[s].transfers), entities[s].module, entities[s].entry_func, dummy=True)
+                else: 
+                    self.states[s].selector = Selector(len(self.states[s].transfers), entities[s].module, entities[s].entry_func)
+            else:
+                self.states[s].selector =  Selector(len(self.states[s].transfers))
         self.graph = Graph(self.states["__BEGIN__"], self.states["__END__"])
         self.graph.init_graph()
         return self.graph
@@ -101,9 +103,9 @@ class Parser():
         'fact'
     )
 
-    def __init__(self, tocpp=True):
+    def __init__(self, tocpp=False):
         self.entities = {}
-        self.fact = GraphFactory(tocpp=True)
+        self.fact = GraphFactory(tocpp=tocpp)
     
     def _check_brackets(self, rawfile):
         br = 0
@@ -194,7 +196,7 @@ class Parser():
         # one to many connection, here could be selector
         elif len(right)>1:
             p = self._param_from_props(spl[3])
-            self.fact.add_state(left[0],selectorname=p.selector)
+            self.fact.add_state(left[0])
             morphs = self._split_multiple(p)
             print("MORPH", morphs[0])
             if len(morphs)!=len(right):
@@ -218,6 +220,9 @@ class Parser():
         dot = file.read()
         self._check_brackets(dot)
         
+        comments = [m for m in re.finditer(r'\".*\"', dot)]
+        for m in comments:
+            dot=dot[:m.span()[0]]+(dot[m.span()[0]:m.span()[1]]).replace(' ','\0')+dot[m.span()[1]:]
         dot = re.sub(r"[ \t\r]", "", dot) #deleting all spaces
         dot = re.sub(r"((digraph\w+\n?)|}|{)", "", dot)
         dot = re.sub(r"\/\/.*", "", dot)
@@ -246,6 +251,3 @@ class Parser():
         self.entities = entities
         return self.fact.build()
 
-pars = Parser()
-graph = pars.parse_file("./test.adot")
-

main.py

 import comsdk.parser as prs
 from comsdk.graph import Selector, Func
+
+data = {}
+
+sl = Selector(1)
+print(sl.func(data))
+pars = prs.Parser(tocpp=True)
+graph = pars.parse_file("./test.adot")
+

test.adot

@@ -32,9 +32,9 @@ digraph CODEOBJECT_GENERATOR
 	INPUT_READY -> TEPMLATE_COPIED [morphism=EDGE_1]
 	TEPMLATE_COPIED -> NAMES_SUBSTITUTED [morphism=EDGE_2]
 	NAMES_SUBSTITUTED -> CONTENT_SUBSTITUTED [morphism=EDGE_3]
-	CONTENT_SUBSTITUTED -> DUMP_CREATED [morphism=EDGE_10]
-	CONTENT_SUBSTITUTED -> RESULT_SAVED [morphism=EDGE_4]
-	CONTENT_SUBSTITUTED -> RESULT_SAVED [morphism=EDGE_5,comment="test comment to cpp"]
+	CONTENT_SUBSTITUTED -> DUMP_CREATED [morphism=EDGE_10, order=3]
+	CONTENT_SUBSTITUTED -> RESULT_SAVED [morphism=EDGE_4, order=2]
+	CONTENT_SUBSTITUTED -> RESULT_SAVED [morphism=EDGE_5,order=1,comment="test comment to cpp"]
 // В зависимости от результата вычисления функции-SELECTOR осуществляется переход по
 //первому или второму ребру
 	RESULT_SAVED -> __END__ [morphism=EDGE_8, order=(40)]

test_funcs/simplest.py

+def dummy_edge(data):
+    pass
+
+def increment_a_edge(data):
+    data['a'] += 1
+
+def increment_a_array_edge(data):
+    for i in range(len(data['a'])):
+        data['a'][i] += 1
+
+def increment_b_edge(data):
+    data['b'] += 1
+
+def decrement_a_edge(data):
+    data['a'] -= 1
+
+def nonzero_predicate(data):
+    return True if data['a'] != 0 else False
+
+def positiveness_predicate(data):
+    return True if data['a'] > 0 else False
+
+def nonpositiveness_predicate(data):
+    return True if data['a'] <= 0 else False
\ No newline at end of file

test_parser.py

+import unittest
+from copy import deepcopy
+import subprocess
+import os
+import random
+# import test_funcs.simplest as tf
+import comsdk.parser as pars
+
+prsr = pars.Parser()
+print(prsr.fact.tocpp)
+graph = prsr.parse_file('./tests/parser_test/simple.adot')
+
+data = {"a":1}
+
+graph.run(data)
+
+print(data)
+

tests/parser_test/simple.adot

+digraph SIMPLEST {
+    FUNC [module=test_funcs.simplest, entry_func=increment_a_edge]
+    PRED [module=test_funcs.simplest, entry_func=nonzero_predicate]
+    MORPH [predicate=PRED, function=FUNC]
+    __BEGIN__ -> ST1 [morphism = MORPH]
+    ST1 -> ST2 [morphism=MORPH]
+    ST2 -> __END__ [morphism=MORPH]
+}
\ No newline at end of file