math-spec-mapping 0.3.21__tar.gz → 0.4.1__tar.gz

{math_spec_mapping-0.3.21/src/math_spec_mapping.egg-info → math_spec_mapping-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: math-spec-mapping
-Version: 0.3.21
+Version: 0.4.1
 Summary: A library for easy mapping of mathematical specifications.
 Author-email: Sean McOwen <Sean@Block.Science>
 Classifier: Programming Language :: Python :: 3
@@ -12,6 +12,10 @@ License-File: LICENSE
 Requires-Dist: graphviz>=0.20.1
 Requires-Dist: ipython>=7.7.0
 Requires-Dist: pandas>=1.4
+Requires-Dist: jsonschema>=4.21.1
+Requires-Dist: PyGithub==2.5.0
+Requires-Dist: dotenv
+Requires-Dist: python-dotenv>=1.0.0
 
 # Mathematical Specification Mapping Library (MSML)
 

{math_spec_mapping-0.3.21 → math_spec_mapping-0.4.1}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "math-spec-mapping"
-version = "0.3.21"
+version = "0.4.1"
 authors = [
   { name="Sean McOwen", email="Sean@Block.Science" },
 ]
@@ -11,7 +11,11 @@ description = "A library for easy mapping of mathematical specifications."
 dependencies = [
   "graphviz>=0.20.1",
   "ipython>=7.7.0",
-  "pandas>=1.4"
+  "pandas>=1.4",
+  "jsonschema>=4.21.1",
+  "PyGithub==2.5.0",
+  "dotenv",
+  "python-dotenv>=1.0.0"
 ]
 readme = "README.md"
 requires-python = ">=3.7"

{math_spec_mapping-0.3.21 → math_spec_mapping-0.4.1}/src/math_spec_mapping/Classes/MathSpec.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Literal
 from .Entity import Entity
 from .Policy import Policy
 from .Mechanism import Mechanism
@@ -10,6 +10,16 @@ import shutil
 import pandas as pd
 from inspect import signature, getsource, getfile, getsourcelines
 from IPython.display import display, Markdown
+from copy import copy, deepcopy
+
+
+class ValidKeyDict(dict):
+    def __getitem__(self, key):
+        # Add an assertion to check if the key exists
+        assert key in self, "Key not valid, valid options are: {}".format(
+            ", ".join(self.keys())
+        )
+        return super().__getitem__(key)
 
 
 class MathSpec:
@@ -54,6 +64,21 @@ class MathSpec:
         self._crawl_spaces()
         self._set_source_code()
 
+        self.boundary_actions = ValidKeyDict(self.boundary_actions)
+        self.control_actions = ValidKeyDict(self.control_actions)
+        self.entities = ValidKeyDict(self.entities)
+        self.mechanisms = ValidKeyDict(self.mechanisms)
+        self.parameters.parameter_map = ValidKeyDict(self.parameters.parameter_map)
+        self.policies = ValidKeyDict(self.policies)
+        self.spaces = ValidKeyDict(self.spaces)
+        self.state = ValidKeyDict(self.state)
+        self.stateful_metrics_map = ValidKeyDict(self.stateful_metrics_map)
+        self.wiring = ValidKeyDict(self.wiring)
+        self.metrics = ValidKeyDict(self.metrics)
+        self.displays = ValidKeyDict(self.displays)
+        self.blocks = ValidKeyDict(self.blocks)
+        self.components = ValidKeyDict(self.components)
+
     def _check_dictionary_names(self):
         for key in self.boundary_actions:
             assert key == self.boundary_actions[key].name
@@ -727,11 +752,13 @@ class MathSpec:
         state_preperation_functions=None,
         parameter_preperation_functions=None,
         metrics_functions=None,
+        append_param_change_columns=False,
     ):
         state_l = []
         params_l = []
         df_l = []
         metrics_l = []
+        param_mods = set()
         for experiment in experiments:
             for i in range(experiment["Monte Carlo Runs"]):
                 state, params, msi, df, metrics = self.run_experiment(
@@ -743,6 +770,11 @@ class MathSpec:
                     parameter_preperation_functions=parameter_preperation_functions,
                     metrics_functions=metrics_functions,
                 )
+                if append_param_change_columns:
+                    if experiment["Param Modifications"]:
+                        for key in experiment["Param Modifications"]:
+                            df[key] = experiment["Param Modifications"][key]
+                            param_mods.add(key)
                 df["Monte Carlo Run"] = i + 1
                 df["Experiment"] = experiment["Name"]
                 metrics.loc["Monte Carlo Run"] = i + 1
@@ -753,6 +785,9 @@ class MathSpec:
                 df_l.append(df)
                 metrics_l.append(metrics)
         df = pd.concat(df_l)
+        if append_param_change_columns:
+            for key in param_mods:
+                df[key] = df[key].fillna(params_base[key])
         metrics = pd.concat(metrics_l, axis=1).T
         return df, metrics, state_l, params_l
 
@@ -976,6 +1011,50 @@ using .Spaces: generate_space_type
             self, params, domain_codomain_checking=domain_codomain_checking
         )
 
+    def _build_state_space(self):
+        state = self.state["Global State"]
+        state_map = {}
+        for variable in state.variables:
+            if "python" in variable.type.type:
+                state_map[variable.name] = variable.type.type["python"]
+            else:
+                state_map[variable.name] = None
+
+        return state_map
+
+    def _build_parameter_space(self):
+        parameter_space = {}
+        for parameter in self.parameters.all_parameters:
+            parameter = self.parameters.parameter_map[parameter]
+            if "python" in parameter.variable_type.type:
+                parameter_space[parameter.name] = parameter.variable_type.type["python"]
+            else:
+                parameter_space[parameter.name] = None
+        for name in self.functional_parameters.keys():
+            fp = self.functional_parameters[name]
+            fp = tuple(fp.keys())
+            parameter_space[name] = Literal[fp]
+        return parameter_space
+
+    def build_cadCAD(
+        self,
+        blocks,
+        state_preperation_functions=[],
+        parameter_preperation_functions=[],
+    ):
+        out = {}
+        out["StateSpace"] = self._build_state_space()
+        out["ParameterSpace"] = self._build_parameter_space()
+        out["Model"] = cadCADModel(
+            self,
+            out["StateSpace"],
+            out["ParameterSpace"],
+            blocks,
+            state_preperation_functions=state_preperation_functions,
+            parameter_preperation_functions=parameter_preperation_functions,
+        )
+        return out
+
     def _set_source_code(self):
         if "python" not in self.implementations:
             self.source_code = None
@@ -991,6 +1070,126 @@ using .Spaces: generate_space_type
                 self.source_code[x][y] = getsource(self.source_code[x][y])
 
 
+class cadCADModel:
+    def __init__(
+        self,
+        ms,
+        state_space,
+        parameter_space,
+        blocks,
+        state_preperation_functions=[],
+        parameter_preperation_functions=[],
+    ):
+        self.ms = ms
+        self.state_space = state_space
+        self.parameter_space = parameter_space
+        self.blocks = blocks
+        self.state_preperation_functions = state_preperation_functions
+        self.parameter_preperation_functions = parameter_preperation_functions
+
+    def create_experiment(
+        self, state, params, record_trajectory=False, use_deepcopy=True
+    ):
+        return Experiment(
+            self,
+            state,
+            params,
+            self.ms,
+            record_trajectory=record_trajectory,
+            use_deepcopy=use_deepcopy,
+        )
+
+    def create_batch_experiments(
+        self, state, params, record_trajectory=False, use_deepcopy=True
+    ):
+        return BatchExperiments(
+            self,
+            state,
+            params,
+            self.ms,
+            record_trajectory=record_trajectory,
+            use_deepcopy=use_deepcopy,
+        )
+
+    def __repr__(self):
+        return f"Model({self.parameter_space}, {self.state_space}, {self.blocks})"
+
+
+class Experiment:
+    def __init__(self, model, state, params, ms, record_trajectory, use_deepcopy=True):
+        self.model = model
+        self.state = deepcopy(state)
+        self.params = deepcopy(params)
+        self._use_deepcopy = use_deepcopy
+        self.msi = ms.build_implementation(self.params)
+        self.state, self.params = self.msi.prepare_state_and_params(
+            self.state,
+            self.params,
+            state_preperation_functions=self.model.state_preperation_functions,
+            parameter_preperation_functions=self.model.parameter_preperation_functions,
+        )
+
+        if record_trajectory:
+            if self._use_deepcopy:
+                self.trajectories = [deepcopy(self.state)]
+            else:
+                self.trajectories = [copy(self.state)]
+            self.trajectories[-1].pop("Stateful Metrics")
+            self.trajectories[-1].pop("Metrics")
+        else:
+            self.trajectories = None
+        self._record_trajectory = record_trajectory
+        self._iteration_count = 0
+
+    def step(self):
+        self.msi.execute_blocks(self.state, self.params, self.model.blocks)
+        self._iteration_count += 1
+        if self._record_trajectory:
+            if self._use_deepcopy:
+                self.trajectories.append(deepcopy(self.state))
+            else:
+                self.trajectories.append(copy(self.state))
+            self.trajectories[-1].pop("Stateful Metrics")
+            self.trajectories[-1].pop("Metrics")
+
+    def run(self, t):
+        for _ in range(t):
+            self.step()
+
+
+class BatchExperiments:
+    def __init__(self, model, state, params, ms, record_trajectory, use_deepcopy=True):
+        assert type(state) == list, "Input for state must be a list of states"
+        assert type(params) == list, "Input for params must be a list of states"
+        assert len(state) == len(
+            params
+        ), "Length of state and parameters has to be the same"
+
+        self.experiments = [
+            Experiment(
+                model,
+                s,
+                p,
+                ms,
+                record_trajectory=record_trajectory,
+                use_deepcopy=use_deepcopy,
+            )
+            for s, p in zip(state, params)
+        ]
+
+    def step(self):
+        for experiment in self.experiments:
+            experiment.step()
+    
+    def run(self, t):
+        for experiment in self.experiments:
+            experiment.run(t)
+    
+    @property
+    def trajectories(self):
+        return [experiment.trajectories for experiment in self.experiments]
+
+
 class MathSpecImplementation:
     def __init__(self, ms: MathSpec, params, domain_codomain_checking):
         self.ms = deepcopy(ms)
@@ -1006,6 +1205,16 @@ class MathSpecImplementation:
         self.load_components()
         self.load_source_files()
 
+        self.boundary_actions = ValidKeyDict(self.boundary_actions)
+        self.control_actions = ValidKeyDict(self.control_actions)
+        self.mechanisms = ValidKeyDict(self.mechanisms)
+        self.policies = ValidKeyDict(self.policies)
+        self.stateful_metrics = ValidKeyDict(self.stateful_metrics)
+        self.wiring = ValidKeyDict(self.wiring)
+        self.metrics = ValidKeyDict(self.metrics)
+        self.blocks = ValidKeyDict(self.blocks)
+        self.components = ValidKeyDict(self.components)
+
     def load_control_actions(self):
         control_actions = {}
         for ca in self.ms.control_actions:
@@ -1022,6 +1231,12 @@ class MathSpecImplementation:
                     ), "No functional parameterization for {}. To fix this error, add {} to the parameters passed to ms.build_implementation. Option can be: {}".format(
                         ca.name, "FP " + ca.name, [x.name for x in opts]
                     )
+                    assert (
+                        self.params["FP {}".format(ca.name)]
+                        in self.ms.functional_parameters["FP {}".format(ca.name)]
+                    ), "{} is not a valid functional parameterization for {}".format(
+                        self.params["FP {}".format(ca.name)], ca.name
+                    )
                     opt = self.ms.functional_parameters["FP {}".format(ca.name)][
                         self.params["FP {}".format(ca.name)]
                     ]
@@ -1061,6 +1276,13 @@ class MathSpecImplementation:
                         ba.name, "FP " + ba.name, [x.name for x in opts]
                     )
 
+                    assert (
+                        self.params["FP {}".format(ba.name)]
+                        in self.ms.functional_parameters["FP {}".format(ba.name)]
+                    ), "{} is not a valid functional parameterization for {}".format(
+                        self.params["FP {}".format(ba.name)], ba.name
+                    )
+
                     opt = self.ms.functional_parameters["FP {}".format(ba.name)][
                         self.params["FP {}".format(ba.name)]
                     ]
@@ -1165,6 +1387,12 @@ class MathSpecImplementation:
                     ), "No functional parameterization for {}. To fix this error, add {} to the parameters passed to ms.build_implementation. Option can be: {}".format(
                         p.name, "FP " + p.name, [x.name for x in opts]
                     )
+                    assert (
+                        self.params["FP {}".format(p.name)]
+                        in self.ms.functional_parameters["FP {}".format(p.name)]
+                    ), "{} is not a valid functional parameterization for {}".format(
+                        self.params["FP {}".format(p.name)], p.name
+                    )
                     opt = self.ms.functional_parameters["FP {}".format(p.name)][
                         self.params["FP {}".format(p.name)]
                     ]

{math_spec_mapping-0.3.21 → math_spec_mapping-0.4.1}/src/math_spec_mapping/Convenience/github.py

@@ -92,6 +92,15 @@ def create_milestone_label_matrix(df, exclude_milestones=None):
     labels = list(df.columns[4:])
     labels = sorted([x for x in labels if x not in priority_labels])
     milestones = sorted(list(df[~pd.isnull(df["Milestone"])]["Milestone"].unique()))
+    try:
+        milestones = sorted(
+            milestones,
+            key=lambda x: int(x.split(".")[0][1:]) * 10000
+            + int(x.split(".")[1]) * 100
+            + int(x.split(".")[2]),
+        )
+    except:
+        pass
 
     table = []
     for label in labels:

{math_spec_mapping-0.3.21 → math_spec_mapping-0.4.1}/src/math_spec_mapping/Load/type.py

@@ -1,7 +1,7 @@
 from .general import check_json_keys
 from ..Classes import Type
 import os
-from typing import _UnionGenericAlias
+from typing import _UnionGenericAlias, List, _GenericAlias
 
 
 def convert_type(data, ms):
@@ -36,6 +36,8 @@ def convert_type(data, ms):
                 data["type_name"]["python"] = str(out)
             elif type(data["type"]["python"]) == _UnionGenericAlias:
                 data["type_name"]["python"] = data["type"]["python"].__repr__()
+            elif type(data["type"]["python"]) == _GenericAlias:
+                data["type_name"]["python"] = data["type"]["python"].__repr__()
             else:
                 data["type_name"]["python"] = data["type"]["python"].__name__
     if "typescript" in ms["Type Keys"]:

{math_spec_mapping-0.3.21 → math_spec_mapping-0.4.1/src/math_spec_mapping.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: math-spec-mapping
-Version: 0.3.21
+Version: 0.4.1
 Summary: A library for easy mapping of mathematical specifications.
 Author-email: Sean McOwen <Sean@Block.Science>
 Classifier: Programming Language :: Python :: 3
@@ -12,6 +12,10 @@ License-File: LICENSE
 Requires-Dist: graphviz>=0.20.1
 Requires-Dist: ipython>=7.7.0
 Requires-Dist: pandas>=1.4
+Requires-Dist: jsonschema>=4.21.1
+Requires-Dist: PyGithub==2.5.0
+Requires-Dist: dotenv
+Requires-Dist: python-dotenv>=1.0.0
 
 # Mathematical Specification Mapping Library (MSML)
 

math_spec_mapping-0.4.1/src/math_spec_mapping.egg-info/requires.txt

@@ -0,0 +1,7 @@
+graphviz>=0.20.1
+ipython>=7.7.0
+pandas>=1.4
+jsonschema>=4.21.1
+PyGithub==2.5.0
+dotenv
+python-dotenv>=1.0.0

math_spec_mapping-0.3.21/src/math_spec_mapping.egg-info/requires.txt

@@ -1,3 +0,0 @@
-graphviz>=0.20.1
-ipython>=7.7.0
-pandas>=1.4