init added and some minor changes

comsdk/.vscode/settings.json

+{
+    "python.linting.enabled": true
+}
\ No newline at end of file

comsdk/edge.py

@@ -30,8 +30,8 @@ class Edge(object):
         '_morphism',
         '_io_mapping',
         'preprocess',
-        'postprocess',
-        ]
+        'postprocess'
+    ]
     def __init__(self, predicate, morphism, 
                  io_mapping=InOutMapping(),
                  ):

comsdk/graph.py

@@ -3,16 +3,16 @@ import os
 from enum import Enum, auto
 from functools import partial
 
-import aux as aux
+import comsdk.aux as aux
 
 ImplicitParallelizationInfo = collections.namedtuple('ImplicitParallelizationInfo', ['array_keys_mapping', 'branches_number', 'branch_i'])
 
-class Morphism:
+class Transfer:
     def __init__(self, edge, output_state):
         self.edge = edge
         self.output_state = output_state
 
-    def morph(self, data, dynamic_keys_mapping={}):
+    def transfer(self, data, dynamic_keys_mapping={}):
         #print(dynamic_keys_mapping)
         self.edge.morph(data, dynamic_keys_mapping)
         #return self.output_state, None
@@ -22,21 +22,21 @@ class IdleRunType(Enum):
     INIT = auto()
     CLEANUP = auto()
 
-class GraphFactory:
-    def __init__(self):
-        pass
-
-    def create_state():
-        pass
-
-    def create_edge():
+# class GraphFactory:
+    # def __init__(self):
+        # pass
+# 
+    # def create_state():
+        # pass
+# 
+    # def create_edge():
         # Here we should somehow pass the argument for "special" edges
         # Essentially, we change only io_mapping
-        pass
-
-    def make_graph():
-        pass
-
+        # pass
+# 
+    # def make_graph():
+        # pass
+'''
 class PluralGraphFactory:
     def __init__(self, plural_keys_mappings, parallel_graphs_number):
         self.plural_keys_mappings = plural_keys_mappings
@@ -54,7 +54,7 @@ class PluralGraphFactory:
 
     def make_graph():
         pass
-
+'''
 class PluralState:
     def __init__(self, states):
         self.states = states
@@ -62,7 +62,7 @@ class PluralState:
 
     def connect_to(self, term_states, edge):
         for init_state, term_state in zip(self.states, term_states):
-            init_state.output_morphisms.append(Morphism(edge, term_state))
+            init_state.transfers.append(Transfer(edge, term_state))
 
 class Graph:
     '''
@@ -93,12 +93,12 @@ class Graph:
         while cur_state is not None:
  #           print('1) In main loop', implicit_parallelization_info)
 #            morph = _run_state(cur_state, data, implicit_parallelization_info)
-            morph, implicit_parallelization_info = _run_state(cur_state, data, implicit_parallelization_info)
+            transfer_f, implicit_parallelization_info = _run_state(cur_state, data, implicit_parallelization_info)
 #            print('2) In main loop', implicit_parallelization_info)
             if '__EXCEPTION__' in data:
                 return False
 #            cur_state, implicit_parallelization_info = morph(data)
-            cur_state = morph(data)
+            cur_state = transfer_f(data)
 #            print(morph)
             if '__EXCEPTION__' in data:
                 return False
@@ -117,10 +117,10 @@ class Graph:
 class State:
     __slots__ = [
         'name',
-        'input_edges_number',
+        'input_edges_number', #output_edges_number == len(transfers)
         'looped_edges_number',
         'activated_input_edges_number',
-        'output_morphisms',
+        'transfers',
         'parallelization_policy',
         'selection_policy',
         'is_term_state',
@@ -140,7 +140,7 @@ class State:
         self.input_edges_number = 0
         self.looped_edges_number = 0
         self.activated_input_edges_number = 0
-        self.output_morphisms = []
+        self.transfers = []
         self.is_term_state=False
         self._branching_states_history = None
         self._proxy_state=None
@@ -170,21 +170,21 @@ class State:
             self.activated_input_edges_number += 1 # BUG: here we need to choose somehow whether we proceed or not
 #        if len(self.output_edges) == 0:
 #            print('Terminate state found')
-        if len(self.output_morphisms) == 1:
-            self.output_morphisms[0].output_state.idle_run(idle_run_type, branching_states_history)
+        if len(self.transfers) == 1:
+            self.transfers[0].output_state.idle_run(idle_run_type, branching_states_history)
         else:
-            for i, morphism in enumerate(self.output_morphisms):
-                next_state = morphism.output_state
+            for i, transfer in enumerate(self.transfers):
+                next_state = transfer.output_state
                 next_state.idle_run(idle_run_type, branching_states_history + [next_state.name])
 
     def connect_to(self, term_state, edge):
-        self.output_morphisms.append(Morphism(edge, term_state))
+        self.transfers.append(Transfer(edge, term_state))
 #        edge.set_output_state(term_state)
 #        self.output_edges.append(edge)
 
     def replace_with_graph(self, graph):
         self._proxy_state = graph.init_state
-        graph.term_state.output_morphisms = self.output_morphisms
+        graph.term_state.transfers = self.transfers
 
     def run(self, data, implicit_parallelization_info=None):
         print('STATE {}, just entered, implicit_parallelization_info: {}'.format(self.name, implicit_parallelization_info))
@@ -194,31 +194,28 @@ class State:
         #self.activated_input_edges_number += 1
         print('STATE {}, required input: {}, active: {}, looped: {}'.format(self.name, self.input_edges_number, self.activated_input_edges_number, self.looped_edges_number))
 #        print('qwer')
-        if not self._ready_to_morph(implicit_parallelization_info):
+        if not self._ready_to_transfer(implicit_parallelization_info):
             return None, None # it means that this state waits for some incoming edges (it is a point of collision of several edges)
         self._reset_activity(implicit_parallelization_info)
         if self.is_term_state:
             implicit_parallelization_info = None
         #print(self.name)
-        if len(self.output_morphisms) == 0:
-            return morphism_to_termination, None
+        if len(self.transfers) == 0:
+            return transfer_to_termination, None
         predicate_values = []
         dynamic_keys_mapping = build_dynamic_keys_mapping(implicit_parallelization_info)
-        for morphism in self.output_morphisms:
-            predicate_values.append(morphism.edge.predicate(data, dynamic_keys_mapping))
+        for transfer in self.transfers:
+            predicate_values.append(transfer.edge.predicate(data, dynamic_keys_mapping))
         selected_edge_indices = self.selection_policy.select(predicate_values)
         if not selected_edge_indices:
             raise GraphUnexpectedTermination(
                 'State {}: Predicate values {} do not conform selection policy'.format(self.name, predicate_values))
-        selected_morphisms = [self.output_morphisms[i] for i in selected_edge_indices]
-        return self.parallelization_policy.make_morphism(selected_morphisms,
+        selected_transfers = [self.transfers[i] for i in selected_edge_indices]
+        return self.parallelization_policy.make_transfer_func(selected_transfers,
                                                          array_keys_mapping=self.array_keys_mapping,
                                                          implicit_parallelization_info=implicit_parallelization_info,), \
                implicit_parallelization_info
 
-#        return self.parallelization_policy.make_morphism(selected_morphisms,
-#                                                         array_keys_mapping=self.array_keys_mapping,
-#                                                         implicit_parallelization_info=implicit_parallelization_info,)
 
     def _activate_input_edge(self, implicit_parallelization_info=None):
         if implicit_parallelization_info is None or self.is_term_state:
@@ -228,7 +225,7 @@ class State:
                 self.activated_input_edges_number = [0 for i in range(implicit_parallelization_info.branches_number)]
             self.activated_input_edges_number[implicit_parallelization_info.branch_i] += 1
 
-    def _ready_to_morph(self, implicit_parallelization_info=None):
+    def _ready_to_transfer(self, implicit_parallelization_info=None):
         required_activated_input_edges_number = self.input_edges_number - self.looped_edges_number
         if implicit_parallelization_info is not None:
             if self.is_term_state:
@@ -247,7 +244,7 @@ class State:
 
     def _reset_activity(self, implicit_parallelization_info=None):
         self._branching_states_history = None
-        if self._ready_to_morph(implicit_parallelization_info) and self._has_loop():
+        if self._ready_to_transfer(implicit_parallelization_info) and self._has_loop():
             if implicit_parallelization_info is None or self.is_term_state:
                 self.activated_input_edges_number -= 1
             else:
@@ -265,7 +262,7 @@ class State:
     def _has_loop(self):
         return self.looped_edges_number != 0
 
-def morphism_to_termination(data):
+def transfer_to_termination(data):
     return None
 
 class SerialParallelizationPolicy:
@@ -274,55 +271,7 @@ class SerialParallelizationPolicy:
     def __init__(self):
         pass
 
-#    def make_morphism(self, morphisms, array_keys_mapping=None, implicit_parallelization_info=None):
-#        def _morph(data):
-#            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_impl_para_infos = [implicit_parallelization_info for _ in morphisms]
-# #               print('\t\t {}'.format(implicit_parallelization_infos))
-#            else:
-#                if len(morphisms) != 1:
-#                    raise BadGraphStructure('Impossible to create implicit paralleilzation in the state with {} output edges'.format(len(morphisms)))
-#                dynamic_keys_mapping = build_dynamic_keys_mapping(implicit_parallelization_info)
-#                proxy_data = aux.ProxyDict(data, keys_mappings=array_keys_mapping)
-#                anykey = next(iter(array_keys_mapping.keys()))
-#                implicit_branches_number = len(proxy_data[anykey])
-#                next_morphs = []
-#                next_impl_para_infos = []
-#                for branch_i in range(implicit_branches_number):
-#                    implicit_parallelization_info_ = ImplicitParallelizationInfo(array_keys_mapping, implicit_branches_number, branch_i)
-#                    dynamic_keys_mapping = build_dynamic_keys_mapping(implicit_parallelization_info_)
-#                    next_morphs.append(partial(morphisms[0].morph, dynamic_keys_mapping=dynamic_keys_mapping))
-#                    next_impl_para_infos.append(implicit_parallelization_info_)
-#            cur_morphs = []
-#            cur_impl_para_infos = []
-#            while len(next_morphs) != 1:
-#                cur_morphs[:] = next_morphs[:]
-#                cur_impl_para_infos[:] = next_impl_para_infos[:]
-#                del next_morphs[:]
-#                del next_impl_para_infos[:]
-#                # WE DO NOT UPDATE implicit_parallelization_infos !!!
-#                for morph, impl_para_info in zip(cur_morphs, cur_impl_para_infos):
-#                    next_state, _ = morph(data)
-##                    print('\t next_state: {}, with impl para info: {}'.format(next_state.name, impl_para_info))
-#                    if next_state is None:
-#                        return None, None
-#                    next_morph = _run_state(next_state, data, impl_para_info)
-##                    print('\t next_morph: {}'.format(next_morph))
-#                    if '__EXCEPTION__' in data:
-#                        return None, None
-#                    if next_morph is not None:
-#                        next_morphs.append(next_morph)
-#                        next_impl_para_infos.append(impl_para_info)
-#                #print(len(next_morphs))
-##            print('\t last morph: {}'.format(next_morphs[0]))
-#            next_state, _ = next_morphs[0](data)
-#            print(next_state.name, next_impl_para_infos[0])
-#            return next_state, next_impl_para_infos[0]
-#        return _morph
-
-    def make_morphism(self, morphisms, array_keys_mapping=None, implicit_parallelization_info=None):
+    def make_transfer_func(self, morphisms, array_keys_mapping=None, implicit_parallelization_info=None):
         def _morph(data):
             if array_keys_mapping is None:
                 dynamic_keys_mapping = build_dynamic_keys_mapping(implicit_parallelization_info)

comsdk/parser.py → parser.py

 import re
-import graph as gr
-from edge import *
+import comsdk.graph as gr
+from comsdk.edge import *
 import importlib as imp
 from typing import NamedTuple
 from enum import Enum, auto
@@ -57,10 +57,6 @@ class GraphFactory():
                     fu = getattr(morph, m)
                     func_f = getattr(imp.import_module(fu.module), fu.entry_func)
         return pred_f, func_f
-                    
-
-
-
     def connect_states(self, st1, st2, morphism=None):
         pass
         # self.states[st1].connect_to(self.states[st2])

test.adot

+digraph CODEOBJECT_GENERATOR
+{
+// Определения функций-обработчиков
+	FUNC_1 [module=case_gen_funcs, entry_func=function_1]
+	FUNC_2 [module=case_gen_funcs, entry_func=function_2]
+	FUNC_3 [module=case_gen_funcs, entry_func=function_3]
+	SAVE_TO_DB [module=case_gen_funcs, entry_func=save_to_db]
+	SAVE_TO_FILE [module=case_gen_funcs, entry_func=save_to_file]
+	REPEAT [module=case_gen_funcs, entry_func=repeat]
+	EXIT [module=case_gen_funcs, entry_func=exit]
+	CREATE_DUMP [module=case_gen_funcs, entry_func=create_dump]
+// Определения функций-предикатов
+	PREDICATE_X [module=predicate_funcs, entry_func=predicate_x]
+	PREDICATE_Y [module=predicate_funcs, entry_func=predicate_y]
+	SELECTOR [module=predicate_funcs, entry_func=selector]
+// Определения функций перехода
+	EDGE_1 [predicate=PREDICATE_X, function=FUNC_1]
+	EDGE_2 [predicate=PREDICATE_Y, function=FUNC_2]
+	EDGE_3 [predicate=PREDICATE_X, function=FUNC_3]
+	EDGE_4 [predicate=PREDICATE_Y, function=SAVE_TO_DB]
+	EDGE_5 [predicate=PREDICATE_X, function=SAVE_TO_FILE]
+	EDGE_6 [predicate=PREDICATE_Y, function=REPEAT]
+	EDGE_7 [predicate=PREDICATE_X, function=EXIT]
+	EDGE_8 [function=EXIT]
+	EDGE_9 [predicate=CHECK_DUMP, function=EXIT]
+	EDGE_10 [function=CREATE_DUMP]
+// В узле указана стратегия распараллеливания	
+	CONTENT_SUBSTITUTED [parallelism=threading]
+// Определение графовой модели
+	__BEGIN__ -> INPUT_READY
+	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"]
+// В зависимости от результата вычисления функции-SELECTOR осуществляется переход по
+//первому или второму ребру
+	RESULT_SAVED -> INPUT_READY,__END__ [selector=SELECTOR, morphism=(EDGE_6, EDGE_7)]
+	RESULT_SAVED, DUMP_CREATED -> __END__ [morphism=(EDGE_8, EDGE_9)]
+}