math-spec-mapping 0.3.3__tar.gz → 0.3.4__tar.gz

{math_spec_mapping-0.3.3/src/math_spec_mapping.egg-info → math_spec_mapping-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.3.3
+Version: 0.3.4
 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 → math_spec_mapping-0.3.4}/pyproject.toml

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

{math_spec_mapping-0.3.3 → math_spec_mapping-0.3.4}/src/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-0.3.3 → math_spec_mapping-0.3.4}/src/math_spec_mapping/Classes/MathSpec.py

@@ -364,7 +364,7 @@ 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
             ]
@@ -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, 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, 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"]

{math_spec_mapping-0.3.3 → math_spec_mapping-0.3.4}/src/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-0.3.3 → math_spec_mapping-0.3.4}/src/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-0.3.3 → math_spec_mapping-0.3.4}/src/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-0.3.3 → math_spec_mapping-0.3.4}/src/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-0.3.3 → math_spec_mapping-0.3.4}/src/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 → math_spec_mapping-0.3.4/src/math_spec_mapping.egg-info}/PKG-INFO

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