math-spec-mapping 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

math_spec_mapping/Classes/BoundaryAction.py

@@ -8,6 +8,7 @@ class BoundaryAction(Block):
         super().__init__(data)
         self.boundary_action_options = data["boundary_action_options"]
         self.block_type = "Boundary Action"
+        self.model_name = self.name.replace(" ", "_").lower()
 
 
 class BoundaryActionOption:
@@ -15,3 +16,4 @@ class BoundaryActionOption:
         self.name = data["name"]
         self.description = data["description"]
         self.logic = data["logic"]
+        self.implementations = data["implementations"]

math_spec_mapping/Classes/MathSpec.py

@@ -364,14 +364,14 @@ class MathSpec:
         ]
         opts.extend(
             [
-                (x, x.boundary_actions)
+                (x, x.boundary_action_options)
                 for x in self.boundary_actions.values()
                 if len(x.boundary_action_options) > 1
             ]
         )
         opts.extend(
             [
-                (x, x.control_actions)
+                (x, x.control_action_options)
                 for x in self.control_actions.values()
                 if len(x.control_action_options) > 1
             ]
@@ -604,6 +604,34 @@ class MathSpec:
         with open(path, "w") as f:
             f.write(out)
 
+    def metaprogramming_boundary_actions(
+        self, model_directory, overwrite=False, default_values=None
+    ):
+        path = model_directory + "/boundary_actions.py"
+        if not overwrite:
+            assert "boundary_actions.py" not in os.listdir(
+                model_directory
+            ), "The boundary actions file is already written, either delete it or switch to overwrite mode"
+        out = ""
+
+        unique_spaces = set().union(
+            *[x.all_spaces_used for x in self.boundary_actions.values()]
+        )
+        unique_spaces = [x.name_variable for x in unique_spaces]
+
+        out += "from .spaces import {}".format(", ".join(unique_spaces))
+        out += "\n\n"
+        for x in self.boundary_actions.values():
+            out += "def "
+            out += x.model_name
+            out += "(state, params) -> ({}):".format(
+                ", ".join([y.name_variable for y in x.codomain])
+            )
+            out += "\n\n"
+
+        with open(path, "w") as f:
+            f.write(out)
+
     def metaprogramming_julia_types(self, model_directory, overwrite=False):
         path = model_directory + "/types.jl"
         if not overwrite:
@@ -652,7 +680,7 @@ class MathSpecImplementation:
         self.ms = deepcopy(ms)
         self.params = params
         self.control_actions = self.load_control_actions()
-        self.boundary_actions = {}
+        self.boundary_actions = self.load_boundary_actions()
         self.policies = self.load_policies()
         self.mechanisms = self.load_mechanisms()
         self.load_wiring()
@@ -670,24 +698,64 @@ class MathSpecImplementation:
                 else:
                     assert (
                         "FP {}".format(ca.name) in self.params
-                    ), "No functional parameterization for {}".format(ca.name)
+                    ), "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]
+                    )
                     opt = self.ms.functional_parameters["FP {}".format(ca.name)][
                         self.params["FP {}".format(ca.name)]
                     ]
 
-                assert (
-                    "python" in opt.implementations
-                ), "No python implementation for {} / {}".format(ca.name, opt.name)
-
-                control_actions[ca.name] = opt.implementations["python"]
+                if "python" not in opt.implementations:
+                    print(
+                        "No python implementation for {} / {}. To fix this, go to Implementations/Python/ControlActions and add {}".format(
+                            ca.name, opt.name, opt.name
+                        )
+                    )
+                else:
+                    control_actions[ca.name] = opt.implementations["python"]
         return control_actions
 
+    def load_boundary_actions(self):
+        boundary_actions = {}
+        for ba in self.ms.boundary_actions:
+            ba = self.ms.boundary_actions[ba]
+            opts = ba.boundary_action_options
+            if len(opts) == 0:
+                print("{} has no boundary action options".format(ba.name))
+            else:
+                if len(opts) == 1:
+                    opt = opts[0]
+                else:
+                    assert (
+                        "FP {}".format(ba.name) in self.params
+                    ), "No functional parameterization for {}. To fix this error, add {} to the parameters passed to ms.build_implementation. Option can be: {}".format(
+                        ba.name, "FP " + ba.name, [x.name for x in opts]
+                    )
+
+                    opt = self.ms.functional_parameters["FP {}".format(ba.name)][
+                        self.params["FP {}".format(ba.name)]
+                    ]
+
+                if "python" not in opt.implementations:
+                    print(
+                        "No python implementation for {} / {}. To fix this, go to Implementations/Python/BoundaryActions and add {}".format(
+                            ba.name, opt.name, opt.name
+                        )
+                    )
+                else:
+                    boundary_actions[ba.name] = opt.implementations["python"]
+        return boundary_actions
+
     def load_mechanisms(self):
         mechanisms = {}
         for m in self.ms.mechanisms:
             m = self.ms.mechanisms[m]
             if "python" not in m.implementations:
-                print("No python implementation for {}".format(m.name))
+                print(
+                    "No python implementation for {}. To fix this, go to Implementations/Python/Mechanisms and add {}".format(
+                        m.name, m.name
+                    )
+                )
             else:
                 mechanisms[m.name] = m.implementations["python"]
         return mechanisms
@@ -737,14 +805,18 @@ class MathSpecImplementation:
                 else:
                     assert (
                         "FP {}".format(p.name) in self.params
-                    ), "No functional parameterization for {}".format(p.name)
+                    ), "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]
+                    )
                     opt = self.ms.functional_parameters["FP {}".format(p.name)][
                         self.params["FP {}".format(p.name)]
                     ]
 
                 if "python" not in opt.implementations:
                     print(
-                        "No python implementation for {} / {}".format(p.name, opt.name)
+                        "No python implementation for {} / {}. To fix this, go to Implementations/Python/Policies and add {}".format(
+                            p.name, opt.name, opt.name
+                        )
                     )
                 else:
                     policies[p.name] = opt.implementations["python"]
@@ -785,3 +857,31 @@ class MathSpecImplementation:
         if len(wiring) > 0:
             wiring = [x.name for x in wiring]
             print("The following wirings were not loading: {}".format(wiring))
+
+    def validate_state_and_params(self, state, parameters):
+
+        k1 = state.keys()
+        k2 = [x.name for x in self.ms.state["Global State"].variables]
+
+        not_in_state = [x for x in k2 if x not in k1]
+        shouldnt_be_in_state = [x for x in k1 if x not in k2]
+        assert (
+            len(not_in_state) == 0
+        ), "The following state variables are missing: {}".format(not_in_state)
+        assert (
+            len(shouldnt_be_in_state) == 0
+        ), "The following state variables are extra: {}".format(shouldnt_be_in_state)
+
+        k1 = parameters.keys()
+        k2 = self.ms.parameters.all_parameters + list(
+            self.ms.functional_parameters.keys()
+        )
+
+        not_in_params = [x for x in k2 if x not in k1]
+        shouldnt_be_in_params = [x for x in k1 if x not in k2]
+        assert (
+            len(not_in_params) == 0
+        ), "The following parameters are missing: {}".format(not_in_params)
+        assert (
+            len(shouldnt_be_in_params) == 0
+        ), "The following parameters are extra: {}".format(shouldnt_be_in_params)

math_spec_mapping/Load/boundary_actions.py

@@ -34,6 +34,17 @@ def convert_boundary_action(data: Dict, ms: Dict) -> BoundaryAction:
     new_bao = []
     for ba in data["boundary_action_options"]:
         check_json_keys(ba, "Boundary Action Option")
+
+        ba["implementations"] = {}
+        if "python" in ms["Implementations"]:
+            if "boundary_action_options" in ms["Implementations"]["python"]:
+                if (
+                    ba["name"]
+                    in ms["Implementations"]["python"]["boundary_action_options"]
+                ):
+                    ba["implementations"]["python"] = ms["Implementations"]["python"][
+                        "boundary_action_options"
+                    ][ba["name"]]
         new_bao.append(BoundaryActionOption(ba))
     data["boundary_action_options"] = new_bao
 

math_spec_mapping/Load/displays.py

@@ -7,7 +7,9 @@ def load_wiring(ms, json):
     ms["Displays"]["Wiring"] = []
     for display in json["Displays"]["wiring"]:
         for component in display["components"]:
-            assert component in ms["Blocks"], "{} is not a valid block".format(
-                component
+            assert (
+                component in ms["Blocks"]
+            ), "{} referenced in {} is not a valid block".format(
+                component, display["name"]
             )
         ms["Displays"]["Wiring"].append(display)

math_spec_mapping/Load/states.py

@@ -25,7 +25,9 @@ def convert_state(ms, data: Dict) -> State:
     new_variables = []
     for var in data["variables"]:
         check_json_keys(var, "State Variable")
-        assert var["type"] in ms["Types"], "Type {} not in ms".format(var["name"])
+        assert var["type"] in ms["Types"], "Type {} referenced by {} not in ms".format(
+            var["type"], var["name"]
+        )
         var["type"] = ms["Types"][var["type"]]
         if "metadata" not in var:
             var["metadata"] = {}

math_spec_mapping/Reports/html.py

@@ -164,7 +164,10 @@ cssclasses:
         else:
             out += symbol2 + name + "\n"
         for var in ms.stateful_metrics[name].metrics:
-            out += symbol3 + "[[{}]]".format(var.name) + "\n"
+            if linking:
+                out += symbol3 + "[[{}]]".format(var.name) + "\n"
+            else:
+                out += symbol3 + "{}".format(var.name) + "\n"
 
     out += symbol1 + "**Types**\n"
     for name in ms.types.keys():
@@ -186,7 +189,10 @@ cssclasses:
         else:
             out += symbol2 + name + "\n"
         for param in [x.name for x in ms.parameters.data[name].parameters]:
-            out += symbol3 + "[[{}]]".format(param) + "\n"
+            if linking:
+                out += symbol3 + "[[{}]]".format(param) + "\n"
+            else:
+                out += symbol3 + "{}".format(param) + "\n"
 
     out += symbol1 + "**Boundary Actions**\n"
     for name in ms.boundary_actions.keys():

math_spec_mapping/Reports/markdown.py

@@ -577,7 +577,7 @@ def write_metrics_markdown_report(ms, path, metric, add_metadata=True):
     out += "\n\n"
 
     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)
         var = ms.parameters.parameter_map[x]
         if var.symbol:
@@ -711,7 +711,7 @@ def write_wiring_display_markdown_report(ms, path, wiring, add_metadata=True):
     parameters = set().union(*parameters)
     parameters = sorted(parameters, key=lambda x: x)
     out += "## Unique Parameters Used\n"
-    for i, x in enumerate(sorted(parameters, key=lambda x: x.name)):
+    for i, x in enumerate(sorted(parameters, key=lambda x: x)):
         out += "{}. [[{}]]".format(i + 1, x)
         out += "\n"
     out += "\n"

math_spec_mapping/schema.schema.json

@@ -130,7 +130,7 @@
                 },
                 "control_action_options": {
                     "type": "array",
-                    "items": {},
+                    "items": {"$ref": "./schema.schema.json/#/definitions/ControlActionOption"},
                     "description": "Possible implementations of the control action"
                 },
                 "codomain": {
@@ -157,6 +157,38 @@
             "title": "ControlAction",
             "description": "The definition of actions that the system might call, such as an action to refill the stock of an item when reserves run too low or something that could get triggered from a sensor. The key differentiator from boundary actions is that there is no entity calling it and it is not done with randomness."
         },
+        "BoundaryActionOption": {"type": "object",
+        "additionalProperties": false,
+    "properties": {"name": {"type": "string",
+    "description": "The name of the boundary action option"},
+    "description": {"type": "string",
+    "description": "A description of what this implementation does"},
+    "logic": {"type": "string",
+    "description": "The logic related to the implementation"},
+        "metadata": {"type": "object"}},
+    "title": "BoundaryActionOption",
+    "required": [
+        "name",
+        "description",
+        "logic"
+    ],
+"description": "Specific implementations of a control action which are in the same form of the underlying control action definition."},
+        "ControlActionOption": {"type": "object",
+        "additionalProperties": false,
+    "properties": {"name": {"type": "string",
+    "description": "The name of the control action option"},
+    "description": {"type": "string",
+    "description": "A description of what this implementation does"},
+    "logic": {"type": "string",
+    "description": "The logic related to the implementation"},
+        "metadata": {"type": "object"}},
+    "title": "ControlActionOption",
+    "required": [
+        "name",
+        "description",
+        "logic"
+    ],
+"description": "Specific implementations of a control action which are in the same form of the underlying control action definition."},
         "Entity": {
             "type": "object",
             "additionalProperties": false,
@@ -469,7 +501,7 @@
                 },
                 "boundary_action_options": {
                     "type": "array",
-                    "items": {},
+                    "items": {"$ref": "./schema.schema.json/#/definitions/BoundaryActionOption"},
                     "description": "The options for implementation of the boundary action"
                 },
                 "called_by": {

{math_spec_mapping-0.3.3.dist-info → math_spec_mapping-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.3.3
+Version: 0.3.5
 Summary: A library for easy mapping of mathematical specifications.
 Author-email: Sean McOwen <Sean@Block.Science>
 Classifier: Programming Language :: Python :: 3

{math_spec_mapping-0.3.3.dist-info → math_spec_mapping-0.3.5.dist-info}/RECORD

@@ -1,12 +1,12 @@
 math_spec_mapping/__init__.py,sha256=CzT9KycdX5nuiUzDFmLXVeAIr8v8UKGbXsEQF8vjl1c,961
 math_spec_mapping/schema.py,sha256=6mrRqzEnTTSXjb19xJ63MBp0KjKH0s7i6TfT4MkAY9k,233
-math_spec_mapping/schema.schema.json,sha256=5_DiubQzPo8koyx5PKFh_zIINyjtrhGWG_7N73s9b1Q,29400
+math_spec_mapping/schema.schema.json,sha256=hJP2TcV5WPFPmx4u_A5U1xtnpkE1LeYaTeYOXadTot0,30916
 math_spec_mapping/Classes/ActionTransmissionChannel.py,sha256=zWMo5QsgPh5WGIWXl-xOrZNMXYJXmK6Vejw1dQvi0og,246
 math_spec_mapping/Classes/Block.py,sha256=OsWM1ZAi6ZvavDhMFJi_H7w8ZF9LqJIKR3ZLTXnts9w,17437
-math_spec_mapping/Classes/BoundaryAction.py,sha256=AOENCqCEfpjotnHhzUj_F2SOP0SGpkN1tNPr8Mtl6Tc,476
+math_spec_mapping/Classes/BoundaryAction.py,sha256=KuZqtvZwSHWDP7gFQXGnG-r3EuYJU_oU9wMCuqvRkzk,593
 math_spec_mapping/Classes/ControlAction.py,sha256=ysqpgANwdizVdwqtgZmnxXMpCqrzmVEF_6YT0M3l4Ho,526
 math_spec_mapping/Classes/Entity.py,sha256=fA0-b128_OHHxfCg4pzqyQV083EYev1HlVpy86S5igg,1226
-math_spec_mapping/Classes/MathSpec.py,sha256=KEk7oUs21YznNmsdCUtldpOl7p-rwFmpZcolVNHlaTo,28854
+math_spec_mapping/Classes/MathSpec.py,sha256=f0S-52Gh-LjZtOldXZTXPTTwqCWAz-ULsckzmNGxcSg,33257
 math_spec_mapping/Classes/Mechanism.py,sha256=2sLm3wYBIeTQaMBcsJ9btqIWsbS895Ra8NY6Y9_G_Dg,379
 math_spec_mapping/Classes/Metric.py,sha256=AhPgYppOP6q49xvR8S9STxQsXUKJlTWx7wI1LfZEtww,581
 math_spec_mapping/Classes/Parameter.py,sha256=ZuJ_w0sChvRElJ4sOnXZ2EV4Ell2xXFulKLjVOpgz2E,1237
@@ -22,9 +22,9 @@ math_spec_mapping/Convenience/documentation.py,sha256=1ziWVJznbCUxeAAt03nAdEYtMl
 math_spec_mapping/Convenience/starter.py,sha256=Pv0b5pHnv5Bxk3PkY8O9Nv62z2C_gxj5xcf8G9r4Pkw,11010
 math_spec_mapping/Load/__init__.py,sha256=_ga5nHi7U5rY5lCF36_XI9Qmybq4P8R4m5I5mmjLBk8,33
 math_spec_mapping/Load/action_transmission_channel.py,sha256=9Wer7g2s5SSOcUYuZ0PqSKUVVnW3EvGQJZNXJTwW__0,2561
-math_spec_mapping/Load/boundary_actions.py,sha256=mKX4hUHlX4xoJzm-6W3W3AjWRC9RNiEWb0al7lN0DBs,2142
+math_spec_mapping/Load/boundary_actions.py,sha256=q-jxhu8FaKNjdOdexlK6f22GDgraGa1jnL5kEzQ7mJY,2625
 math_spec_mapping/Load/control_actions.py,sha256=4E57s730W4tX5SaKXKaAvet37r8Bwt-g8Kk6EanF4TU,2042
-math_spec_mapping/Load/displays.py,sha256=ooHWT_OryzEkp7F3LcGywwdLMRJLxuyPK82zJ3gcyN0,414
+math_spec_mapping/Load/displays.py,sha256=uQvs0Jhp8-9SXGex8SG3ibxHJu7ahAV3xLeBFbT8QEE,480
 math_spec_mapping/Load/entities.py,sha256=Ds7VQY_govWEn1vSHYVrLa8IadSNyOQzaCK18JPYPKk,1289
 math_spec_mapping/Load/general.py,sha256=2q6aGKxXhebiHHTZhtACvM4nWIkTben0o5rXuvfv2Vw,4463
 math_spec_mapping/Load/implementations.py,sha256=SGKZ_YXeNpJUTnw5fajQTXji7S2bNQo8sh-7YcIO6pk,395
@@ -36,15 +36,15 @@ math_spec_mapping/Load/policy.py,sha256=HvlhGHGJTweVs7DOI2HSL_2_diECr8ukDUmzoFLQ
 math_spec_mapping/Load/spaces.py,sha256=7zgGA57Te7T4hfuCCDElffiidWgn1lKm5E14e1yjt8M,1116
 math_spec_mapping/Load/state_update_transmission_channels.py,sha256=FJWp5n4HdtHAfof5BUQ6BnRakljatL2h8dWCapaVSc0,2238
 math_spec_mapping/Load/stateful_metrics.py,sha256=uGSTc6x6lld5xptgSUMHrO0Vg0QDRIL14C6zTg33S8o,1977
-math_spec_mapping/Load/states.py,sha256=WTLvonzrUQWDVnkF9OPzHeyImrxoMPmonEl5O9O6Pxg,1313
+math_spec_mapping/Load/states.py,sha256=3YurI7eTNkN6nrXRFVrc58wH0VfM22XOuWE07HVpR7Y,1365
 math_spec_mapping/Load/type.py,sha256=z6cBdBNjWed7cRyA0Bj7Jd5PmtemVVh07n3mWFj_5U4,4356
 math_spec_mapping/Load/wiring.py,sha256=1dR94U5N1W_WI5rL6lYBltH25ZvApB2pIpq9r5Opkug,3083
 math_spec_mapping/Reports/__init__.py,sha256=W27I6S9Ro1hWeHmnxIokCA06awB__eYey7PvKD4Hc1s,933
 math_spec_mapping/Reports/boundary_actions.py,sha256=45BPp4QjWdD-3E9ZWwqgj_nI2-YdcI2ZZ19_Qv_K7Qk,1410
 math_spec_mapping/Reports/control_actions.py,sha256=NksekZKIPFSIkubttFstKFthc5AU9B9PWRLSl9j1wWs,1216
 math_spec_mapping/Reports/general.py,sha256=WOOn6Wlb8M4fsdN49FlKLwOka6vJPQ9aCUy88TL2ki0,1610
-math_spec_mapping/Reports/html.py,sha256=tqydmwFWz_1Bg_J_avG4t9LtE-DUGbOKAPNuwg6lgRI,9007
-math_spec_mapping/Reports/markdown.py,sha256=K1amcJrAs4dNv9mN8NeC8U97RtWGJrRmJfEkZlAn_jA,22881
+math_spec_mapping/Reports/html.py,sha256=uUXxMgGoL2yQelSg7CmJjIsU84SbZarqPg2d9x7Z13k,9220
+math_spec_mapping/Reports/markdown.py,sha256=t6C2D6pk3Y9K9vOR0IC6rLe18tBm3JFgJ3rC9tnvt_Q,22871
 math_spec_mapping/Reports/mechanisms.py,sha256=d2Rxt3JBYvqAOAYUynl0buYVoXEHrO8EGq7GK6hK8NA,1322
 math_spec_mapping/Reports/node_map.py,sha256=FdSMDQG16NX6n9sZcH-T5xwsvgjrV9OqBHc9J_VlNK0,3129
 math_spec_mapping/Reports/parameters.py,sha256=yizNG4lNGrgrlzYYcHMGfXKDFlPw4PMDYshDqZ3YARs,535
@@ -53,8 +53,8 @@ math_spec_mapping/Reports/spaces.py,sha256=-76hR5wQBv4lsG000ypBJ-OprjsNjI-rNRMYd
 math_spec_mapping/Reports/state.py,sha256=RkqfSonar74KVC8PpA9GgI2xaHX6BrkNdAuWMZlYQfI,2321
 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.3.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
-math_spec_mapping-0.3.3.dist-info/METADATA,sha256=M8t5087vsXIk7Xw-SROeZa8xWRuuMs2lkaqswl0_srU,6012
-math_spec_mapping-0.3.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-math_spec_mapping-0.3.3.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
-math_spec_mapping-0.3.3.dist-info/RECORD,,
+math_spec_mapping-0.3.5.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
+math_spec_mapping-0.3.5.dist-info/METADATA,sha256=5V-r7KxzjQ0TpSTcMx9o0kmdi6L9xwqtZ2VQGDE081w,6012
+math_spec_mapping-0.3.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+math_spec_mapping-0.3.5.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
+math_spec_mapping-0.3.5.dist-info/RECORD,,