selector works, cycles tested, parallel tested

comsdk/edge.py

@@ -51,7 +51,7 @@ class Edge(object):
         self._io_mapping = io_mapping
         self.preprocess = lambda pd: None
         self.postprocess = lambda pd: None
-        self.order = int(order)
+        self.order = int(0 if order is None else order)
 
     def predicate(self, data, dynamic_keys_mapping={}):
         proxy_data = self._io_mapping.build_proxy_data(data, dynamic_keys_mapping)

comsdk/graph.py

@@ -17,15 +17,18 @@ class Func():
     def __init__(self, module="", name="", dummy=False,func=None):
         self.module = module
         self.name = name
-        if module =="" or name =="":
+        if module =="" or name =="" or module is None or name is None:
             dummy = True
         if func is not None:
             self.func = func
         elif dummy:
             self.func = lambda data: data
         else: 
-            # print(module, name, "loading")
+            print("LOADING function {} from {} module".format(name, module) )
+            try:
                 self.func = getattr(imp.import_module(module), name)
+            except Exception:
+                raise Exception("Could not load function {} from {} module".format(name, module))
 
     def __str__(self):
         return "{}.{}()".format(self.module, self.name)
@@ -107,27 +110,6 @@ class Graph:
                 return False
         return True
 
-    def generate_cpp(self):
-        data = {}
-        self.init_graph(data)
-        cur_state = self.init_state
-        implicit_parallelization_info = None
-        while cur_state is not None:
- #           print('1) In main loop', implicit_parallelization_info)
-#            morph = _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)
-            print(cur_state.name, transfer_f) 
-            cur_state = transfer_f(data)
-#            print(morph)
-            if '__EXCEPTION__' in data:
-                return False
-        return True
-
-
     def init_graph(self, data={}):
         if not self._initialized:
             self.init_state.idle_run(IdleRunType.INIT, [self.init_state.name])
@@ -208,6 +190,7 @@ class State:
 
     def connect_to(self, term_state, edge=None):
         self.transfers.append(Transfer(edge, term_state))
+        self.selector = Selector(len(self.transfers))
 #        edge.set_output_state(term_state)
 #        self.output_edges.append(edge)
 
@@ -219,6 +202,7 @@ class State:
     
     def run(self, data, implicit_parallelization_info=None):
         print('STATE {}\n\tjust entered, implicit_parallelization_info: {}'.format(self.name, implicit_parallelization_info))
+        print('\t{}'.format(data))
         if self._proxy_state is not None:
             return self._proxy_state.run(data, implicit_parallelization_info)
         self._activate_input_edge(implicit_parallelization_info)
@@ -230,21 +214,17 @@ class State:
         self._reset_activity(implicit_parallelization_info)
         if self.is_term_state:
             implicit_parallelization_info = None
-        #print(self.name)
         if len(self.transfers) == 0:
             return transfer_to_termination, None
-        predicate_values = []
         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_edges = self.selector.func(predicate_values)
+        selected_edges = self.selector.func(data)
         if not selected_edges:
             raise GraphUnexpectedTermination(
-                'State {}: Predicate values {} do not conform selection policy'.format(self.name, predicate_values))
+                "STATE {}: error in selector: {} ".format(self.name, selected_edges))
         selected_transfers = [self.transfers[i] for i, _ in enumerate(selected_edges) if selected_edges[i]==True]
         for transf in selected_transfers:
             if not transf.edge.predicate(data, dynamic_keys_mapping):
-                raise Exception("\tERROR: predicate {} returns False running from STATE {}".format(transf.edge.pred_name, self.name))
+                raise Exception("\tERROR: predicate {} returns {} running from STATE {}".format(transf.edge.pred_name,transf.edge.predicate(data, dynamic_keys_mapping), self.name))
         return self.parallelization_policy.make_transfer_func(selected_transfers,
                                                          array_keys_mapping=self.array_keys_mapping,
                                                          implicit_parallelization_info=implicit_parallelization_info,), \
@@ -296,6 +276,11 @@ class State:
     def _has_loop(self):
         return self.looped_edges_number != 0
 
+    def cpp_print(self, parameter_list):
+        ststr = "{}:\n\t".format(self.name)
+        for t in self.transfers:
+            print(t.edge)
+
 def transfer_to_termination(data):
     return None
 
@@ -332,7 +317,7 @@ class SerialParallelizationPolicy:
             #while len(next_morphs) != 1 or _is_implicitly_parallelized(next_impl_para_infos):
             while len(next_morphs) != 1 or _requires_joint_of_implicit_parallelization(array_keys_mapping, next_impl_para_infos):
                 if next_impl_para_infos == []:
-                    raise Exception(str(len(next_morphs)))
+                    raise Exception("Morpsh count on state is {}".format(str(len(next_morphs))))
 #                print(array_keys_mapping, next_impl_para_infos)
                 cur_morphs[:] = next_morphs[:]
                 cur_impl_para_infos[:] = next_impl_para_infos[:]

comsdk/parser.py

@@ -83,7 +83,7 @@ class GraphFactory():
     def add_connection(self, st1, st2, morphism=None, ordr=0):
         pred, entr = self._create_morphism(morphism)
         self.states[st1].connect_to(self.states[st2], edge=Edge(pred, entr, order=ordr))
-        # print("{} --{}-{}--> {}".format(st1, pred, entr, st2))
+        print("{} -> {}".format(st1, st2))
 
     def build(self):
         print("BUILDING {}\nStates:".format(self.name))
@@ -96,10 +96,11 @@ class GraphFactory():
         self.graph.init_graph()
         for s in self.states:
             if s in self.entities and self.entities[s].selector is not None:
+                selname = self.entities[s].selector
                 if self.tocpp:
-                    self.states[s].selector = Selector(len(self.states[s].transfers), self.entities[s].module, self.entities[s].entry_func, dummy=True)
+                    self.states[s].selector = Selector(len(self.states[s].transfers), self.entities[selname].module, self.entities[selname].entry_func, dummy=True)
                 else:
-                    self.states[s].selector = Selector(len(self.states[s].transfers), self.entities[s].module, self.entities[s].entry_func)
+                    self.states[s].selector = Selector(len(self.states[s].transfers), self.entities[selname].module, self.entities[selname].entry_func)
             else:
                 self.states[s].selector =  Selector(len(self.states[s].transfers))
             if s in self.entities and self.entities[s].subgraph is not None:
@@ -107,6 +108,7 @@ class GraphFactory():
                 parsr = Parser(subgraph=True)
                 subgr = parsr.parse_file(self.entities[s].subgraph)
                 self.states[s].replace_with_graph(subgr)
+        self.graph.init_graph()
         return self.graph
 
 class Parser():
@@ -216,6 +218,7 @@ class Parser():
             p = self._param_from_props(spl[3])
             self.fact.add_state(left[0])
             morphs = self._split_multiple(p)
+            print(p)
             print("MORPH", morphs[0])
             if len(morphs)!=len(right):
                 raise Exception("\tERROR:Count of edges do not match to count of states in one to many connection!\n\t\t{}".format(raw))

test_funcs/simplest.py

@@ -2,7 +2,6 @@ def dummy_edge(data):
     pass
 
 def increment_a_edge(data):
-    data['b'] = 5
     data['a'] += 1
 
 def increment_a_array_edge(data):
@@ -25,4 +24,11 @@ def nonpositiveness_predicate(data):
     return data['a'] <= 0 
 
 def copy_to_c(data):
-    data['c'] = data['b']
\ No newline at end of file
+    data['c'] = data['a']
+
+def selector_a_nonpositive(data):
+    res = data['a'] > 0
+    return [res, not res]
+
+def true_predicate(data):
+    return True

test_parser.py

@@ -3,14 +3,26 @@ from copy import deepcopy
 import subprocess
 import os
 import random
-# import test_funcs.simplest as tf
+from test_funcs.simplest import * 
 import comsdk.parser as pars
+from comsdk.graph import *
+from comsdk.edge import Edge
 
 prsr = pars.Parser()
 print(prsr.fact.tocpp)
-graph = prsr.parse_file('./tests/parser_test/simple.adot')
+graph = prsr.parse_file('./tests/adot/testparal.adot')
 
-data = {"a":1}
+# s_1 = State('cycled_s_1')
+# s_2 = State('cycled_s_2')
+# s_3 = State('cycled_s_3')
+# s_1.connect_to(s_2, edge=Edge(Func(),Func(func=increment_a_edge)))
+# s_2.connect_to(s_3, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
+# s_2.connect_to(s_1, edge=Edge(Func(func=positiveness_predicate), Func(func=increment_a_edge)))
+# 
+# graph = Graph(s_1, s_2)
+
+
+data = {"a":1, "b":1}
 
 graph.run(data)
 

tests/parser_test/simple.adot → tests/adot/simple.adot

 digraph SIMPLEST {
-    FUNC [module=test_funcs.simplest, entry_func=increment_a_edge]
+    FUNC [module=test_funcs.simplest, entry_func=decrement_a_edge]
     PRED [module=test_funcs.simplest, entry_func=positiveness_predicate]
     MORPH [predicate=PRED, function=FUNC]
 
-    FUNC2 [module=test_funcs.simplest, entry_func=copy_to_c]
-    MORPH2 [predicate=PRED, function=FUNC2]
+    SEL [module = test_funcs.simplest, entry_func = selector_a_nonpositive]
+
+    ST2 [selector = SEL]
     
-    ST2 [subgraph=./tests/parser_test/add.adot]
     __BEGIN__ -> ST1 
     ST1 -> ST2 [morphism=MORPH]
-    ST2 -> ST3 [morphism=MORPH2]
-    ST3 -> __END__ [morphism=MORPH]
+    ST2 -> ST1 
+    ST2 -> __END__
 }
\ No newline at end of file

tests/adot/testparal.adot

+digraph SIMPLEST {
+    FUNCA [module=test_funcs.simplest, entry_func=increment_a_edge]
+    FUNCB [module=test_funcs.simplest, entry_func=increment_b_edge]
+    PRED [module=test_funcs.simplest, entry_func=positiveness_predicate]
+    INCR_A [predicate=PRED, function=FUNCA]
+    INCR_B [predicate=PRED, function=FUNCB]
+    
+    __BEGIN__ -> ST2 
+    ST2 -> ST3_1, ST3_2 [morphism=(INCR_A, INCR_B)]
+    ST3_1, ST3_2 -> __END__ [morphism=(INCR_A, INCR_B)]
+}
\ No newline at end of file

tests/adot/testsub.adot

+digraph TEST_SUB {
+    FUNC [module=test_funcs.simplest, entry_func=decrement_a_edge]
+    PRED [module=test_funcs.simplest, entry_func=positiveness_predicate]
+    MORPH [predicate=PRED, function=FUNC]
+
+    ST2 [subgraph = tests/adot/add.dot]
+    
+    __BEGIN__ -> ST1 
+    ST1 -> ST2 [morphism=MORPH]
+    ST2 -> __END 
+}
\ No newline at end of file