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

{math_spec_mapping-0.1.5/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.5
+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
@@ -42,7 +42,31 @@ A[JSON Object \n\n Each spec has a repo for tracking changes \n Must conform to
 
 ```
 
-
-
-
-
+## Canonical Examples
+
+[Dummy/Starter Repository](https://github.com/BlockScience/MSML/tree/main/examples/StarterRepo)
+[Root Finding Simulation](https://github.com/SeanMcOwen/Root-Finding-Simulation)
+
+### Comparison of Canonical Example Features
+
+| Feature | Dummy | Root Finding |
+| --- | --- | --- |
+| Action Transmission Channels | X | X |
+| Stack Block | X | X |
+| Parallel Block |  | X |
+| Split Block |  |  |
+| Boundary Actions | X |  |
+| Control Actions | X | X |
+| Entities | X |  |
+| Mechanisms | X | X |
+| Parameters | X | X |
+| Policies | X | X |
+| Spaces | X | X |
+| State | X | X |
+| Stateful Metrics |  |  |
+| State Update Transmission Channels | X | X |
+| Reports | X | X |
+
+##  Other Related Repositories
+
+[GDS-MSML-cadCAD Repository](https://github.com/BlockScience/GDS-MSML-cadCAD)

{math_spec_mapping-0.1.5 → math_spec_mapping-0.2.1}/README.md

@@ -27,7 +27,31 @@ A[JSON Object \n\n Each spec has a repo for tracking changes \n Must conform to
 
 ```
 
-
-
-
-
+## Canonical Examples
+
+[Dummy/Starter Repository](https://github.com/BlockScience/MSML/tree/main/examples/StarterRepo)
+[Root Finding Simulation](https://github.com/SeanMcOwen/Root-Finding-Simulation)
+
+### Comparison of Canonical Example Features
+
+| Feature | Dummy | Root Finding |
+| --- | --- | --- |
+| Action Transmission Channels | X | X |
+| Stack Block | X | X |
+| Parallel Block |  | X |
+| Split Block |  |  |
+| Boundary Actions | X |  |
+| Control Actions | X | X |
+| Entities | X |  |
+| Mechanisms | X | X |
+| Parameters | X | X |
+| Policies | X | X |
+| Spaces | X | X |
+| State | X | X |
+| Stateful Metrics |  |  |
+| State Update Transmission Channels | X | X |
+| Reports | X | X |
+
+##  Other Related Repositories
+
+[GDS-MSML-cadCAD Repository](https://github.com/BlockScience/GDS-MSML-cadCAD)

{math_spec_mapping-0.1.5 → 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.5"
+version = "0.2.1"
 authors = [
   { name="Sean McOwen", email="Sean@Block.Science" },
 ]

{math_spec_mapping-0.1.5 → 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
@@ -74,6 +78,7 @@ class ParallelBlock(Block):
         self.components = data["components"]
         self.description = data["description"]
         self.constraints = data["constraints"]
+        self.mermaid_show_name = data["mermaid_show_name"]
         self.domain = tuple(
             [
                 i
@@ -119,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
@@ -131,21 +137,75 @@ class ParallelBlock(Block):
         nodes = []
 
         # Render components
+        domain_map = {}
+        codomain_map = {}
         for component in self.components:
+            domain = component.domain
+            codomain = component.codomain
+            domain = [
+                x.name
+                for x in domain
+                if x.name not in ["Empty Space", "Terminating Space"]
+            ]
+            codomain = [
+                x.name
+                for x in codomain
+                if x.name not in ["Empty Space", "Terminating Space"]
+            ]
+
             component, i = component.render_mermaid(i)
             out += component
             out += "\n"
+            domain_map[i] = domain
+            codomain_map[i] = codomain
             nodes.append(i)
-        end_i = i
+
+        # Add domain and codomain
+        i += 1
+        out += "X{}[Domain]".format(i)
+        out += "\n"
+        domain_i = i
+        i += 1
+        out += "X{}[Codomain]".format(i)
+        out += "\n"
+        codomain_i = i
+
+        out += "direction LR\n"
 
         # Render invisible connections
-        for ix1, ix2 in zip(nodes[:-1], nodes[1:]):
-            out += "X{} ~~~ X{}".format(ix1, ix2)
+        # for ix1, ix2 in zip(nodes[:-1], nodes[1:]):
+        #    out += "X{} ~~~~ X{}".format(ix1, ix2)
+        #    out += "\n"
+
+        out += "direction TB\n"
+
+        for ix1 in nodes:
+            d = domain_map[ix1]
+            if len(d) > 0:
+                d = "\n".join(d)
+                d = '"{}"'.format(d)
+                out += "X{} --{}--> X{}".format(domain_i, d, ix1)
+            else:
+                out += "X{} --> X{}".format(domain_i, ix1)
+            out += "\n"
+
+        for ix1 in nodes:
+            d = codomain_map[ix1]
+            if len(d) > 0:
+                d = "\n".join(d)
+                d = '"{}"'.format(d)
+                out += "X{} --{}--> X{}".format(ix1, d, codomain_i)
+            else:
+                out += "X{} --> X{}".format(ix1, codomain_i)
             out += "\n"
 
         # Subgraph it
+        if self.mermaid_show_name:
+            name = self.name
+        else:
+            name = " "
         i += 1
-        out = "subgraph X{}[{}]\ndirection LR\n".format(i, self.name) + out
+        out = "subgraph X{}[{}]\ndirection TB\n".format(i, name) + out
 
         out += "end"
 
@@ -158,6 +218,9 @@ class StackBlock(Block):
         self.components = data["components"]
         self.description = data["description"]
         self.constraints = data["constraints"]
+        self.mermaid_show_name = data["mermaid_show_name"]
+        self.optional_indices = data["optional_indices"]
+        self.loop = data["loop"]
         self._check_domain_mapping()
         self.domain = self.components[0].domain
         self.codomain = self.components[-1].codomain
@@ -177,9 +240,15 @@ class StackBlock(Block):
         self.calls = []
 
         self.block_type = "Stack Block"
+        self.metadata = data["metadata"]
 
     def _check_domain_mapping(self):
-        for a, b in zip(self.components[:-1], self.components[1:]):
+        x = self.components[:-1]
+        y = self.components[1:]
+        if self.loop:
+            x.append(self.components[-1])
+            y.append(self.components[0])
+        for a, b in zip(x, y):
             assert [
                 x for x in a.codomain if x not in [EmptySpace, TerminatingSpace]
             ] == [
@@ -190,10 +259,17 @@ class StackBlock(Block):
 
     def build_action_transmission_channels(self):
         channels = []
-        for a, b in zip(self.components[:-1], self.components[1:]):
+        x = self.components[:-1]
+        y = self.components[1:]
+        if self.loop:
+            x.append(self.components[-1])
+            y.append(self.components[0])
+        for a, b, c in zip(x, y, range(len(x))):
             assert len(a.codomain_blocks) == len(b.domain_blocks) and len(
                 b.domain_blocks
             ) == len([x for x in b.domain if x not in [EmptySpace, TerminatingSpace]])
+            global_optional = c in self.optional_indices
+
             for x, y, z in zip(
                 a.codomain_blocks,
                 b.domain_blocks,
@@ -204,7 +280,7 @@ class StackBlock(Block):
                         "origin": x.name,
                         "target": y.name,
                         "space": z.name,
-                        "optional": False,
+                        "optional": global_optional,
                     }
                 )
             for x in a.codomain_blocks_empty:
@@ -214,7 +290,7 @@ class StackBlock(Block):
                             "origin": x.name,
                             "target": y.name,
                             "space": "Empty Space",
-                            "optional": False,
+                            "optional": global_optional,
                         }
                     )
         return channels
@@ -229,9 +305,17 @@ class StackBlock(Block):
 
         nodes = []
 
+        domain_map = {}
         # Render components
         for component in self.components:
+            domain = component.domain
+            domain = [
+                x.name
+                for x in domain
+                if x.name not in ["Empty Space", "Terminating Space"]
+            ]
             component, i = component.render_mermaid(i)
+            domain_map[i] = domain
             out += component
             out += "\n"
             nodes.append(i)
@@ -240,19 +324,42 @@ class StackBlock(Block):
         end_i = i
 
         # Render connections
-        for ix1, ix2 in zip(nodes[:-1], nodes[1:]):
+        x = nodes[:-1]
+        y = nodes[1:]
+        if self.loop:
+            x.append(nodes[-1])
+            y.append(nodes[0])
+        for ix1, ix2, c in zip(x, y, range(len(x))):
+            global_optional = c in self.optional_indices
             if type(ix1) != list:
                 ix1 = [ix1]
             if type(ix2) != list:
                 ix2 = [ix2]
             for ix3 in ix1:
                 for ix4 in ix2:
-                    out += "X{}-->X{}".format(ix3, ix4)
+                    d = domain_map[ix4]
+                    optional = global_optional
+                    if len(d) > 0:
+                        d = "\n".join(d)
+                        d = '"{}"'.format(d)
+                        if optional:
+                            out += "X{}-.{}.->X{}".format(ix3, d, ix4)
+                        else:
+                            out += "X{}--{}-->X{}".format(ix3, d, ix4)
+                    else:
+                        if optional:
+                            out += "X{}-.->X{}".format(ix3, ix4)
+                        else:
+                            out += "X{}--->X{}".format(ix3, ix4)
                     out += "\n"
 
         # Subgraph it
+        if self.mermaid_show_name:
+            name = self.name
+        else:
+            name = " "
         i += 1
-        out = "subgraph X{}[{}]\ndirection TB\n".format(i, self.name) + out
+        out = "subgraph X{}[{}]\ndirection TB\n".format(i, name) + out
         out += "end"
 
         return out, i
@@ -264,6 +371,7 @@ class SplitBlock(Block):
         self.components = data["components"]
         self.description = data["description"]
         self.constraints = data["constraints"]
+        self.mermaid_show_name = data["mermaid_show_name"]
         self.domain = tuple(
             [
                 i
@@ -310,6 +418,7 @@ class SplitBlock(Block):
         self.calls = []
 
         self.block_type = "Split Block"
+        self.metadata = data["metadata"]
 
     def render_mermaid(self, i):
         multi = None
@@ -330,9 +439,9 @@ class SplitBlock(Block):
         end_i = i
 
         # Render invisible connections
-        for ix1, ix2 in zip(nodes[:-1], nodes[1:]):
-            out += "X{} ~~~ X{}".format(ix1, ix2)
-            out += "\n"
+        # for ix1, ix2 in zip(nodes[:-1], nodes[1:]):
+        #    out += "X{} ~~~ X{}".format(ix1, ix2)
+        #    out += "\n"
         out = out[:-1]
 
         return out, nodes

{math_spec_mapping-0.1.5 → 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.5 → 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()
@@ -259,3 +260,85 @@ class MathSpec:
         out["Spaces"] = list(out["Spaces"])
         out["Parameters"] = list(out["Parameters"])
         return out
+
+    def crawl_wiring(self, wiring_name) -> dict:
+        wiring = self.wiring[wiring_name]
+        out = {}
+
+        out["Boundary Actions"] = []
+        out["Control Actions"] = []
+        out["Policies"] = []
+        out["Mechanisms"] = []
+        out["State Updates"] = []
+        out["Entities2"] = []
+        out["Spaces"] = set()
+        out["Parameters"] = set()
+        out["Wiring"] = []
+        q = [wiring.name]
+        while len(q) > 0:
+            x = q.pop()
+            if x in self.wiring:
+                if x not in out["Wiring"]:
+                    x = self.wiring[x]
+                    out["Wiring"].append(x)
+                    q.extend([y.name for y in x.components])
+                else:
+                    x = None
+            elif x in self.boundary_actions:
+                if x not in out["Boundary Actions"]:
+                    x = self.boundary_actions[x]
+                    out["Boundary Actions"].append(x)
+                else:
+                    x = None
+            elif x in self.control_actions:
+                if x not in out["Control Actions"]:
+                    x = self.control_actions[x]
+                    out["Control Actions"].append(x)
+                else:
+                    x = None
+            elif x in self.policies:
+                if x not in out["Policies"]:
+                    x = self.policies[x]
+                    out["Policies"].append(x)
+                else:
+                    x = None
+            elif x in self.mechanisms:
+                if x not in out["Mechanisms"]:
+                    x = self.mechanisms[x]
+                    out["Mechanisms"].append(x)
+                    for y in x.updates:
+                        if y not in out["State Updates"]:
+                            out["State Updates"].append(y)
+                        if y[0] not in out["Entities2"]:
+                            out["Entities2"].append(y[0])
+                else:
+                    x = None
+            else:
+                assert False
+
+            if x:
+                out["Spaces"].update(x.codomain)
+                out["Spaces"].update(x.domain)
+                out["Parameters"].update(x.parameters_used)
+
+        out["Entities"] = self.find_relevant_entities(
+            [x.name for x in out["Boundary Actions"]]
+        )
+
+        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.5 → math_spec_mapping-0.2.1}/src/Classes/Parameter.py

@@ -8,8 +8,11 @@ class ParameterContainer:
         self.data = data
 
         self.all_parameters = []
+        self.parameter_map = {}
         for x in self.data.values():
             x = x.parameters
+            for y in x:
+                self.parameter_map[y.name] = y
             x = [y.name for y in x]
             self.all_parameters.extend(x)
         assert len(set(self.all_parameters)) == len(
@@ -25,6 +28,7 @@ class ParameterSet:
         self.name = data["name"]
         self.notes = data["notes"]
         self.parameters = data["parameters"]
+        self.metadata = data["metadata"]
 
 
 # Individual Parameter
@@ -40,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.5 → 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.5 → 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.5 → 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.5 → 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.5 → 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")
@@ -20,6 +24,9 @@ def convert_boundary_action(data: Dict, ms: Dict) -> BoundaryAction:
         data["name"]
     )
 
+    if len(data["codomain"]) == 0:
+        data["codomain"] = ("Empty Space",)
+
     # Copy
     data = data.copy()
 
@@ -53,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.5 → math_spec_mapping-0.2.1}/src/Load/control_actions.py

@@ -14,8 +14,19 @@ 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(
+        data["name"]
+    )
+
+    if len(data["codomain"]) == 0:
+        data["codomain"] = ("Empty Space",)
 
     # Copy
     data = data.copy()
@@ -42,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.5 → 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"