math-spec-mapping 0.3.21__py3-none-any.whl → 0.4.1__py3-none-any.whl

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/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/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.dist-info → math_spec_mapping-0.4.1.dist-info}/METADATA

@@ -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.dist-info → math_spec_mapping-0.4.1.dist-info}/RECORD

@@ -6,7 +6,7 @@ math_spec_mapping/Classes/Block.py,sha256=2VOBTPRafmtaLY847tEw3OJTrWNp2d0aSStC_u
 math_spec_mapping/Classes/BoundaryAction.py,sha256=_rFvEZ4LNxmlM59js4SuQ9n5CgVmITw4YWKs0-q0r-4,560
 math_spec_mapping/Classes/ControlAction.py,sha256=4AzMSA8fbnUf-fGlvMJXHJFbz32G1h1QVWf2yzrXrLA,493
 math_spec_mapping/Classes/Entity.py,sha256=fA0-b128_OHHxfCg4pzqyQV083EYev1HlVpy86S5igg,1226
-math_spec_mapping/Classes/MathSpec.py,sha256=nQTesARmLrYagoW2T3G6gbidTsFM-NFC9yl3Li01ey8,55970
+math_spec_mapping/Classes/MathSpec.py,sha256=rXiAWuIxtdo4myvCNq7qkBPycCGErMQzVvBRq97HrJc,64548
 math_spec_mapping/Classes/Mechanism.py,sha256=2sLm3wYBIeTQaMBcsJ9btqIWsbS895Ra8NY6Y9_G_Dg,379
 math_spec_mapping/Classes/Metric.py,sha256=iQhH4g8Z60QlM22nPX9ytGmidOsZSiSs0KjqwmsScwU,636
 math_spec_mapping/Classes/Parameter.py,sha256=ZuJ_w0sChvRElJ4sOnXZ2EV4Ell2xXFulKLjVOpgz2E,1237
@@ -19,7 +19,7 @@ math_spec_mapping/Classes/Type.py,sha256=cA5-5nOfjX6aHzTHM8M6mP5lsS7foumckRu7WDX
 math_spec_mapping/Classes/__init__.py,sha256=0zxgOqns_9JybD74HKMVh6aw8ij8WVbfQ4Q_1uWzof0,761
 math_spec_mapping/Convenience/__init__.py,sha256=BEZr1rXohKAknOa3wjNVx3EvSVxDcfftJsvtSw5mvmQ,264
 math_spec_mapping/Convenience/documentation.py,sha256=1ziWVJznbCUxeAAt03nAdEYtMlXNo5TeedHfgs0vSBU,1625
-math_spec_mapping/Convenience/github.py,sha256=Wddr1FCxcIxaFeiKyvx3mvVDbzjcgTxs4rU8ulc4qXk,3539
+math_spec_mapping/Convenience/github.py,sha256=JMFJWyA3nRIMNYGvn9831BolnBthoa48HhgeZuENZm8,3772
 math_spec_mapping/Convenience/starter.py,sha256=dD1R9wcVFZV-BCTflxNkR6Ay6NF1TlVBdIaWmbJwMGE,17379
 math_spec_mapping/Load/__init__.py,sha256=QfHMLatZAKqj4up-LkDL_r42tO7Mo_-qdqPQYLYY5l0,49
 math_spec_mapping/Load/action_transmission_channel.py,sha256=oTYCi7as4LWKZLxfRckuWpfLsAPZXjp-VBYmyLBN3yk,2781
@@ -39,7 +39,7 @@ math_spec_mapping/Load/spec_tree.py,sha256=cRSvb3vHPJIJ7pS6KKH3yJLJXPQXMMPt-ciX9
 math_spec_mapping/Load/state_update_transmission_channels.py,sha256=FJWp5n4HdtHAfof5BUQ6BnRakljatL2h8dWCapaVSc0,2238
 math_spec_mapping/Load/stateful_metrics.py,sha256=eNXIsNmezVN75L3zMXUl8_JORShm_ovJuM7vkiODs7s,2599
 math_spec_mapping/Load/states.py,sha256=3YurI7eTNkN6nrXRFVrc58wH0VfM22XOuWE07HVpR7Y,1365
-math_spec_mapping/Load/type.py,sha256=FbViE3wV1o1JTx7mUYyUpAvgIxDKDQYc6Iw50FrZ4nY,4808
+math_spec_mapping/Load/type.py,sha256=pIo3lYAP6sxukvbFTDvaun1lslgShksZy2froNnwAfA,4973
 math_spec_mapping/Load/wiring.py,sha256=l1FhHNFRMKorn1oiRhsuMDsExcXnUmTjqQt5ElE-Bbk,3258
 math_spec_mapping/Reports/__init__.py,sha256=P3IuE1wiM1EO_yCSD73D4O0O6j7aVWmiwpKJM58ISEs,1121
 math_spec_mapping/Reports/boundary_actions.py,sha256=45BPp4QjWdD-3E9ZWwqgj_nI2-YdcI2ZZ19_Qv_K7Qk,1410
@@ -55,8 +55,8 @@ math_spec_mapping/Reports/spaces.py,sha256=-76hR5wQBv4lsG000ypBJ-OprjsNjI-rNRMYd
 math_spec_mapping/Reports/state.py,sha256=QYeCvX5cHeZBrbvMeDsTqJcUDTuDFJSLvPbasjLspk8,3643
 math_spec_mapping/Reports/tables.py,sha256=O0CNuqh3LMECq5uLjBOoxMUk5hUvkUK660FNnwWUxDY,1505
 math_spec_mapping/Reports/wiring.py,sha256=u9SvKWy6T-WJUEgFI6-zgZanoOaTTs_2YwmEceDLsV8,1618
-math_spec_mapping-0.3.21.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
-math_spec_mapping-0.3.21.dist-info/METADATA,sha256=R7kkn8miJCyVczVY_3EknmGt2utf5-uJtAOH6rl5Npw,6850
-math_spec_mapping-0.3.21.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-math_spec_mapping-0.3.21.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
-math_spec_mapping-0.3.21.dist-info/RECORD,,
+math_spec_mapping-0.4.1.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
+math_spec_mapping-0.4.1.dist-info/METADATA,sha256=UqNOOafGIeJY_gp-mgFXNK2TF6lE_dR8TI-GKGy3i4g,6972
+math_spec_mapping-0.4.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+math_spec_mapping-0.4.1.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
+math_spec_mapping-0.4.1.dist-info/RECORD,,

{math_spec_mapping-0.3.21.dist-info → math_spec_mapping-0.4.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any