math-spec-mapping 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

Classes/Block.py

@@ -1,4 +1,5 @@
 from typing import Dict
+from .Space import TerminatingSpace, EmptySpace
 
 
 class Block:
@@ -15,3 +16,323 @@ class Block:
             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

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:

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:

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()

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"

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"

Classes/Space.py

@@ -5,3 +5,10 @@ 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": {}})

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

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)

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)

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)

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]

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

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)

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)

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)

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.dist-info → math_spec_mapping-0.1.5.dist-info}/METADATA

@@ -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.dist-info → math_spec_mapping-0.1.5.dist-info}/RECORD

@@ -1,34 +1,35 @@
 __init__.py,sha256=lsyvmC37lNTZbIK_b0O4WQpYt129kB0-fhj14UXje80,339
 Classes/ActionTransmissionChannel.py,sha256=zWMo5QsgPh5WGIWXl-xOrZNMXYJXmK6Vejw1dQvi0og,246
-Classes/Block.py,sha256=ZZ7nJOSLUzwpWlz3TnbF6RnCSN1Mg3S8lKldMu5PKkM,503
-Classes/BoundaryAction.py,sha256=DQkfRLc4fFB0lmkAcZn7SPpCBObi9rRfPkclFDcjoHI,429
-Classes/ControlAction.py,sha256=Y1jmm3pNDuauhhuGLpdVIWhuArwk7_7MFNRl_fZGElY,425
+Classes/Block.py,sha256=kCvXCSPA7vWbzTQrnMN9HR4O5Dpn9D7FF101JrIg-X8,10474
+Classes/BoundaryAction.py,sha256=AOENCqCEfpjotnHhzUj_F2SOP0SGpkN1tNPr8Mtl6Tc,476
+Classes/ControlAction.py,sha256=xaU3_WVeWOoOFX3O86x30_9Eiirfe76KrO3M2kfjcmo,471
 Classes/Entity.py,sha256=wCckyg7880oenwj503Wi4_HbVRZab9zl13Q51Dc2OtA,1197
-Classes/MathSpec.py,sha256=Wpq20x76SeA8Z5uBhEhFc7-BcJ7qba49vTnH29gl5e8,9913
-Classes/Mechanism.py,sha256=-rmnOHNcxsRNS4pH9eMkRiZomx0ZcXI-Yednw6_JJfE,235
+Classes/MathSpec.py,sha256=haU6iR4ILfqOucWHEyYHCUK1XD_nFSRfpMUd5I9JCVI,9993
+Classes/Mechanism.py,sha256=7jj6bcPI6H2iv1VZZTlpbG4G2k9s4MYkrH8Sfj9uGM4,324
 Classes/Parameter.py,sha256=ZWHgXP1MyxjFH943ZU3tWkhw6YGqcBY4xTmnQDJ1cJo,1052
-Classes/Policy.py,sha256=7Mz0QmsEdZcgK9_wlMaeEoCEgtKC5E8koDGmdXHHyi4,391
-Classes/Space.py,sha256=-8e__ZkCvksoUD3QDEysJQnQSdl6cv8jGIUmO096A0s,145
+Classes/Policy.py,sha256=r0m9oCeAYun2ujoEH0BasuknFV4Rsvlu4Obq4TUO8zk,426
+Classes/Space.py,sha256=jlPIGgRR1GmJScJMc-jpK1kLBV3lxW3GyqY4JVWdlLo,325
 Classes/State.py,sha256=2JsI63lG_4K-f6QXMqFFoiu_0oFF0rbNQp-0ivb3uGE,1369
 Classes/StateUpdateTransmissionChannel.py,sha256=3hBLvD1lE64PkwqksBXAfFWv7foOZzGQLAFQWy42tOA,257
 Classes/StatefulMetric.py,sha256=r0d7mEE4yPJNQ-aQybLAiywcXo-K9AiwPvq2ILgmT-Y,667
-Classes/__init__.py,sha256=JirG2bLL_-yTac5Gd7lfazdVdgGSmEfs_zGILJorTDU,593
+Classes/__init__.py,sha256=_BdQRhSAtm2Ks3cTdu36P4dtBdcFHfg7JuP3UvfUojA,687
 Convenience/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Convenience/starter.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Load/__init__.py,sha256=_ga5nHi7U5rY5lCF36_XI9Qmybq4P8R4m5I5mmjLBk8,33
-Load/action_transmission_channel.py,sha256=E_EPWJ44H5GKNDl0fwJhC9LksI7z6AAaV9dttjQcQD4,2511
-Load/boundary_actions.py,sha256=HokALnMEJd_upSZW_tTjqArHzwlbxR1_TYbwdJrYmus,1781
-Load/control_actions.py,sha256=xFJrC4kQw0mbYw9YwoVnj3fFhr2kEC5GefE8MCzEV9Y,1302
+Load/action_transmission_channel.py,sha256=9Wer7g2s5SSOcUYuZ0PqSKUVVnW3EvGQJZNXJTwW__0,2561
+Load/boundary_actions.py,sha256=SBc5wTA1dv1Hb6hipuPpUdMRjQdmwZAmZnPZKTcllto,1894
+Load/control_actions.py,sha256=0Jrfhxz7aP3sEI71JmS0FU4CzgFnJqcXW5HOntb3zK0,1307
 Load/entities.py,sha256=mz1zx1KQZjGPI6KvDnA0HbMRT3ijmeYGpvF8MH6R118,1104
-Load/general.py,sha256=UBBzgeMehgJU8tRovdJuW2H38OmVoY0GZsGXVUlKM6c,3361
-Load/load.py,sha256=ZPWrztKBZ9P4vBogKSchi5KXnO6JKPecWvGUJTyAjIw,1487
-Load/mechanism.py,sha256=4QqpZ-DPOMJ9N03OSBUbgwJGVcU_YZZn8UyevLNWc8k,933
+Load/general.py,sha256=Q8JHNhVS0S2VHkO_pAA40hrv27Cq1s1tel4fxUw0g78,3815
+Load/load.py,sha256=2Br4ISFOlzEs4PvOjWe9dM73zbF1W9Q4QLHWujMEadk,1595
+Load/mechanism.py,sha256=MLcT5siLsDsriougm7cQKNXioaFnmH6oJBFYZF6MX5A,1042
 Load/parameters.py,sha256=7QvNXvI2e5dEnW2KvwqtX_Pr-cnvz51WFa3aEbnqMLg,1060
-Load/policy.py,sha256=J1w2GlOYUk4tsfZPexraHce2Op4tucJBI3Fhw7bXluU,1547
-Load/spaces.py,sha256=H93XwDjaXHjQQXnJLQ49sZMo2GgONdOSKJ5TtA3u1MA,645
+Load/policy.py,sha256=Wu4YYZ59QmkZuDatbim3N9pvsAiYeK4r79zqsWtCTPM,1769
+Load/spaces.py,sha256=HKjHQoqK7XHacWyVdn7_3fb84RPUYzD-m9jnbtiCt08,841
 Load/state_update_transmission_channels.py,sha256=l6KnF_4eQwmhvpcuBjEIveNqeZVBQK861SUiOBAWHqA,2216
 Load/stateful_metrics.py,sha256=85zRqK2AuOmxgH9b7Lgha2v44ei3RVClnZ0I17WZ_hg,1160
 Load/states.py,sha256=A_4rBPFAnkuXzzMlv5wnGB5wsFVA-0RghqNp7XCgK8E,966
+Load/wiring.py,sha256=kz6wpxsZBOv_TMKGozK6OgXAYpb6HpaG0E8TKL3bwsY,2098
 Reports/__init__.py,sha256=we5Qb7FIG4iSdkejnTw1H5vj_EdiCx7zMD9K3Xti888,389
 Reports/boundary_actions.py,sha256=45BPp4QjWdD-3E9ZWwqgj_nI2-YdcI2ZZ19_Qv_K7Qk,1410
 Reports/control_actions.py,sha256=NksekZKIPFSIkubttFstKFthc5AU9B9PWRLSl9j1wWs,1216
@@ -41,8 +42,8 @@ Reports/policies.py,sha256=EuBzBsTM6QSS_GHFcAyhGgWvDDZwRuKe7Eos9nX13ho,1814
 Reports/spaces.py,sha256=hyy0TAM8vz986nexGtDKUrEksd9jPTZx47NQWiTfriY,583
 Reports/state.py,sha256=5jPrulJ2MIBto6qIWlapYG4c7YnOlYovV0_pYe2hCKg,932
 Reports/tables.py,sha256=O0CNuqh3LMECq5uLjBOoxMUk5hUvkUK660FNnwWUxDY,1505
-math_spec_mapping-0.1.3.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
-math_spec_mapping-0.1.3.dist-info/METADATA,sha256=p4kqmwfp-Inz9XCUG9p_3dVsu0bhgpovewCckam5SQA,2484
-math_spec_mapping-0.1.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-math_spec_mapping-0.1.3.dist-info/top_level.txt,sha256=VPXI_45FlWgal53yjpbpWhksTVaFU3h8Soro9cmmcxc,42
-math_spec_mapping-0.1.3.dist-info/RECORD,,
+math_spec_mapping-0.1.5.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
+math_spec_mapping-0.1.5.dist-info/METADATA,sha256=A9Ktbppjt2hCZspo-OBXQmBWcFmQCvLupZhGLHOI_Z4,2484
+math_spec_mapping-0.1.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+math_spec_mapping-0.1.5.dist-info/top_level.txt,sha256=VPXI_45FlWgal53yjpbpWhksTVaFU3h8Soro9cmmcxc,42
+math_spec_mapping-0.1.5.dist-info/RECORD,,