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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math_spec_mapping
-Version: 0.1.4
+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.4 → 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.4"
+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.4 → math_spec_mapping-0.1.5}/src/Classes/MathSpec.py

@@ -25,6 +25,7 @@ class MathSpec:
         ]
         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.4 → math_spec_mapping-0.1.5}/src/Classes/Mechanism.py

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

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.4 → math_spec_mapping-0.1.5}/src/Classes/__init__.py

@@ -9,5 +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.4 → 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.4 → math_spec_mapping-0.1.5}/src/Load/general.py

@@ -30,7 +30,6 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "Blocks",
         ],
         "JSON": [
-            "Action Transmission Channels",
             "Boundary Actions",
             "Entities",
             "Mechanisms",

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

@@ -40,8 +40,8 @@ def load_from_json(json: Dict) -> MathSpec:
     load_parameters(ms, json)
     load_policies(ms, json)
     load_stateful_metrics(ms, json)
-    load_wiring(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.4 → 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.4 → math_spec_mapping-0.1.5}/src/Load/wiring.py

@@ -29,15 +29,42 @@ def load_single_wiring(data, ms):
     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.4 → 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.4
+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.4/src/Classes/Block.py

@@ -1,184 +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 = []
-        self.block_type = "Block"
-
-    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])
-
-        self.codomain = tuple([i for x in self.components for i in x.codomain])
-        self.parameters_used = list(
-            set([i for x in self.components for i in x.parameters_used])
-        )
-
-        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.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 (
-                a.codomain == b.domain
-            ), "{} codomain does not match {} domain".format(a.name, b.name)
-
-    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])
-        self.codomain = tuple([i for x in self.components for i in x.codomain])
-        self.parameters_used = list(
-            set([i for x in self.components for i in x.parameters_used])
-        )
-
-        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.4/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"]