math-spec-mapping 0.1.4__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:
@@ -16,6 +17,45 @@ class Block:
         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
@@ -34,13 +74,48 @@ class ParallelBlock(Block):
         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.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"
@@ -90,6 +165,14 @@ class StackBlock(Block):
             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 = []
 
@@ -97,9 +180,44 @@ class StackBlock(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)
+            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
@@ -146,12 +264,48 @@ class SplitBlock(Block):
         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.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 = []
 

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

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 = []

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,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

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/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",

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

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

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

@@ -1,35 +1,35 @@
 __init__.py,sha256=lsyvmC37lNTZbIK_b0O4WQpYt129kB0-fhj14UXje80,339
 Classes/ActionTransmissionChannel.py,sha256=zWMo5QsgPh5WGIWXl-xOrZNMXYJXmK6Vejw1dQvi0og,246
-Classes/Block.py,sha256=1ZXdOGqHlnBozOZgPhgIyV-yE4bKRIpBUOag5axDcas,5181
+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=n03srEYhuZWd9ZYqqMKxC-iQLPhHfj-jz_VdgnKE73U,9953
-Classes/Mechanism.py,sha256=BWFg5O9_li0Qy3IL4w2avPBjxsD_FLttDK5cJBJoyxI,276
+Classes/MathSpec.py,sha256=haU6iR4ILfqOucWHEyYHCUK1XD_nFSRfpMUd5I9JCVI,9993
+Classes/Mechanism.py,sha256=7jj6bcPI6H2iv1VZZTlpbG4G2k9s4MYkrH8Sfj9uGM4,324
 Classes/Parameter.py,sha256=ZWHgXP1MyxjFH943ZU3tWkhw6YGqcBY4xTmnQDJ1cJo,1052
 Classes/Policy.py,sha256=r0m9oCeAYun2ujoEH0BasuknFV4Rsvlu4Obq4TUO8zk,426
-Classes/Space.py,sha256=-8e__ZkCvksoUD3QDEysJQnQSdl6cv8jGIUmO096A0s,145
+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=ih6YYC4QdJGYa6CF0sapbitu-dILJYNqqM5xPsKxe5E,657
+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/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=hISy9IEbb6wnYsqmoDUlN07f2ZVT-D0-TPl9a1Xwmi0,3859
-Load/load.py,sha256=vRh7g7JZDCudUh28C8UK_54Qw4zU6aof1V45ewsoxCU,1540
+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=Wu4YYZ59QmkZuDatbim3N9pvsAiYeK4r79zqsWtCTPM,1769
-Load/spaces.py,sha256=H93XwDjaXHjQQXnJLQ49sZMo2GgONdOSKJ5TtA3u1MA,645
+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=-Vls7mazBQ7hhxw3xJ4ll15_Y3skE8QWElxT8h8SzIk,1158
+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
@@ -42,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.4.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
-math_spec_mapping-0.1.4.dist-info/METADATA,sha256=6NYztrnSMy_CAJGwgInwpewMt6KwNbzYWoiVXNomQq8,2484
-math_spec_mapping-0.1.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-math_spec_mapping-0.1.4.dist-info/top_level.txt,sha256=VPXI_45FlWgal53yjpbpWhksTVaFU3h8Soro9cmmcxc,42
-math_spec_mapping-0.1.4.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,,