math-spec-mapping 0.1.7__tar.gz → 0.2.1__tar.gz

{math_spec_mapping-0.1.7/src/math_spec_mapping.egg-info → math_spec_mapping-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math_spec_mapping
-Version: 0.1.7
+Version: 0.2.1
 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.1.7 → math_spec_mapping-0.2.1}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "math_spec_mapping"
-version = "0.1.7"
+version = "0.2.1"
 authors = [
   { name="Sean McOwen", email="Sean@Block.Science" },
 ]

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Classes/Block.py

@@ -10,11 +10,15 @@ class Block:
         self.domain = data["domain"]
         self.codomain = data["codomain"]
         self.parameters_used = data["parameters_used"]
+        self.metadata = data["metadata"]
         if "label" in data:
             self.label = data["label"]
         else:
             self.label = self.name
-        self.called_by = []
+        if "called_by" in data:
+            self.called_by = data["called_by"]
+        else:
+            self.called_by = []
         self.calls = []
         self.block_type = "Block"
         # Will be overwritten in composite blocks to represent individual components
@@ -120,6 +124,7 @@ class ParallelBlock(Block):
         self.called_by = []
         self.calls = []
         self.block_type = "Paralell Block"
+        self.metadata = data["metadata"]
 
     def render_mermaid(self, i):
         multi = None
@@ -235,6 +240,7 @@ class StackBlock(Block):
         self.calls = []
 
         self.block_type = "Stack Block"
+        self.metadata = data["metadata"]
 
     def _check_domain_mapping(self):
         x = self.components[:-1]
@@ -412,6 +418,7 @@ class SplitBlock(Block):
         self.calls = []
 
         self.block_type = "Split Block"
+        self.metadata = data["metadata"]
 
     def render_mermaid(self, i):
         multi = None

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Classes/Entity.py

@@ -9,6 +9,7 @@ class Entity:
         self.name = data["name"]
         self.notes = data["notes"]
         self.state = data["state"]
+        self.metadata = data["metadata"]
 
         if "label" in data:
             self.label = data["label"]
@@ -25,7 +26,7 @@ class Entity:
 
     def add_boundary_action(self, boundary_action) -> None:
         self.boundary_actions.append(boundary_action)
-    
+
     def add_impacted_by_mechanism(self, mechanism) -> None:
         self.impacted_by_mechanism.append(mechanism)
         q = [mechanism]
@@ -36,4 +37,3 @@ class Entity:
                     self.impacted_by_actions.append(cur)
             else:
                 q.extend([x[0] for x in cur.called_by])
-        

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Classes/MathSpec.py

@@ -26,6 +26,7 @@ class MathSpec:
         self.stateful_metrics = ms_dict["Stateful Metrics"]
         self.wiring = ms_dict["Wiring"]
         self.blocks = ms_dict["Blocks"]
+        self.types = ms_dict["Types"]
 
         self._check_parameters()
         self._crawl_parameters()
@@ -327,3 +328,17 @@ class MathSpec:
         out["State"] = [x.state for x in out["Entities"]]
         out["State"] = list(set(out["State"]))
         return out
+
+    def get_specific_stateful_metrics(self, metric):
+        for x in self.stateful_metrics.values():
+            for y in x.metrics:
+                if metric == y.name:
+                    return y
+        print("Metric not found")
+        return None
+
+    def get_all_stateful_metric_names(self):
+        sm = []
+        for metrics in self.stateful_metrics.values():
+            sm.extend([x.name for x in metrics.metrics])
+        return sm

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Classes/Parameter.py

@@ -28,6 +28,7 @@ class ParameterSet:
         self.name = data["name"]
         self.notes = data["notes"]
         self.parameters = data["parameters"]
+        self.metadata = data["metadata"]
 
 
 # Individual Parameter
@@ -43,3 +44,4 @@ class Parameter:
         self.parameter_class = data[
             "parameter_class"
         ]  # I.e. behavioral, functional, system
+        self.metadata = data["metadata"]

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Classes/Space.py

@@ -5,10 +5,11 @@ class Space:
     def __init__(self, data: Dict):
         self.name = data["name"]
         self.schema = data["schema"]
+        self.metadata = data["metadata"]
 
     def __repr__(self):
         return self.name
 
 
-TerminatingSpace = Space({"name": "Terminating Space", "schema": {}})
-EmptySpace = Space({"name": "Empty Space", "schema": {}})
+TerminatingSpace = Space({"name": "Terminating Space", "schema": {}, "metadata": {}})
+EmptySpace = Space({"name": "Empty Space", "schema": {}, "metadata": {}})

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Classes/State.py

@@ -14,6 +14,7 @@ class State:
             self.label = self.name
         self._write_variable_map()
         self.updated_by = []
+        self.metadata = data["metadata"]
 
     def _write_variable_map(self) -> None:
         """
@@ -27,8 +28,9 @@ class State:
             key = var.name
 
             # Check variable name not repeated
-            assert var.name not in self.variable_map, "Variable name {} is already present in variables!".format(
-                key)
+            assert (
+                var.name not in self.variable_map
+            ), "Variable name {} is already present in variables!".format(key)
 
             self.variable_map[key] = var
 
@@ -43,10 +45,7 @@ class StateVariable:
         self.domain = data["domain"]
         self.updated_by = []
 
-
-
         # Add check for type of List
         if hasattr(self.type, "_name"):
             if self.type._name == "List":
-                self.type.__name__ = self.type.__repr__().replace("typing.","")
-
+                self.type.__name__ = self.type.__repr__().replace("typing.", "")

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Classes/StatefulMetric.py

@@ -15,6 +15,7 @@ class StatefulMetric:
             self.label = data["label"]
         else:
             self.label = self.name
+        self.metadata = data["metadata"]
 
 
 class StatefulMetricSet:
@@ -23,3 +24,4 @@ class StatefulMetricSet:
         self.name = data["name"]
         self.notes = data["notes"]
         self.metrics = data["metrics"]
+        self.metadata = data["metadata"]

math_spec_mapping-0.2.1/src/Classes/Type.py

@@ -0,0 +1,7 @@
+class Type:
+
+    def __init__(self, data):
+        self.name = data["name"]
+        self.type = data["type"]
+        self.notes = data["notes"]
+        self.metadata = data["metadata"]

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Classes/__init__.py

@@ -11,3 +11,4 @@ from .StatefulMetric import StatefulMetric, StatefulMetricSet
 from .ControlAction import ControlAction, ControlActionOption
 from .Space import Space, TerminatingSpace, EmptySpace
 from .Block import ParallelBlock, Block, StackBlock, SplitBlock
+from .Type import Type

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/boundary_actions.py

@@ -13,6 +13,10 @@ def convert_boundary_action(data: Dict, ms: Dict) -> BoundaryAction:
     Returns:
         BoundaryAction: Boundary action object
     """
+    if "metadata" not in data:
+        data["metadata"] = {}
+
+    data["codomain"] = tuple(data["codomain"])
 
     # Check the keys are correct
     check_json_keys(data, "Boundary Action")
@@ -56,9 +60,8 @@ def load_boundary_actions(ms: Dict, json: Dict) -> None:
     """
 
     ms["Boundary Actions"] = {}
-    for key in json["Boundary Actions"]:
-        ms["Boundary Actions"][key] = convert_boundary_action(
-            json["Boundary Actions"][key], ms
-        )
+    for ba in json["Boundary Actions"]:
+        key = ba["name"]
+        ms["Boundary Actions"][key] = convert_boundary_action(ba, ms)
         for entity in ms["Boundary Actions"][key].called_by:
             entity.add_boundary_action(ms["Boundary Actions"][key])

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/control_actions.py

@@ -14,6 +14,11 @@ def convert_control_action(data: Dict, ms: Dict) -> ControlAction:
         ControlAction: Control action object
     """
 
+    if "metadata" not in data:
+        data["metadata"] = {}
+
+    data["codomain"] = tuple(data["codomain"])
+
     # Check the keys are correct
     check_json_keys(data, "Control Action")
     assert type(data["codomain"]) == tuple, "{} codomain is not a tuple".format(
@@ -48,7 +53,5 @@ def load_control_actions(ms: Dict, json: Dict) -> None:
     """
 
     ms["Control Actions"] = {}
-    for key in json["Control Actions"]:
-        ms["Control Actions"][key] = convert_control_action(
-            json["Control Actions"][key], ms
-        )
+    for ca in json["Control Actions"]:
+        ms["Control Actions"][ca["name"]] = convert_control_action(ca, ms)

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/entities.py

@@ -14,6 +14,8 @@ def convert_entity(data: Dict, ms: Dict) -> Entity:
         Entity: An entity object
     """
 
+    if "metadata" not in data:
+        data["metadata"] = {}
     # Check the keys are correct
     check_json_keys(data, "Entity")
 
@@ -23,8 +25,7 @@ def convert_entity(data: Dict, ms: Dict) -> Entity:
     # Assert that the state is in the math spec and assign it here
     if data["state"]:
         name = data["state"]
-        assert name in ms["State"], "{} state not in states dictionary".format(
-            name)
+        assert name in ms["State"], "{} state not in states dictionary".format(name)
         data["state"] = ms["State"][name]
 
     # Build the state object
@@ -40,5 +41,7 @@ def load_entities(ms: Dict, json: Dict) -> None:
     """
 
     ms["Entities"] = {}
-    for key in json["Entities"]:
-        ms["Entities"][key] = convert_entity(json["Entities"][key], ms)
+
+    for e in json["Entities"]:
+        ms["Entities"][e["name"]] = convert_entity(e, ms)
+    assert "Global" in ms["Entities"], "There must be a global entity"

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/general.py

@@ -1,4 +1,6 @@
 from typing import Dict
+from jsonschema import validate
+from ..schema import schema
 
 
 def check_json_keys(json: Dict, check_set_key: str) -> None:
@@ -28,6 +30,7 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "Control Actions",
             "Wiring",
             "Blocks",
+            "Types",
         ],
         "JSON": [
             "Boundary Actions",
@@ -37,14 +40,14 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "Policies",
             "Spaces",
             "State",
-            "State Update Transmission Channels",
             "Stateful Metrics",
             "Control Actions",
             "Wiring",
+            "Types",
         ],
-        "State": ["name", "label", "notes", "variables"],
+        "State": ["name", "label", "notes", "variables", "metadata"],
         "State Variable": ["type", "name", "description", "symbol", "domain"],
-        "Entity": ["name", "notes", "state"],
+        "Entity": ["name", "notes", "state", "metadata"],
         "Boundary Action": [
             "name",
             "label",
@@ -54,6 +57,7 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "called_by",
             "codomain",
             "parameters_used",
+            "metadata",
         ],
         "Action Transmission Channel": ["origin", "target", "space", "optional"],
         "Mechanism": [
@@ -64,6 +68,8 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "logic",
             "domain",
             "parameters_used",
+            "metadata",
+            "updates",
         ],
         "State Update Transmission Channel": [
             "origin",
@@ -80,9 +86,10 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "domain",
             "codomain",
             "parameters_used",
+            "metadata",
         ],
         "Policy Option": ["name", "description", "logic"],
-        "Stateful Metric Set": ["name", "label", "notes", "metrics"],
+        "Stateful Metric Set": ["name", "label", "notes", "metrics", "metadata"],
         "Stateful Metric": [
             "type",
             "name",
@@ -92,6 +99,7 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "parameters_used",
             "symbol",
             "domain",
+            "metadata",
         ],
         "Control Action": [
             "name",
@@ -101,10 +109,11 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "control_action_options",
             "codomain",
             "parameters_used",
+            "metadata",
         ],
         "Control Action Option": ["name", "description", "logic"],
         "Boundary Action Option": ["name", "description", "logic"],
-        "Parameter Set": ["name", "notes", "parameters"],
+        "Parameter Set": ["name", "notes", "parameters", "metadata"],
         "Parameter": [
             "variable_type",
             "name",
@@ -112,8 +121,9 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "symbol",
             "domain",
             "parameter_class",
+            "metadata",
         ],
-        "Space": ["name", "schema"],
+        "Space": ["name", "schema", "metadata"],
         "Block": [
             "name",
             "components",
@@ -122,7 +132,9 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "mermaid_show_name",
             "loop",
             "optional_indices",
+            "metadata",
         ],
+        "Type": ["name", "notes", "metadata", "type"],
     }
 
     check_set = check_sets[check_set_key]
@@ -139,3 +151,7 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
 
     # Make sure there are no extra keys in the json
     assert len(keys) == 0, "There are extra keys in json: {}".format(", ".join(keys))
+
+
+def validate_json_schema(json):
+    validate(json, schema)

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/load.py

@@ -1,6 +1,6 @@
 from typing import Dict
 from ..Classes import MathSpec
-from .general import check_json_keys
+from .general import check_json_keys, validate_json_schema
 from .states import load_states
 from .entities import load_entities
 from .boundary_actions import load_boundary_actions
@@ -13,6 +13,7 @@ from .policy import load_policies
 from .spaces import load_spaces
 from .stateful_metrics import load_stateful_metrics
 from .wiring import load_wiring
+from .type import load_types
 
 
 def load_from_json(json: Dict) -> MathSpec:
@@ -28,21 +29,25 @@ def load_from_json(json: Dict) -> MathSpec:
     # Assert the keys are correct in the json
     check_json_keys(json, "JSON")
 
+    # Validate against the JSON schema
+    validate_json_schema(json)
+
     ms = {}
 
     # Do loading one by one to transfer the json
+    load_types(ms, json)
     load_spaces(ms, json)
     load_states(ms, json)
     load_entities(ms, json)
     load_boundary_actions(ms, json)
     load_control_actions(ms, json)
-    load_mechanisms(ms, json)
+    state_update_transmission_channels = load_mechanisms(ms, json)
     load_parameters(ms, json)
     load_policies(ms, json)
     load_stateful_metrics(ms, json)
     action_transmission_channels = load_wiring(ms, json)
     load_action_transmission_channels(ms, action_transmission_channels)
-    load_state_update_transmission_channels(ms, json)
+    load_state_update_transmission_channels(ms, state_update_transmission_channels)
 
     # Assert all keys are correct for the ms version
     check_json_keys(ms, "Math Spec")

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/mechanism.py

@@ -13,6 +13,11 @@ def convert_mechanism(data: Dict, ms: Dict) -> Mechanism:
         Mechanism: Mechanism object
     """
 
+    if "metadata" not in data:
+        data["metadata"] = {}
+
+    data["domain"] = tuple(data["domain"])
+
     # Check the keys are correct
     check_json_keys(data, "Mechanism")
     assert type(data["domain"]) == tuple, "{} domain is not a tuple".format(
@@ -24,10 +29,22 @@ def convert_mechanism(data: Dict, ms: Dict) -> Mechanism:
     # Copy
     data = data.copy()
 
+    new_channels = []
+    updates = data.pop("updates")
+    for x in updates:
+        new_channels.append(
+            {
+                "origin": data["name"],
+                "entity": x[0],
+                "variable": x[1],
+                "optional": x[2],
+            }
+        )
+
     data["domain"] = tuple(ms["Spaces"][x] for x in data["domain"])
 
     # Build the action transmission channel object
-    return Mechanism(data)
+    return Mechanism(data), new_channels
 
 
 def load_mechanisms(ms: Dict, json: Dict) -> None:
@@ -39,5 +56,8 @@ def load_mechanisms(ms: Dict, json: Dict) -> None:
     """
 
     ms["Mechanisms"] = {}
-    for key in json["Mechanisms"]:
-        ms["Mechanisms"][key] = convert_mechanism(json["Mechanisms"][key], ms)
+    state_update_transmission_channels = []
+    for m in json["Mechanisms"]:
+        ms["Mechanisms"][m["name"]], new_channels = convert_mechanism(m, ms)
+        state_update_transmission_channels.extend(new_channels)
+    return state_update_transmission_channels

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/parameters.py

@@ -3,7 +3,9 @@ from ..Classes import ParameterContainer, ParameterSet, Parameter
 from .general import check_json_keys
 
 
-def convert_parameter_set(data: Dict) -> ParameterSet:
+def convert_parameter_set(ms, data: Dict) -> ParameterSet:
+    if "metadata" not in data:
+        data["metadata"] = {}
     # Check the keys are correct
     check_json_keys(data, "Parameter Set")
 
@@ -13,7 +15,11 @@ def convert_parameter_set(data: Dict) -> ParameterSet:
     # Convert the parameters
     new_parameters = []
     for param in data["parameters"]:
+        if "metadata" not in param:
+            param["metadata"] = {}
         check_json_keys(param, "Parameter")
+        assert param["variable_type"] in ms["Types"], "Type not in ms"
+        param["variable_type"] = ms["Types"][param["variable_type"]]
         new_parameters.append(Parameter(param))
     data["parameters"] = new_parameters
 
@@ -32,8 +38,8 @@ def load_parameters(ms: Dict, json: Dict) -> None:
     ms["Parameters"] = {}
 
     # Convert parameter sets
-    for key in json["Parameters"]:
-        ms["Parameters"][key] = convert_parameter_set(json["Parameters"][key])
+    for param in json["Parameters"]:
+        ms["Parameters"][param["name"]] = convert_parameter_set(ms, param)
 
     # Placeholder for now
     ms["Parameters"] = ParameterContainer(ms["Parameters"])

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/policy.py

@@ -35,8 +35,14 @@ def convert_policy(data: Dict, ms: Dict) -> Policy:
         Policy: Policy object
     """
 
+    if "metadata" not in data:
+        data["metadata"] = {}
     # Check the keys are correct
     check_json_keys(data, "Policy")
+
+    data["codomain"] = tuple(data["codomain"])
+    data["domain"] = tuple(data["domain"])
+
     assert type(data["codomain"]) == tuple, "{} codomain is not a tuple".format(
         data["name"]
     )
@@ -75,5 +81,5 @@ def load_policies(ms: Dict, json: Dict) -> None:
     """
 
     ms["Policies"] = {}
-    for key in json["Policies"]:
-        ms["Policies"][key] = convert_policy(json["Policies"][key], ms)
+    for policy in json["Policies"]:
+        ms["Policies"][policy["name"]] = convert_policy(policy, ms)

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/spaces.py

@@ -3,13 +3,21 @@ from ..Classes import Space, TerminatingSpace, EmptySpace
 from .general import check_json_keys
 
 
-def convert_space(data: Dict) -> Space:
+def convert_space(ms, data: Dict) -> Space:
+    if "metadata" not in data:
+        data["metadata"] = {}
     # Check the keys are correct
     check_json_keys(data, "Space")
 
     # Copy
     data = data.copy()
 
+    for x in data["schema"]:
+        assert data["schema"][x] in ms["Types"], "Type {} not in ms".format(
+            data["schema"][x]
+        )
+        data["schema"][x] = ms["Types"][data["schema"][x]]
+
     # Build the space object
     return Space(data)
 
@@ -29,4 +37,4 @@ def load_spaces(ms: Dict, json: Dict) -> None:
 
     for space in json["Spaces"]:
         assert space["name"] not in ms["Spaces"], "{} repeated"
-        ms["Spaces"][space["name"]] = convert_space(space)
+        ms["Spaces"][space["name"]] = convert_space(ms, space)

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/state_update_transmission_channels.py

@@ -51,7 +51,9 @@ def convert_state_update_transmission_channel(
     return StateUpdateTransmissionChannel(data)
 
 
-def load_state_update_transmission_channels(ms: Dict, json: Dict) -> None:
+def load_state_update_transmission_channels(
+    ms: Dict, state_update_transmission_channels
+) -> None:
     """Function to load state update transmission channels into the new dictionary
 
     Args:
@@ -60,7 +62,7 @@ def load_state_update_transmission_channels(ms: Dict, json: Dict) -> None:
     """
 
     ms["State Update Transmission Channels"] = []
-    for sutc in json["State Update Transmission Channels"]:
+    for sutc in state_update_transmission_channels:
         ms["State Update Transmission Channels"].append(
             convert_state_update_transmission_channel(sutc, ms)
         )

{math_spec_mapping-0.1.7 → math_spec_mapping-0.2.1}/src/Load/stateful_metrics.py

@@ -3,7 +3,7 @@ from ..Classes import StatefulMetric, StatefulMetricSet
 from .general import check_json_keys
 
 
-def convert_stateful_metric(data: Dict) -> StatefulMetricSet:
+def convert_stateful_metric(ms, data: Dict) -> StatefulMetricSet:
     """Function to convert stateful metric
 
     Args:
@@ -12,6 +12,8 @@ def convert_stateful_metric(data: Dict) -> StatefulMetricSet:
     Returns:
         StatefulMetricSet: A stateful metric set
     """
+    if "metadata" not in data:
+        data["metadata"] = {}
 
     # Check the keys are correct
     check_json_keys(data, "Stateful Metric Set")
@@ -22,7 +24,21 @@ def convert_stateful_metric(data: Dict) -> StatefulMetricSet:
     # Convert the variables
     new_variables = []
     for var in data["metrics"]:
+        if "metadata" not in var:
+            var["metadata"] = {}
         check_json_keys(var, "Stateful Metric")
+        for x in var["variables_used"]:
+            assert type(x) == tuple, "Variables used is not tuple"
+            assert len(x) == 2, "Length of variables used is not 2"
+            assert (
+                x[0] in ms["State"]
+            ), "State '{}' from variables used not in states".format(x[0])
+            vm = ms["State"][x[0]].variable_map
+            assert (
+                x[1] in vm
+            ), "Variable '{}' not in variable map for stateful metrics variables used".format(
+                x[1]
+            )
         new_variables.append(StatefulMetric(var))
     data["metrics"] = new_variables
 
@@ -39,6 +55,5 @@ def load_stateful_metrics(ms: Dict, json: Dict) -> None:
     """
 
     ms["Stateful Metrics"] = {}
-    for key in json["Stateful Metrics"]:
-        ms["Stateful Metrics"][key] = convert_stateful_metric(
-            json["Stateful Metrics"][key])
+    for sm in json["Stateful Metrics"]:
+        ms["Stateful Metrics"][sm["name"]] = convert_stateful_metric(ms, sm)