math-spec-mapping 0.3.5__tar.gz → 0.3.7__tar.gz

{math_spec_mapping-0.3.5/src/math_spec_mapping.egg-info → math_spec_mapping-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.3.5
+Version: 0.3.7
 Summary: A library for easy mapping of mathematical specifications.
 Author-email: Sean McOwen <Sean@Block.Science>
 Classifier: Programming Language :: Python :: 3
@@ -45,8 +45,9 @@ Writing mathematical specifications can be a difficult process, especially when
 ```mermaid
 graph TD
 A[JSON Object \n\n Each spec has a repo for tracking changes \n Must conform to the json specification \n Defines all aspects of the spec including blocks, spaces and actions] -->B[MSML Object \n\n JSON file is parsed, with validations and mappings along the way \n Can show different views on the fly]
-    B --> C[Report Outputs \n\n Automatically build reports for the full spec or subviews \n Example: all blocks with an effect on variable XYZ]
-
+    B --> C[Report Outputs & Obsidian Directory \n\n Automatically build reports for the full spec or subviews \n Example: all blocks with an effect on variable XYZ\n Also builds an entire Obsidian directory of all components as linked notes]
+D[Python Function Implementations \n\n Optional enhancement to actually execute code\n Done for each referenced policy option, mechanism, etc. \n Just needs a function definition for each] --> B 
+B --> E[Python Wirings & Simulations \n\n MSML can be used to run blocks \n Wirings automatically work to pass between domain/codomains \n Entire simulations can be built up as composed wirings]
 ```
 
 ## MSML in the Engineering Lifecycle

{math_spec_mapping-0.3.5 → math_spec_mapping-0.3.7}/README.md

@@ -30,8 +30,9 @@ Writing mathematical specifications can be a difficult process, especially when
 ```mermaid
 graph TD
 A[JSON Object \n\n Each spec has a repo for tracking changes \n Must conform to the json specification \n Defines all aspects of the spec including blocks, spaces and actions] -->B[MSML Object \n\n JSON file is parsed, with validations and mappings along the way \n Can show different views on the fly]
-    B --> C[Report Outputs \n\n Automatically build reports for the full spec or subviews \n Example: all blocks with an effect on variable XYZ]
-
+    B --> C[Report Outputs & Obsidian Directory \n\n Automatically build reports for the full spec or subviews \n Example: all blocks with an effect on variable XYZ\n Also builds an entire Obsidian directory of all components as linked notes]
+D[Python Function Implementations \n\n Optional enhancement to actually execute code\n Done for each referenced policy option, mechanism, etc. \n Just needs a function definition for each] --> B 
+B --> E[Python Wirings & Simulations \n\n MSML can be used to run blocks \n Wirings automatically work to pass between domain/codomains \n Entire simulations can be built up as composed wirings]
 ```
 
 ## MSML in the Engineering Lifecycle

{math_spec_mapping-0.3.5 → math_spec_mapping-0.3.7}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "math-spec-mapping"
-version = "0.3.5"
+version = "0.3.7"
 authors = [
   { name="Sean McOwen", email="Sean@Block.Science" },
 ]

{math_spec_mapping-0.3.5 → math_spec_mapping-0.3.7}/src/math_spec_mapping/Classes/Block.py

@@ -37,6 +37,7 @@ class Block:
                 )
             ]
         )
+        self.domain_blocks2 = self.domain_blocks[:]
         self.codomain_blocks = tuple(
             [
                 self
@@ -191,6 +192,9 @@ class ParallelBlock(Block):
         self.domain_blocks = tuple(
             [i for x in self.components for i in x.domain_blocks]
         )
+        self.domain_blocks2 = tuple(
+            [x for x in self.components for i in x.domain_blocks2]
+        )
         self.codomain_blocks = tuple(
             [i for x in self.components for i in x.codomain_blocks]
         )
@@ -320,6 +324,7 @@ class StackBlock(Block):
         )
 
         self.domain_blocks = self.components[0].domain_blocks
+        self.domain_blocks2 = self.components[0].domain_blocks2
         self.codomain_blocks = self.components[-1].codomain_blocks
         self.domain_blocks_empty = self.components[0].domain_blocks_empty
         self.codomain_blocks_empty = self.components[-1].codomain_blocks_empty

{math_spec_mapping-0.3.5 → math_spec_mapping-0.3.7}/src/math_spec_mapping/Classes/MathSpec.py

@@ -7,6 +7,7 @@ from .BoundaryAction import BoundaryAction
 import os
 from copy import deepcopy
 import shutil
+import pandas as pd
 
 
 class MathSpec:
@@ -45,6 +46,7 @@ class MathSpec:
         self._check_dictionary_names()
         self._build_functional_parameters()
         self._build_parameter_types()
+        self._crawl_spaces()
 
     def _check_dictionary_names(self):
         for key in self.boundary_actions:
@@ -406,6 +408,18 @@ class MathSpec:
         self.behavioral_parameters_types = behavioral_parameters_types
         self.functional_parameters_types = functional_parameters_types
 
+    def _crawl_spaces(self):
+        self._used_spaces = []
+        self._used_spaces.extend([x.codomain for x in self.control_actions.values()])
+        self._used_spaces.extend([x.codomain for x in self.boundary_actions.values()])
+        self._used_spaces.extend([x.domain for x in self.policies.values()])
+        self._used_spaces.extend([x.codomain for x in self.policies.values()])
+        self._used_spaces.extend([x.domain for x in self.mechanisms.values()])
+
+        self._used_spaces = list(set().union(*self._used_spaces))
+        us_names = [y.name for y in self._used_spaces]
+        self._unused_spaces = [self.spaces[x] for x in self.spaces if x not in us_names]
+
     def metaprogramming_python_types(self, model_directory, overwrite=False):
         path = model_directory + "/types.py"
         if not overwrite:
@@ -456,6 +470,75 @@ class MathSpec:
         with open(path, "w") as f:
             f.write(out)
 
+    def run_experiment(
+        self,
+        experiment,
+        params_base,
+        state_base,
+        post_processing_function,
+        state_preperation_functions=None,
+        metrics_functions=None,
+    ):
+        if experiment["Param Modifications"]:
+            params_base = deepcopy(params_base)
+            for key in experiment["Param Modifications"]:
+                params_base[key] = experiment["Param Modifications"][key]
+        msi = self.build_implementation(params_base)
+        state, params = msi.prepare_state_and_params(
+            state_base,
+            params_base,
+            state_preperation_functions=state_preperation_functions,
+        )
+
+        state = msi.execute_blocks(state, params, experiment["Blocks"])
+        df = post_processing_function(state, params)
+
+        if metrics_functions:
+            metrics = {}
+            for metrics_function in metrics_functions:
+                metrics_function(metrics, state, params, df)
+            metrics = pd.Series(metrics)
+        else:
+            metrics = None
+
+        return state, params, msi, df, metrics
+
+    def run_experiments(
+        self,
+        experiments,
+        params_base,
+        state_base,
+        post_processing_function,
+        state_preperation_functions=None,
+        metrics_functions=None,
+    ):
+        state_l = []
+        params_l = []
+        df_l = []
+        metrics_l = []
+        for experiment in experiments:
+            for i in range(experiment["Monte Carlo Runs"]):
+                state, params, msi, df, metrics = self.run_experiment(
+                    experiment,
+                    params_base,
+                    state_base,
+                    post_processing_function,
+                    state_preperation_functions=state_preperation_functions,
+                    metrics_functions=metrics_functions,
+                )
+                df["Monte Carlo Run"] = i + 1
+                df["Experiment"] = experiment["Name"]
+                metrics.loc["Monte Carlo Run"] = i + 1
+                metrics.loc["Experiment"] = experiment["Name"]
+                metrics.name = "{}-{}".format(experiment["Name"], i + 1)
+                state_l.append(state)
+                params_l.append(params)
+                df_l.append(df)
+                metrics_l.append(metrics)
+        df = pd.concat(df_l)
+        metrics = pd.concat(metrics_l, axis=1).T
+        return df, metrics, state_l, params_l
+
     def metaprogramming_python_states(
         self, model_directory, overwrite=False, default_values=None
     ):
@@ -683,7 +766,9 @@ class MathSpecImplementation:
         self.boundary_actions = self.load_boundary_actions()
         self.policies = self.load_policies()
         self.mechanisms = self.load_mechanisms()
+        self.stateful_metrics = self.load_stateful_metrics()
         self.load_wiring()
+        self.load_components()
 
     def load_control_actions(self):
         control_actions = {}
@@ -761,6 +846,10 @@ class MathSpecImplementation:
         return mechanisms
 
     def load_single_wiring(self, wiring):
+        hold = wiring
+        domain_sizes = {}
+        for x in wiring.components:
+            domain_sizes[x.name] = len(x.domain)
         components = [x.name for x in wiring.components]
         if wiring.block_type == "Stack Block":
 
@@ -772,16 +861,32 @@ class MathSpecImplementation:
         elif wiring.block_type == "Parallel Block":
 
             spaces_mapping = {}
-            for x in wiring.components:
-                spaces_mapping[x.name] = []
 
-            for i, x in enumerate([x.name for x in wiring.domain_blocks]):
+            for y in [x.name for x in wiring.domain_blocks2]:
+                spaces_mapping[y] = []
+
+            for i, x in enumerate([x.name for x in wiring.domain_blocks2]):
                 spaces_mapping[x].append(i)
 
             def wiring(state, params, spaces):
+                spaces_mapping_temp = deepcopy(spaces_mapping)
                 codomain = []
                 for component in components:
-                    spaces_i = [spaces[i] for i in spaces_mapping[component]]
+                    if component in spaces_mapping_temp:
+                        spaces_i = [spaces[i] for i in spaces_mapping_temp[component]][
+                            : domain_sizes[component]
+                        ]
+                        # Fix for repeated block names
+                        spaces_mapping_temp[component] = spaces_mapping_temp[component][
+                            domain_sizes[component] :
+                        ]
+                    else:
+                        assert component in [
+                            x.name for x in hold.domain_blocks_empty
+                        ], "{} not in domain_blocks_empty of wiring {}".format(
+                            component, hold
+                        )
+                        spaces_i = []
                     spaces_i = self.blocks[component](state, params, spaces_i)
                     if spaces_i:
                         codomain.extend(spaces_i)
@@ -822,6 +927,22 @@ class MathSpecImplementation:
                     policies[p.name] = opt.implementations["python"]
         return policies
 
+    def load_stateful_metrics(self):
+        stateful_metrics = {}
+
+        for sm in self.ms.stateful_metrics_map:
+            sm = self.ms.stateful_metrics_map[sm]
+            if "python" not in sm.implementations:
+                print(
+                    "No python implementation for {}. To fix this, go to Implementations/Python/StatefulMetrics and add {}".format(
+                        sm.name, sm.name
+                    )
+                )
+            else:
+                stateful_metrics[sm.name] = sm.implementations["python"]
+
+        return stateful_metrics
+
     def load_wiring(
         self,
     ):
@@ -885,3 +1006,29 @@ class MathSpecImplementation:
         assert (
             len(shouldnt_be_in_params) == 0
         ), "The following parameters are extra: {}".format(shouldnt_be_in_params)
+
+    def prepare_state_and_params(self, state, params, state_preperation_functions=None):
+        self.validate_state_and_params(state, params)
+        state = deepcopy(state)
+        params = deepcopy(params)
+        state["Stateful Metrics"] = self.stateful_metrics
+        if state_preperation_functions:
+            for f in state_preperation_functions:
+                state = f(state)
+                assert (
+                    state is not None
+                ), "A state must be returned from the state preperation functions"
+        return state, params
+
+    def load_components(self):
+        self.components = {}
+        self.components.update(self.control_actions)
+        self.components.update(self.boundary_actions)
+        self.components.update(self.policies)
+        self.components.update(self.mechanisms)
+        self.components.update(self.wiring)
+
+    def execute_blocks(self, state, params, blocks):
+        for block in blocks:
+            self.components[block](state, params, [])
+        return state

{math_spec_mapping-0.3.5 → math_spec_mapping-0.3.7}/src/math_spec_mapping/Classes/StatefulMetric.py

@@ -16,6 +16,7 @@ class StatefulMetric:
         else:
             self.label = self.name
         self.metadata = data["metadata"]
+        self.implementations = data["implementations"]
 
 
 class StatefulMetricSet:

{math_spec_mapping-0.3.5 → math_spec_mapping-0.3.7}/src/math_spec_mapping/Load/stateful_metrics.py

@@ -39,6 +39,15 @@ def convert_stateful_metric(ms, data: Dict) -> StatefulMetricSet:
             ), "Variable '{}' not in variable map for stateful metrics variables used".format(
                 x[1]
             )
+
+    var["implementations"] = {}
+
+    if "python" in ms["Implementations"]:
+        if "stateful_metrics" in ms["Implementations"]["python"]:
+            if var["name"] in ms["Implementations"]["python"]["stateful_metrics"]:
+                var["implementations"]["python"] = ms["Implementations"]["python"][
+                    "stateful_metrics"
+                ][var["name"]]
         new_variables.append(StatefulMetric(var))
     data["metrics"] = new_variables
 

{math_spec_mapping-0.3.5 → math_spec_mapping-0.3.7}/src/math_spec_mapping/Reports/markdown.py

@@ -538,7 +538,7 @@ def write_stateful_metrics_markdown_report(ms, path, metric, add_metadata=True):
     out += "Domain: {}\n\n".format(metric.domain)
 
     out += "## Parameters Used\n"
-    for i, x in enumerate(sorted(metric.parameters_used, key=lambda x: x.name)):
+    for i, x in enumerate(sorted(metric.parameters_used, key=lambda x: x)):
         out += "{}. [[{}]]".format(i + 1, x)
         out += "\n"
     out += "\n"

{math_spec_mapping-0.3.5 → math_spec_mapping-0.3.7/src/math_spec_mapping.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.3.5
+Version: 0.3.7
 Summary: A library for easy mapping of mathematical specifications.
 Author-email: Sean McOwen <Sean@Block.Science>
 Classifier: Programming Language :: Python :: 3
@@ -45,8 +45,9 @@ Writing mathematical specifications can be a difficult process, especially when
 ```mermaid
 graph TD
 A[JSON Object \n\n Each spec has a repo for tracking changes \n Must conform to the json specification \n Defines all aspects of the spec including blocks, spaces and actions] -->B[MSML Object \n\n JSON file is parsed, with validations and mappings along the way \n Can show different views on the fly]
-    B --> C[Report Outputs \n\n Automatically build reports for the full spec or subviews \n Example: all blocks with an effect on variable XYZ]
-
+    B --> C[Report Outputs & Obsidian Directory \n\n Automatically build reports for the full spec or subviews \n Example: all blocks with an effect on variable XYZ\n Also builds an entire Obsidian directory of all components as linked notes]
+D[Python Function Implementations \n\n Optional enhancement to actually execute code\n Done for each referenced policy option, mechanism, etc. \n Just needs a function definition for each] --> B 
+B --> E[Python Wirings & Simulations \n\n MSML can be used to run blocks \n Wirings automatically work to pass between domain/codomains \n Entire simulations can be built up as composed wirings]
 ```
 
 ## MSML in the Engineering Lifecycle