Reafactor Pt. 3: Improved Runtime Env / ui Pt.1

engine/__init__.py

@@ -1,18 +1,67 @@
-# from pathos.multiprocessing import ProcessingPool as Pool
+
-#
+
-# class Multiproc(object):
+from pathos.multiprocessing import ProcessingPool as Pool
-#
+
-#     def __init__(self, fs, states_list, configs, env_processes, Ts, Ns):
+import pandas as pd
-#         self.fs = fs
+from tabulate import tabulate
-#         self.states_list = states_list
+
-#         self.configs = configs
+from utils import flatten
-#         self.env_processes = env_processes
+from utils.ui import create_tensor_field
-#         self.Ts = Ts
+from utils.configProcessor import generate_config
-#         self.Ns = Ns
+
-#
+class ExecutionContext(object):
-#     def parallelize_simulations(self):
+
-#         l = list(zip(self.fs, self.states_list, self.configs, self.env_processes, self.Ts, self.Ns))
+    def __init__(self):
-#         with Pool(len(self.configs)) as p:
+        def parallelize_simulations(fs, states_list, configs, env_processes, Ts, Ns):
-#             results = p.map(lambda t: t[0](t[1], t[2], t[3], t[4], t[5]), l)
+            l = list(zip(fs, states_list, configs, env_processes, Ts, Ns))
-#
+            with Pool(len(configs)) as p:
-#         return results
+                results = p.map(lambda t: t[0](t[1], t[2], t[3], t[4], t[5]), l)
+
+            return results
+
+        self.parallelize_simulations = parallelize_simulations
+
+
+class Executor(object):
+
+    def __init__(self, ExecutionContext, configs):
+        from engine.simulation import Executor
+
+        def execute():
+            ec = ExecutionContext()
+            print(configs)
+            states_lists, Ts, Ns, eps, configs_struct, env_processes, mechanisms, simulation_execs = \
+                [], [], [], [], [], [], [], []
+            config_idx = 0
+            for x in configs:
+                states_lists.append([x.state_dict])
+                Ts.append(x.sim_config['T'])
+                Ns.append(x.sim_config['N'])
+                eps.append(list(x.exogenous_states.values()))
+                configs_struct.append(generate_config(x.state_dict, x.mechanisms, eps[config_idx]))
+                env_processes.append(x.env_processes)
+                mechanisms.append(x.mechanisms)
+                simulation_execs.append(Executor(x.behavior_ops).simulation)
+
+                config_idx += 1
+
+            # Dimensions: N x r x mechs
+
+            if len(configs) > 1:
+                simulations = ec.parallelize_simulations(simulation_execs, states_lists, configs_struct, env_processes, Ts, Ns)
+
+                for result, mechanism, ep in list(zip(simulations, mechanisms, eps)):
+                    print(tabulate(create_tensor_field(mechanism, ep), headers='keys', tablefmt='psql'))
+                    print(tabulate(pd.DataFrame(flatten(result)), headers='keys', tablefmt='psql'))
+            else:
+                print('single note')
+                simulation, states_list, config = simulation_execs.pop(), states_lists.pop(), configs_struct.pop()
+                env_process = env_processes.pop()
+                # simulations = [simulation(states_list, config, env_processes, T, N)]
+
+            # behavior_ops, states_list, configs, env_processes, time_seq, runs
+            # result = simulation(states_list1, config1, conf1.env_processes, T, N)
+            # return pd.DataFrame(flatten(result))
+
+        self.ExecutionContext = ExecutionContext
+        self.main = execute

refactored_test.py

@@ -0,0 +1,7 @@
+
+from engine import ExecutionContext, Executor
+from ui import config1, config2
+
+configs = [config1, config2]
+run = Executor(ExecutionContext, configs)
+result = run.main()

runtime/run.py

@@ -1,10 +1,10 @@
 import pandas as pd
 from tabulate import tabulate
 from configuration import configs
-from utils.engine import flatten
+from utils import flatten
 from utils.ui import create_tensor_field
-from engine.configProcessor import generate_config
+from utils.configProcessor import generate_config
-from engine.mechanism import Executor
+from engine.simulation import Executor
 from runtime.multiproc import parallelize_simulations
 
 # from ui import config1, config2

utils/__init__.py

@@ -0,0 +1,4 @@
+flatten = lambda l: [item for sublist in l for item in sublist]
+
+def flatmap(f, items):
+        return list(map(f, items))

utils/engine.py

@@ -1,11 +1,5 @@
 from datetime import datetime
 
-flatten = lambda l: [item for sublist in l for item in sublist]
-
-def flatmap(f, items):
-        return list(map(f, items))
-
-
 def datetime_range(start, end, delta, dt_format='%Y-%m-%d %H:%M:%S'):
     reverse_head = end
     [start, end] = [datetime.strptime(x, dt_format) for x in [start, end]]

utils/ui.py

@@ -1,5 +1,5 @@
 import pandas as pd
-from engine.configProcessor import create_matrix_field
+from utils.configProcessor import create_matrix_field
 
 def create_tensor_field(mechanisms, exo_proc, keys=['behaviors', 'states']):
     dfs = [ create_matrix_field(mechanisms, k) for k in keys ]