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

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math_spec_mapping
-Version: 0.1.3
+Version: 0.1.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.1.3 → math_spec_mapping-0.1.5}/pyproject.toml

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

math_spec_mapping-0.1.5/src/Classes/Block.py

@@ -0,0 +1,338 @@
+from typing import Dict
+from .Space import TerminatingSpace, EmptySpace
+
+
+class Block:
+    def __init__(self, data: Dict):
+        self.name = data["name"]
+        self.description = data["description"]
+        self.constraints = data["constraints"]
+        self.domain = data["domain"]
+        self.codomain = data["codomain"]
+        self.parameters_used = data["parameters_used"]
+        if "label" in data:
+            self.label = data["label"]
+        else:
+            self.label = self.name
+        self.called_by = []
+        self.calls = []
+        self.block_type = "Block"
+        # Will be overwritten in composite blocks to represent individual components
+        self.domain_blocks = tuple(
+            [
+                self
+                for _ in range(
+                    len(
+                        [
+                            x
+                            for x in self.domain
+                            if x not in [TerminatingSpace, EmptySpace]
+                        ]
+                    )
+                )
+            ]
+        )
+        self.codomain_blocks = tuple(
+            [
+                self
+                for _ in range(
+                    len(
+                        [
+                            x
+                            for x in self.codomain
+                            if x not in [TerminatingSpace, EmptySpace]
+                        ]
+                    )
+                )
+            ]
+        )
+        self.domain_blocks_empty = tuple(
+            self for _ in range(len([x for x in self.domain if x == EmptySpace]))
+        )
+        self.codomain_blocks_empty = tuple(
+            self for _ in range(len([x for x in self.codomain if x == EmptySpace]))
+        )
+        self.codomain_blocks_terminating = tuple(
+            self
+            for _ in range(len([x for x in self.codomain if x == TerminatingSpace]))
+        )
+
+    def render_mermaid(self, i):
+        i += 1
+        return "X{}[{}]".format(i, self.name), i
+
+    def render_mermaid_root(self):
+        out = """```mermaid\ngraph TB\n"""
+        out += self.render_mermaid(0)[0]
+        out += "\n```"
+        return out
+
+
+class ParallelBlock(Block):
+    def __init__(self, data: Dict):
+        self.name = data["name"]
+        self.components = data["components"]
+        self.description = data["description"]
+        self.constraints = data["constraints"]
+        self.domain = tuple(
+            [
+                i
+                for x in self.components
+                for i in x.domain
+                if i not in [TerminatingSpace, EmptySpace]
+            ]
+        )
+        if len(self.domain) == 0:
+            self.domain = (EmptySpace,)
+
+        self.codomain = tuple(
+            [
+                i
+                for x in self.components
+                for i in x.codomain
+                if i not in [TerminatingSpace, EmptySpace]
+            ]
+        )
+        if len(self.codomain) == 0:
+            self.codomain = (EmptySpace,)
+        self.parameters_used = list(
+            set([i for x in self.components for i in x.parameters_used])
+        )
+
+        self.domain_blocks = tuple(
+            [i for x in self.components for i in x.domain_blocks]
+        )
+        self.codomain_blocks = tuple(
+            [i for x in self.components for i in x.codomain_blocks]
+        )
+
+        self.domain_blocks_empty = tuple(
+            [i for x in self.components for i in x.domain_blocks_empty]
+        )
+        self.codomain_blocks_empty = tuple(
+            [i for x in self.components for i in x.codomain_blocks_empty]
+        )
+        self.codomain_blocks_terminating = tuple(
+            [i for x in self.components for i in x.codomain_blocks_terminating]
+        )
+
+        self.called_by = []
+        self.calls = []
+        self.block_type = "Paralell Block"
+
+    def render_mermaid(self, i):
+        multi = None
+        if type(i) == list:
+            multi = i
+            i = i[-1]
+        start_i = i
+        out = ""
+
+        nodes = []
+
+        # Render components
+        for component in self.components:
+            component, i = component.render_mermaid(i)
+            out += component
+            out += "\n"
+            nodes.append(i)
+        end_i = i
+
+        # Render invisible connections
+        for ix1, ix2 in zip(nodes[:-1], nodes[1:]):
+            out += "X{} ~~~ X{}".format(ix1, ix2)
+            out += "\n"
+
+        # Subgraph it
+        i += 1
+        out = "subgraph X{}[{}]\ndirection LR\n".format(i, self.name) + out
+
+        out += "end"
+
+        return out, i
+
+
+class StackBlock(Block):
+    def __init__(self, data: Dict):
+        self.name = data["name"]
+        self.components = data["components"]
+        self.description = data["description"]
+        self.constraints = data["constraints"]
+        self._check_domain_mapping()
+        self.domain = self.components[0].domain
+        self.codomain = self.components[-1].codomain
+        self.parameters_used = list(
+            set([i for x in self.components for i in x.parameters_used])
+        )
+
+        self.domain_blocks = self.components[0].domain_blocks
+        self.codomain_blocks = self.components[-1].codomain_blocks
+        self.domain_blocks_empty = self.components[0].domain_blocks_empty
+        self.codomain_blocks_empty = self.components[-1].codomain_blocks_empty
+        self.codomain_blocks_terminating = self.components[
+            -1
+        ].codomain_blocks_terminating
+
+        self.called_by = []
+        self.calls = []
+
+        self.block_type = "Stack Block"
+
+    def _check_domain_mapping(self):
+        for a, b in zip(self.components[:-1], self.components[1:]):
+            assert [
+                x for x in a.codomain if x not in [EmptySpace, TerminatingSpace]
+            ] == [
+                x for x in b.domain if x not in [EmptySpace, TerminatingSpace]
+            ], "{} codomain does not match {} domain, {} != {}".format(
+                a.name, b.name, a.codomain, b.domain
+            )
+
+    def build_action_transmission_channels(self):
+        channels = []
+        for a, b in zip(self.components[:-1], self.components[1:]):
+            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]])
+            for x, y, z in zip(
+                a.codomain_blocks,
+                b.domain_blocks,
+                [x for x in b.domain if x not in [EmptySpace, TerminatingSpace]],
+            ):
+                channels.append(
+                    {
+                        "origin": x.name,
+                        "target": y.name,
+                        "space": z.name,
+                        "optional": False,
+                    }
+                )
+            for x in a.codomain_blocks_empty:
+                for y in b.domain_blocks_empty:
+                    channels.append(
+                        {
+                            "origin": x.name,
+                            "target": y.name,
+                            "space": "Empty Space",
+                            "optional": False,
+                        }
+                    )
+        return channels
+
+    def render_mermaid(self, i):
+        multi = None
+        if type(i) == list:
+            multi = i
+            i = i[-1]
+        start_i = i
+        out = ""
+
+        nodes = []
+
+        # Render components
+        for component in self.components:
+            component, i = component.render_mermaid(i)
+            out += component
+            out += "\n"
+            nodes.append(i)
+            if type(i) == list:
+                i = i[-1]
+        end_i = i
+
+        # Render connections
+        for ix1, ix2 in zip(nodes[:-1], nodes[1:]):
+            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)
+                    out += "\n"
+
+        # Subgraph it
+        i += 1
+        out = "subgraph X{}[{}]\ndirection TB\n".format(i, self.name) + out
+        out += "end"
+
+        return out, i
+
+
+class SplitBlock(Block):
+    def __init__(self, data: Dict):
+        self.name = data["name"]
+        self.components = data["components"]
+        self.description = data["description"]
+        self.constraints = data["constraints"]
+        self.domain = tuple(
+            [
+                i
+                for x in self.components
+                for i in x.domain
+                if i not in [TerminatingSpace, EmptySpace]
+            ]
+        )
+        if len(self.domain) == 0:
+            self.domain = (EmptySpace,)
+
+        self.codomain = tuple(
+            [
+                i
+                for x in self.components
+                for i in x.codomain
+                if i not in [TerminatingSpace, EmptySpace]
+            ]
+        )
+        if len(self.codomain) == 0:
+            self.codomain = (EmptySpace,)
+        self.parameters_used = list(
+            set([i for x in self.components for i in x.parameters_used])
+        )
+
+        self.domain_blocks = tuple(
+            [i for x in self.components for i in x.domain_blocks]
+        )
+        self.codomain_blocks = tuple(
+            [i for x in self.components for i in x.codomain_blocks]
+        )
+
+        self.domain_blocks_empty = tuple(
+            [i for x in self.components for i in x.domain_blocks_empty]
+        )
+        self.codomain_blocks_empty = tuple(
+            [i for x in self.components for i in x.codomain_blocks_empty]
+        )
+        self.codomain_blocks_terminating = tuple(
+            [i for x in self.components for i in x.codomain_blocks_terminating]
+        )
+
+        self.called_by = []
+        self.calls = []
+
+        self.block_type = "Split Block"
+
+    def render_mermaid(self, i):
+        multi = None
+        if type(i) == list:
+            multi = i
+            i = i[-1]
+        start_i = i
+        out = ""
+
+        nodes = []
+
+        # Render components
+        for component in self.components:
+            component, i = component.render_mermaid(i)
+            out += component
+            out += "\n"
+            nodes.append(i)
+        end_i = i
+
+        # Render invisible connections
+        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.3 → math_spec_mapping-0.1.5}/src/Classes/BoundaryAction.py

@@ -4,9 +4,10 @@ from .Block import Block
 
 class BoundaryAction(Block):
     def __init__(self, data: Dict):
-        data["domain"] = None
+        data["domain"] = tuple()
         super().__init__(data)
         self.boundary_action_options = data["boundary_action_options"]
+        self.block_type = "Boundary Action"
 
 
 class BoundaryActionOption:

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Classes/ControlAction.py

@@ -4,9 +4,10 @@ from .Block import Block
 
 class ControlAction(Block):
     def __init__(self, data: Dict):
-        data["domain"] = None
+        data["domain"] = tuple()
         super().__init__(data)
         self.control_action_options = data["control_action_options"]
+        self.block_type = "Control Action"
 
 
 class ControlActionOption:

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Classes/MathSpec.py

@@ -24,6 +24,8 @@ class MathSpec:
             "State Update Transmission Channels"
         ]
         self.stateful_metrics = ms_dict["Stateful Metrics"]
+        self.wiring = ms_dict["Wiring"]
+        self.blocks = ms_dict["Blocks"]
 
         self._check_parameters()
         self._crawl_parameters()

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Classes/Mechanism.py

@@ -1,10 +1,12 @@
 from typing import Dict
 from .Block import Block
+from .Space import TerminatingSpace
 
 
 class Mechanism(Block):
     def __init__(self, data: Dict):
-        data["codomain"] = None
+        data["codomain"] = (TerminatingSpace,)
         super().__init__(data)
         self.logic = data["logic"]
         self.updates = []
+        self.block_type = "Mechanism"

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Classes/Policy.py

@@ -13,3 +13,4 @@ class Policy(Block):
     def __init__(self, data: Dict):
         super().__init__(data)
         self.policy_options: List[PolicyOption] = data["policy_options"]
+        self.block_type = "Policy"

math_spec_mapping-0.1.5/src/Classes/Space.py

@@ -0,0 +1,14 @@
+from typing import Dict
+
+
+class Space:
+    def __init__(self, data: Dict):
+        self.name = data["name"]
+        self.schema = data["schema"]
+
+    def __repr__(self):
+        return self.name
+
+
+TerminatingSpace = Space({"name": "Terminating Space", "schema": {}})
+EmptySpace = Space({"name": "Empty Space", "schema": {}})

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Classes/__init__.py

@@ -9,4 +9,5 @@ from .Policy import Policy, PolicyOption
 from .StateUpdateTransmissionChannel import StateUpdateTransmissionChannel
 from .StatefulMetric import StatefulMetric, StatefulMetricSet
 from .ControlAction import ControlAction, ControlActionOption
-from .Space import Space
+from .Space import Space, TerminatingSpace, EmptySpace
+from .Block import ParallelBlock, Block, StackBlock, SplitBlock

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Load/action_transmission_channel.py

@@ -57,15 +57,17 @@ def convert_action_transmission_channel(
     return ActionTransmissionChannel(data)
 
 
-def load_action_transmission_channels(ms: Dict, json: Dict) -> None:
+def load_action_transmission_channels(
+    ms: Dict, action_transmission_channels: list
+) -> None:
     """Function to load states into the new dictionary
 
     Args:
         ms (Dict): MathSpec dictionary
-        json (Dict): JSON version of MathSpec to load
+        action_transmission_channels (list): List of action transmission channels
     """
 
     ms["Action Transmission Channels"] = []
-    for atc in json["Action Transmission Channels"]:
+    for atc in action_transmission_channels:
         atc = convert_action_transmission_channel(atc, ms)
         ms["Action Transmission Channels"].append(atc)

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Load/boundary_actions.py

@@ -16,6 +16,9 @@ def convert_boundary_action(data: Dict, ms: Dict) -> BoundaryAction:
 
     # Check the keys are correct
     check_json_keys(data, "Boundary Action")
+    assert type(data["codomain"]) == tuple, "{} codomain is not a tuple".format(
+        data["name"]
+    )
 
     # Copy
     data = data.copy()
@@ -35,7 +38,7 @@ def convert_boundary_action(data: Dict, ms: Dict) -> BoundaryAction:
             ), "{} entity not in entities dictionary".format(name)
         data["called_by"] = [ms["Entities"][x] for x in data["called_by"]]
 
-    data["codomain"] = (ms["Spaces"][x] for x in data["codomain"])
+    data["codomain"] = tuple(ms["Spaces"][x] for x in data["codomain"])
 
     # Build the boundary action object
     return BoundaryAction(data)

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Load/control_actions.py

@@ -27,7 +27,7 @@ def convert_control_action(data: Dict, ms: Dict) -> ControlAction:
         new_cao.append(ControlActionOption(ca))
     data["control_action_options"] = new_cao
 
-    data["codomain"] = (ms["Spaces"][x] for x in data["codomain"])
+    data["codomain"] = tuple(ms["Spaces"][x] for x in data["codomain"])
 
     # Build the control action object
     return ControlAction(data)

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Load/general.py

@@ -26,6 +26,21 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "State Update Transmission Channels",
             "Stateful Metrics",
             "Control Actions",
+            "Wiring",
+            "Blocks",
+        ],
+        "JSON": [
+            "Boundary Actions",
+            "Entities",
+            "Mechanisms",
+            "Parameters",
+            "Policies",
+            "Spaces",
+            "State",
+            "State Update Transmission Channels",
+            "Stateful Metrics",
+            "Control Actions",
+            "Wiring",
         ],
         "State": ["name", "label", "notes", "variables"],
         "State Variable": ["type", "name", "description", "symbol", "domain"],
@@ -99,6 +114,7 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "parameter_class",
         ],
         "Space": ["name", "schema"],
+        "Block": ["name", "components", "description", "constraints"],
     }
 
     check_set = check_sets[check_set_key]

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Load/load.py

@@ -12,6 +12,7 @@ from .parameters import load_parameters
 from .policy import load_policies
 from .spaces import load_spaces
 from .stateful_metrics import load_stateful_metrics
+from .wiring import load_wiring
 
 
 def load_from_json(json: Dict) -> MathSpec:
@@ -25,7 +26,7 @@ def load_from_json(json: Dict) -> MathSpec:
     """
 
     # Assert the keys are correct in the json
-    check_json_keys(json, "Math Spec")
+    check_json_keys(json, "JSON")
 
     ms = {}
 
@@ -39,7 +40,8 @@ def load_from_json(json: Dict) -> MathSpec:
     load_parameters(ms, json)
     load_policies(ms, json)
     load_stateful_metrics(ms, json)
-    load_action_transmission_channels(ms, json)
+    action_transmission_channels = load_wiring(ms, json)
+    load_action_transmission_channels(ms, action_transmission_channels)
     load_state_update_transmission_channels(ms, json)
 
     # Assert all keys are correct for the ms version

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Load/mechanism.py

@@ -15,11 +15,14 @@ def convert_mechanism(data: Dict, ms: Dict) -> Mechanism:
 
     # Check the keys are correct
     check_json_keys(data, "Mechanism")
+    assert type(data["domain"]) == tuple, "{} domain is not a tuple".format(
+        data["name"]
+    )
 
     # Copy
     data = data.copy()
 
-    data["domain"] = (ms["Spaces"][x] for x in data["domain"])
+    data["domain"] = tuple(ms["Spaces"][x] for x in data["domain"])
 
     # Build the action transmission channel object
     return Mechanism(data)

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Load/policy.py

@@ -37,6 +37,12 @@ def convert_policy(data: Dict, ms: Dict) -> Policy:
 
     # Check the keys are correct
     check_json_keys(data, "Policy")
+    assert type(data["codomain"]) == tuple, "{} codomain is not a tuple".format(
+        data["name"]
+    )
+    assert type(data["domain"]) == tuple, "{} domain is not a tuple".format(
+        data["name"]
+    )
 
     # Copy
     data = data.copy()
@@ -47,8 +53,8 @@ def convert_policy(data: Dict, ms: Dict) -> Policy:
         policy_options.append(convert_policy_options(po))
     data["policy_options"] = policy_options
 
-    data["codomain"] = (ms["Spaces"][x] for x in data["codomain"])
-    data["domain"] = (ms["Spaces"][x] for x in data["domain"])
+    data["codomain"] = tuple(ms["Spaces"][x] for x in data["codomain"])
+    data["domain"] = tuple(ms["Spaces"][x] for x in data["domain"])
 
     # Build the policy object
     return Policy(data)

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/Load/spaces.py

@@ -1,5 +1,5 @@
 from typing import Dict
-from ..Classes import Space
+from ..Classes import Space, TerminatingSpace, EmptySpace
 from .general import check_json_keys
 
 
@@ -24,6 +24,9 @@ def load_spaces(ms: Dict, json: Dict) -> None:
 
     # Placeholder for now
     ms["Spaces"] = {}
+    ms["Spaces"]["Terminating Space"] = TerminatingSpace
+    ms["Spaces"]["Empty Space"] = EmptySpace
 
     for space in json["Spaces"]:
+        assert space["name"] not in ms["Spaces"], "{} repeated"
         ms["Spaces"][space["name"]] = convert_space(space)

math_spec_mapping-0.1.5/src/Load/wiring.py

@@ -0,0 +1,70 @@
+from typing import Dict
+from ..Classes import Block, StackBlock, ParallelBlock, SplitBlock
+from .general import check_json_keys
+
+
+def load_single_wiring(data, ms):
+    block_type = data.pop("type")
+    # Check the keys are correct
+    check_json_keys(data, "Block")
+    assert block_type in [
+        "Stack",
+        "Parallel",
+        "Split",
+    ], "{} not a valid block type".format(block_type)
+
+    # Map components
+    data["components"] = [ms["Blocks"][x] for x in data["components"]]
+
+    # Map to the correct block
+    if block_type == "Stack":
+        block = StackBlock(data)
+    elif block_type == "Parallel":
+        block = ParallelBlock(data)
+    elif block_type == "Split":
+        block = SplitBlock(data)
+    else:
+        assert False
+
+    return block
+
+
+def check_repeat(d, blocks):
+    for x in blocks:
+        assert x not in d, "{} was a repeated block".format(x)
+
+
+def filter_atc(action_transmission_channels):
+    seen = []
+    out = []
+    for x in action_transmission_channels:
+        key = frozenset(x.items())
+        if key not in seen:
+            seen.append(key)
+            out.append(x)
+    return out
+
+
+def load_wiring(ms, json):
+    ms["Blocks"] = {}
+    check_repeat(ms["Blocks"], ms["Boundary Actions"])
+    ms["Blocks"].update(ms["Boundary Actions"])
+    check_repeat(ms["Blocks"], ms["Control Actions"])
+    ms["Blocks"].update(ms["Control Actions"])
+    check_repeat(ms["Blocks"], ms["Policies"])
+    ms["Blocks"].update(ms["Policies"])
+    check_repeat(ms["Blocks"], ms["Mechanisms"])
+    ms["Blocks"].update(ms["Mechanisms"])
+
+    ms["Wiring"] = {}
+    action_transmission_channels = []
+    for w in json["Wiring"]:
+        w = load_single_wiring(w, ms)
+        assert w.name not in ms["Blocks"], "{} was a repeated block".format(w.name)
+        ms["Wiring"][w.name] = w
+        ms["Blocks"][w.name] = w
+        if w.block_type == "Stack Block":
+            action_transmission_channels.extend(w.build_action_transmission_channels())
+    action_transmission_channels = filter_atc(action_transmission_channels)
+
+    return action_transmission_channels

{math_spec_mapping-0.1.3 → math_spec_mapping-0.1.5}/src/math_spec_mapping.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math_spec_mapping
-Version: 0.1.3
+Version: 0.1.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.1.3 → math_spec_mapping-0.1.5}/src/math_spec_mapping.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ src/Load/spaces.py
 src/Load/state_update_transmission_channels.py
 src/Load/stateful_metrics.py
 src/Load/states.py
+src/Load/wiring.py
 src/Reports/__init__.py
 src/Reports/boundary_actions.py
 src/Reports/control_actions.py

math_spec_mapping-0.1.3/src/Classes/Block.py

@@ -1,17 +0,0 @@
-from typing import Dict
-
-
-class Block:
-    def __init__(self, data: Dict):
-        self.name = data["name"]
-        self.description = data["description"]
-        self.constraints = data["constraints"]
-        self.domain = data["domain"]
-        self.codomain = data["codomain"]
-        self.parameters_used = data["parameters_used"]
-        if "label" in data:
-            self.label = data["label"]
-        else:
-            self.label = self.name
-        self.called_by = []
-        self.calls = []

math_spec_mapping-0.1.3/src/Classes/Space.py

@@ -1,7 +0,0 @@
-from typing import Dict
-
-
-class Space:
-    def __init__(self, data: Dict):
-        self.name = data["name"]
-        self.schema = data["schema"]