math-spec-mapping 0.2.6.7__py3-none-any.whl → 0.2.8__py3-none-any.whl

math_spec_mapping/Classes/ControlAction.py

@@ -15,3 +15,4 @@ class ControlActionOption:
         self.name = data["name"]
         self.description = data["description"]
         self.logic = data["logic"]
+        self.implementations = data["implementations"]

math_spec_mapping/Classes/MathSpec.py

@@ -4,6 +4,8 @@ from .Policy import Policy
 from .Mechanism import Mechanism
 from .ControlAction import ControlAction
 from .BoundaryAction import BoundaryAction
+import os
+from copy import deepcopy
 
 
 class MathSpec:
@@ -12,6 +14,7 @@ class MathSpec:
         self._ms_dict = ms_dict
         self._json = json
         self.type_keys = ms_dict["Type Keys"]
+        self.implementations = ms_dict["Implementations"]
         self.action_transmission_channels = ms_dict["Action Transmission Channels"]
         self.boundary_actions = ms_dict["Boundary Actions"]
         self.control_actions = ms_dict["Control Actions"]
@@ -39,6 +42,8 @@ class MathSpec:
         self._crawl_parameters()
         self._crawl_parameters_exploded()
         self._check_dictionary_names()
+        self._build_functional_parameters()
+        self._build_parameter_types()
 
     def _check_dictionary_names(self):
         for key in self.boundary_actions:
@@ -349,3 +354,249 @@ class MathSpec:
         for metrics in self.stateful_metrics.values():
             sm.extend([x.name for x in metrics.metrics])
         return sm
+
+    def _build_functional_parameters(self):
+        opts = [x for x in self.policies.values() if len(x.policy_options) > 1]
+        opts.extend(
+            [
+                x
+                for x in self.boundary_actions.values()
+                if len(x.boundary_action_options) > 1
+            ]
+        )
+        opts.extend(
+            [
+                x
+                for x in self.control_actions.values()
+                if len(x.control_action_options) > 1
+            ]
+        )
+        self.functional_parameters = {}
+        for x in opts:
+            self.functional_parameters["FP {}".format(x.name)] = x
+
+    def _build_parameter_types(self):
+        system_parameters_types = {}
+        behavioral_parameters_types = {}
+        functional_parameters_types = {}
+
+        for x in self.parameters.all_parameters:
+            pt = self.parameters.parameter_map[x].variable_type.original_type_name
+            pc = self.parameters.parameter_map[x].parameter_class
+            if pc == "Functional":
+                functional_parameters_types[x] = pt
+            elif pc == "System":
+                system_parameters_types[x] = pt
+            elif pc == "Behavioral":
+                behavioral_parameters_types[x] = pt
+            else:
+                assert False
+        for x in self.functional_parameters:
+            functional_parameters_types[x] = "str"
+
+        self.system_parameters_types = system_parameters_types
+        self.behavioral_parameters_types = behavioral_parameters_types
+        self.functional_parameters_types = functional_parameters_types
+
+    def metaprogramming_python_types(self, model_directory, overwrite=False):
+        path = model_directory + "/types.py"
+        if not overwrite:
+            assert "types.py" not in os.listdir(
+                model_directory
+            ), "The types file is already written, either delete it or switch to overwrite mode"
+        out = "import typing\n\n"
+        for t in self.types:
+            t = self.types[t]
+            assert "python" in t.type, "No python type associated with {}".format(
+                t.name
+            )
+            x = t.type["python"]
+            type_desc = x.__name__ if hasattr(x, "__name__") else str(x)
+            out += "{} = {}".format(t.original_type_name, type_desc)
+            out += "\n"
+        with open(path, "w") as f:
+            f.write(out)
+
+    def metaprogramming_python_spaces(self, model_directory, overwrite=False):
+        path = model_directory + "/spaces.py"
+        if not overwrite:
+            assert "spaces.py" not in os.listdir(
+                model_directory
+            ), "The spaces file is already written, either delete it or switch to overwrite mode"
+        unique_spaces = set().union(
+            *[set(x.schema.values()) for x in self.spaces.values()]
+        )
+        unique_types = [x.original_type_name for x in unique_spaces]
+        out = ""
+        out += "from .types import {}".format(", ".join(unique_types))
+        out += "\n"
+        out += "from typing import TypedDict"
+        out += "\n"
+        out += "\n"
+
+        for space in self.spaces:
+            out += self.spaces[space].name_variable
+            out += " = "
+            d = self.spaces[space].schema
+            d = [(x, d[x].original_type_name) for x in d]
+            d = ["'{}': {}".format(x[0], x[1]) for x in d]
+            d = ", ".join(d)
+            d = "{" + d + "}"
+            out += "TypedDict('{}', {})".format(self.spaces[space].name, d)
+            out += "\n"
+
+        with open(path, "w") as f:
+            f.write(out)
+
+    def metaprogramming_python_states(
+        self, model_directory, overwrite=False, default_values=None
+    ):
+        path = model_directory + "/states.py"
+        if not overwrite:
+            assert "states.py" not in os.listdir(
+                model_directory
+            ), "The states file is already written, either delete it or switch to overwrite mode"
+        out = ""
+        unique_types = [x.variables for x in self.state.values()]
+        unique_types = [set(y.type.original_type_name for y in x) for x in unique_types]
+        unique_types = set().union(*unique_types)
+        out = ""
+        out += "from .types import {}".format(", ".join(unique_types))
+        out += "\n"
+        out += "from typing import TypedDict"
+        out += "\n"
+        out += "\n"
+
+        for state in self.state:
+            out += self.state[state].name_variable
+            out += " = "
+            d = self.state[state].variables
+            d = [(x.name, x.type.original_type_name) for x in d]
+            d = ["'{}': {}".format(x[0], x[1]) for x in d]
+            d = ", ".join(d)
+            d = "{" + d + "}"
+            out += "TypedDict('{}', {})".format(self.state[state].name, d)
+            out += "\n"
+        out += "\n"
+        out += "state: GlobalState = "
+        out += "{"
+        for x in self.state["Global State"].variables:
+            out += '"{}"'.format(x.name)
+            out += ": "
+            val = "None"
+            if default_values:
+                if x.name in default_values:
+                    val = str(default_values[x.name])
+            out += val
+            out += ",\n"
+        out += "}"
+
+        with open(path, "w") as f:
+            f.write(out)
+
+    def metaprogramming_python_parameters(
+        self, model_directory, overwrite=False, default_values=None
+    ):
+        path = model_directory + "/parameters.py"
+        if not overwrite:
+            assert "parameters.py" not in os.listdir(
+                model_directory
+            ), "The parameters file is already written, either delete it or switch to overwrite mode"
+        out = ""
+
+        unique_types = (
+            set(self.system_parameters_types.values())
+            .union(set(self.functional_parameters_types.values()))
+            .union(set(self.behavioral_parameters_types.values()))
+        )
+        unique_types = [x for x in unique_types if x != "str"]
+
+        out = ""
+        out += "from .types import {}".format(", ".join(unique_types))
+        out += "\n"
+        out += "from typing import TypedDict"
+        out += "\n"
+        out += "\n"
+
+        d = self.system_parameters_types
+        d = [(x, d[x]) for x in d]
+        d = ["'{}': {}".format(x[0], x[1]) for x in d]
+        d = ", ".join(d)
+        d = "{" + d + "}"
+
+        out += "SystemParameters = TypedDict('SystemParameters', {})".format(d)
+        out += "\n\n"
+
+        d = self.behavioral_parameters_types
+        d = [(x, d[x]) for x in d]
+        d = ["'{}': {}".format(x[0], x[1]) for x in d]
+        d = ", ".join(d)
+        d = "{" + d + "}"
+
+        out += "BehavioralParameters = TypedDict('BehavioralParameters', {})".format(d)
+        out += "\n\n"
+
+        d = self.functional_parameters_types
+        d = [(x, d[x]) for x in d]
+        d = ["'{}': {}".format(x[0], x[1]) for x in d]
+        d = ", ".join(d)
+        d = "{" + d + "}"
+
+        out += "FunctionalParameters = TypedDict('FunctionalParameters', {})".format(d)
+        out += "\n\n"
+        out += """Parameters = TypedDict("Parameters",{**BehavioralParameters.__annotations__,
+ **FunctionalParameters.__annotations__,
+**SystemParameters.__annotations__})"""
+        out += "\n\n"
+
+        out += "functional_parameters: FunctionalParameters = "
+        out += "{"
+        for key in self.functional_parameters_types:
+            out += '"{}"'.format(key)
+            out += ": "
+            val = "None"
+            if default_values:
+                if key in default_values:
+                    val = str(default_values[key])
+            out += val
+            out += ",\n"
+        out += "}"
+        out += "\n\n"
+
+        out += "behavioral_parameters: BehavioralParameters = "
+        out += "{"
+        for key in self.behavioral_parameters_types:
+            out += '"{}"'.format(key)
+            out += ": "
+            val = "None"
+            if default_values:
+                if key in default_values:
+                    val = str(default_values[key])
+            out += val
+            out += ",\n"
+        out += "}"
+        out += "\n\n"
+
+        out += "system_parameters: SystemParameters = "
+        out += "{"
+        for key in self.system_parameters_types:
+            out += '"{}"'.format(key)
+            out += ": "
+            val = "None"
+            if default_values:
+                if key in default_values:
+                    val = str(default_values[key])
+            out += val
+            out += ",\n"
+        out += "}"
+        out += "\n\n"
+
+        out += "parameters: Parameters = {**behavioral_parameters, **functional_parameters, **system_parameters}"
+
+        with open(path, "w") as f:
+            f.write(out)
+
+
+class MathSpecImplementation:
+    def __init__(self, ms: MathSpec, params):
+        self.ms = deepcopy(ms)

math_spec_mapping/Classes/Mechanism.py

@@ -10,3 +10,4 @@ class Mechanism(Block):
         self.logic = data["logic"]
         self.updates = []
         self.block_type = "Mechanism"
+        self.implementations = data["implementations"]

math_spec_mapping/Classes/Policy.py

@@ -7,6 +7,7 @@ class PolicyOption:
         self.name = data["name"]
         self.description = data["description"]
         self.logic = data["logic"]
+        self.implementations = data["implementations"]
 
 
 class Policy(Block):

math_spec_mapping/Classes/Space.py

@@ -6,6 +6,7 @@ class Space:
         self.name = data["name"]
         self.schema = data["schema"]
         self.metadata = data["metadata"]
+        self.name_variable = self.name.replace(" ", "").replace("-", "_")
 
     def __repr__(self):
         return self.name

math_spec_mapping/Classes/State.py

@@ -15,6 +15,7 @@ class State:
         self._write_variable_map()
         self.updated_by = []
         self.metadata = data["metadata"]
+        self.name_variable = self.name.replace(" ", "").replace("-", "_")
 
     def _write_variable_map(self) -> None:
         """

math_spec_mapping/Classes/Type.py

@@ -6,3 +6,4 @@ class Type:
         self.type_name = data["type_name"]
         self.notes = data["notes"]
         self.metadata = data["metadata"]
+        self.original_type_name = data["original_type_name"]

math_spec_mapping/Classes/__init__.py

@@ -1,4 +1,4 @@
-from .MathSpec import MathSpec
+from .MathSpec import MathSpec, MathSpecImplementation
 from .State import State, StateVariable
 from .Entity import Entity
 from .BoundaryAction import BoundaryAction, BoundaryActionOption

math_spec_mapping/Load/control_actions.py

@@ -35,6 +35,16 @@ def convert_control_action(data: Dict, ms: Dict) -> ControlAction:
     new_cao = []
     for ca in data["control_action_options"]:
         check_json_keys(ca, "Control Action Option")
+        ca["implementations"] = {}
+        if "python" in ms["Implementations"]:
+            if "control_action_options" in ms["Implementations"]["python"]:
+                if (
+                    ca["name"]
+                    in ms["Implementations"]["python"]["control_action_options"]
+                ):
+                    ca["implementations"]["python"] = ms["Implementations"]["python"][
+                        "control_action_options"
+                    ][ca["name"]]
         new_cao.append(ControlActionOption(ca))
     data["control_action_options"] = new_cao
 

math_spec_mapping/Load/mechanism.py

@@ -42,6 +42,14 @@ def convert_mechanism(data: Dict, ms: Dict) -> Mechanism:
         )
 
     data["domain"] = tuple(ms["Spaces"][x] for x in data["domain"])
+    data["implementations"] = {}
+
+    if "python" in ms["Implementations"]:
+        if "mechanisms" in ms["Implementations"]["python"]:
+            if data["name"] in ms["Implementations"]["python"]["mechanisms"]:
+                data["implementations"]["python"] = ms["Implementations"]["python"][
+                    "mechanisms"
+                ][data["name"]]
 
     # Build the action transmission channel object
     return Mechanism(data), new_channels

math_spec_mapping/Load/policy.py

@@ -5,7 +5,7 @@ from ..Classes import Policy, PolicyOption
 from .general import check_json_keys
 
 
-def convert_policy_options(data: Dict) -> PolicyOption:
+def convert_policy_options(data: Dict, ms) -> PolicyOption:
     """Function to convert policy options
 
     Args:
@@ -21,6 +21,15 @@ def convert_policy_options(data: Dict) -> PolicyOption:
     # Copy
     data = data.copy()
 
+    data["implementations"] = {}
+
+    if "python" in ms["Implementations"]:
+        if "policies" in ms["Implementations"]["python"]:
+            if data["name"] in ms["Implementations"]["python"]["policies"]:
+                data["implementations"]["python"] = ms["Implementations"]["python"][
+                    "policies"
+                ][data["name"]]
+
     # Build the policy object
     return PolicyOption(data)
 
@@ -62,7 +71,7 @@ def convert_policy(data: Dict, ms: Dict) -> Policy:
     # Convert policy options
     policy_options = []
     for po in data["policy_options"]:
-        policy_options.append(convert_policy_options(po))
+        policy_options.append(convert_policy_options(po, ms))
     data["policy_options"] = policy_options
 
     data["codomain"] = tuple(ms["Spaces"][x] for x in data["codomain"])

math_spec_mapping/Load/type.py

@@ -18,6 +18,7 @@ def convert_type(data, ms):
     type_name = data["type"]
     data["type"] = {}
     data["type_name"] = {}
+    data["original_type_name"] = type_name
 
     if "python" in ms["Type Keys"]:
 

math_spec_mapping/Reports/html.py

@@ -9,6 +9,7 @@ from .node_map import create_action_chains_graph
 from .parameters import write_out_params
 from .state import write_local_state_variable_tables, write_global_state_variable_table
 from typing import List
+import os
 
 
 def write_basic_report_full(ms: MathSpec, directory: str, name: str) -> None:
@@ -128,6 +129,15 @@ def write_spec_tree(
     symbol3 = "│   │   ├──"
 
     out = ""
+
+    if linking:
+        out += """---
+cssclasses:
+  - spec
+---
+
+"""
+
     out += symbol1 + "**Entities**\n"
     for name in ms.entities.keys():
         if linking:
@@ -214,7 +224,29 @@ def write_spec_tree(
     if path:
         with open("{}/Spec Tree.md".format(path), "w") as f:
             f.write(out)
-    return out
+        try:
+            if ".obsidian" not in os.listdir(path):
+                path = path + "/" + ".obsidian"
+                os.mkdir(path)
+            else:
+                path = path + "/" + ".obsidian"
+            if "snippets" not in os.listdir(path):
+                path = path + "/" + "snippets"
+                os.mkdir(path)
+            else:
+                path = path + "/" + "snippets"
+
+            snippet = """.spec {
+  font-family: 'Consolas', Courier, monospace ;
+  line-height: 1;
+  }"""
+            with open("{}/spec.css".format(path), "w") as f:
+                f.write(snippet)
+
+        except:
+            print("Couldn't find .obsidian/snippets to put snippet in")
+    else:
+        return out
 
 
 def write_overview(ms: MathSpec, name: str, file_path: str, summary: str = None):

math_spec_mapping/Reports/markdown.py

@@ -675,7 +675,6 @@ def write_all_markdown_reports(ms, path, clear_folders=False):
             "Types",
             "Control Actions",
             "Spaces",
-            ".obsidian",
             "Boundary Actions",
             "Policies",
             "Wiring",

math_spec_mapping/schema.schema.json

@@ -116,28 +116,34 @@
             "additionalProperties": false,
             "properties": {
                 "name": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "The name of the control action"
                 },
                 "description": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "The description of the control action"
                 },
                 "constraints": {
                     "type": "array",
-                    "items": {}
+                    "description": "Any constraints which the control action must respect",
+                    "items": {"type": "string"}
                 },
                 "control_action_options": {
                     "type": "array",
-                    "items": {}
+                    "items": {},
+                    "description": "Possible implementations of the control action"
                 },
                 "codomain": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "The output spaces of the control action"
                 },
                 "parameters_used": {
                     "type": "array",
-                    "items": {"type": "string"}
+                    "items": {"type": "string"},
+                    "description": "The parameters which the control action uses in its implenetations"
                 }
             },
             "required": [
@@ -308,44 +314,52 @@
             "additionalProperties": false,
             "properties": {
                 "name": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "The name of the policy"
                 },
                 "description": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "Description of the policy"
                 },
                 "constraints": {
                     "type": "array",
-                    "items": {}
+                    "description": "Any constraints which the policy must respect",
+                    "items": {"type": "string"}
                 },
                 "policy_options": {
                     "type": "array",
                     "items": {
                         "$ref": "./schema.schema.json/#/definitions/PolicyOption"
-                    }
+                    },
+                    "description": "Possible implementations of the policy"
                 },
                 "domain": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "The spaces which are passed in as inputs to the policy"
                 },
                 "codomain": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "The spaces which are returned as results of the policy"
                 },
                 "parameters_used": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "All parameters used in the implementations of policies"
                 },
                 "metrics_used": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "All metrics used in implementation of policies"
                 }
             },
             "required": [
@@ -366,13 +380,16 @@
             "additionalProperties": false,
             "properties": {
                 "name": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "The name of the policy option"
                 },
                 "description": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "A description of the implementation"
                 },
                 "logic": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "Any logic associated with the implementation"
                 }
             },
             "required": [
@@ -434,38 +451,45 @@
             "additionalProperties": true,
             "properties": {
                 "name": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "Name of the boundary action"
                 },
                 "description": {
-                    "type": "string"
+                    "type": "string",
+                    "description": "Quick description of the boundary action"
                 },
                 "constraints": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "Any constraints which the boundary action must respect"
                 },
                 "boundary_action_options": {
                     "type": "array",
-                    "items": {}
+                    "items": {},
+                    "description": "The options for implementation of the boundary action"
                 },
                 "called_by": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "The entities which are allowed to call this boundary action"
                 },
                 "codomain": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "List of outputs that come out of this block"
                 },
                 "parameters_used": {
                     "type": "array",
                     "items": {
                         "type": "string"
-                    }
+                    },
+                    "description": "The string keys of parameters which have an effect on the boundary action"
                 }
             },
             "required": [

{math_spec_mapping-0.2.6.7.dist-info → math_spec_mapping-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.2.6.7
+Version: 0.2.8
 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.2.6.7.dist-info → math_spec_mapping-0.2.8.dist-info}/RECORD

@@ -1,50 +1,50 @@
 math_spec_mapping/__init__.py,sha256=k5KVhqX1_iIkGjTBHAHezWUeh0b3ilWpJaSIVSbKMcg,907
 math_spec_mapping/schema.py,sha256=6mrRqzEnTTSXjb19xJ63MBp0KjKH0s7i6TfT4MkAY9k,233
-math_spec_mapping/schema.schema.json,sha256=E8-TQIiv7AjIMXnAIB84z_O4cMLfGuDmDCFCoIlwQz0,27174
+math_spec_mapping/schema.schema.json,sha256=DTrPuYbA-n27jatLt2h76WgMm7pWVgkFwC3zGDnlptQ,29208
 math_spec_mapping/Classes/ActionTransmissionChannel.py,sha256=zWMo5QsgPh5WGIWXl-xOrZNMXYJXmK6Vejw1dQvi0og,246
 math_spec_mapping/Classes/Block.py,sha256=hXQO221IP-TqZm_TwFKfURpEEjZm7L1TPZDCYlaOdho,17302
 math_spec_mapping/Classes/BoundaryAction.py,sha256=AOENCqCEfpjotnHhzUj_F2SOP0SGpkN1tNPr8Mtl6Tc,476
-math_spec_mapping/Classes/ControlAction.py,sha256=xaU3_WVeWOoOFX3O86x30_9Eiirfe76KrO3M2kfjcmo,471
+math_spec_mapping/Classes/ControlAction.py,sha256=ysqpgANwdizVdwqtgZmnxXMpCqrzmVEF_6YT0M3l4Ho,526
 math_spec_mapping/Classes/Entity.py,sha256=fA0-b128_OHHxfCg4pzqyQV083EYev1HlVpy86S5igg,1226
-math_spec_mapping/Classes/MathSpec.py,sha256=P4FPfv6tpbrY1ytmOQ61hXBey83YoCMgMKOpo6xikxU,13230
-math_spec_mapping/Classes/Mechanism.py,sha256=7jj6bcPI6H2iv1VZZTlpbG4G2k9s4MYkrH8Sfj9uGM4,324
+math_spec_mapping/Classes/MathSpec.py,sha256=gzTi7QSsFEWPTfHaz8YU0R7X5g4rVDFFBlKdBj4B0Pk,22244
+math_spec_mapping/Classes/Mechanism.py,sha256=2sLm3wYBIeTQaMBcsJ9btqIWsbS895Ra8NY6Y9_G_Dg,379
 math_spec_mapping/Classes/Metric.py,sha256=AhPgYppOP6q49xvR8S9STxQsXUKJlTWx7wI1LfZEtww,581
 math_spec_mapping/Classes/Parameter.py,sha256=ZuJ_w0sChvRElJ4sOnXZ2EV4Ell2xXFulKLjVOpgz2E,1237
-math_spec_mapping/Classes/Policy.py,sha256=HUEooO4Liy7olmHwegb6A-hcreNMNCevl9QKKwOjSik,475
-math_spec_mapping/Classes/Space.py,sha256=96Cdi8ERkfsgJnh5UyhecKiuU4hWwI6w-i1U1jtwX6A,398
-math_spec_mapping/Classes/State.py,sha256=Mdn0D21G198f6q13-2tVBYUbnzhRwoDivWpFtH4XJq0,1423
+math_spec_mapping/Classes/Policy.py,sha256=fzV85tB3QScjiYGfhw_dyQt9L1BYYfTyTIQQcxeT8ac,530
+math_spec_mapping/Classes/Space.py,sha256=QsahxoUfRsDWQLBL683KnGx72MAmRxv7CDE7TMgCG-E,472
+math_spec_mapping/Classes/State.py,sha256=0gJHHTNjTrz1fL2K-yPu-dJlaCsU_NMxClw6neDv6gE,1497
 math_spec_mapping/Classes/StateUpdateTransmissionChannel.py,sha256=3hBLvD1lE64PkwqksBXAfFWv7foOZzGQLAFQWy42tOA,257
 math_spec_mapping/Classes/StatefulMetric.py,sha256=UCis1BJ7fsajHHxFF05ZiyDean2D4s4a95uYYW1Mjq4,749
-math_spec_mapping/Classes/Type.py,sha256=ZDHSiaDixHOxasOJlHbuBsMjZ29O2O5K_nmHOmlO-Ck,228
-math_spec_mapping/Classes/__init__.py,sha256=_hXyZMJanmIex_W6yCR2H7Jw8iU2JJIf3U7VcvBSOGU,737
+math_spec_mapping/Classes/Type.py,sha256=2KFY8d3cv1PzJJ7SSMHJf1zcfQ3ZbqxotK2KgTaLZdM,289
+math_spec_mapping/Classes/__init__.py,sha256=0zxgOqns_9JybD74HKMVh6aw8ij8WVbfQ4Q_1uWzof0,761
 math_spec_mapping/Convenience/__init__.py,sha256=-hNZVoaNSgTmZTiyZoMfWyg14xonC3ppz-diQk1VlUY,60
 math_spec_mapping/Convenience/documentation.py,sha256=Jf7-JJIk_vZkNBIGV4bs5LM3B0RVaCCtuwJ164thGfY,1607
 math_spec_mapping/Convenience/starter.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 math_spec_mapping/Load/__init__.py,sha256=_ga5nHi7U5rY5lCF36_XI9Qmybq4P8R4m5I5mmjLBk8,33
 math_spec_mapping/Load/action_transmission_channel.py,sha256=9Wer7g2s5SSOcUYuZ0PqSKUVVnW3EvGQJZNXJTwW__0,2561
 math_spec_mapping/Load/boundary_actions.py,sha256=WvEj2tqN0pUZtE4EiKUuGzMdAcWsMlLslJJeFjIu6gk,2058
-math_spec_mapping/Load/control_actions.py,sha256=VmjezReijEqe9cdPHQubGZTGVPsYbMzWfLu5Dfm9WvY,1563
+math_spec_mapping/Load/control_actions.py,sha256=4E57s730W4tX5SaKXKaAvet37r8Bwt-g8Kk6EanF4TU,2042
 math_spec_mapping/Load/displays.py,sha256=ooHWT_OryzEkp7F3LcGywwdLMRJLxuyPK82zJ3gcyN0,414
 math_spec_mapping/Load/entities.py,sha256=rMD_Pja-zqH1Z14rsO_Ia7dg3BIi5_HoQmqGAoEYofA,1208
 math_spec_mapping/Load/general.py,sha256=2q6aGKxXhebiHHTZhtACvM4nWIkTben0o5rXuvfv2Vw,4463
 math_spec_mapping/Load/implementations.py,sha256=SGKZ_YXeNpJUTnw5fajQTXji7S2bNQo8sh-7YcIO6pk,395
 math_spec_mapping/Load/load.py,sha256=CLprDhJpbwm9RAzKM2Ghwr8eqBu0a-wvGDOCMmc01YE,2484
-math_spec_mapping/Load/mechanism.py,sha256=aIpMzgQn8f1aywgOHxL5kHQUn1N8K9pmHOVs51bv3Hk,1673
+math_spec_mapping/Load/mechanism.py,sha256=JBy-QpB4W0Z2OcNiakONjD4_RtEgxlFKtLXfDqfhR-0,2037
 math_spec_mapping/Load/metrics.py,sha256=gD68mt0Y5jSgofZUwscV8PFatOMV_LPwYyPrwV9SdtE,3273
 math_spec_mapping/Load/parameters.py,sha256=aid_vqYub9643s82NDtMAXLRdV9BPQkri5MadA0L0eQ,1334
-math_spec_mapping/Load/policy.py,sha256=fDBuOe1LWw-6C_xcYtvtx9dpjWoD9GNEumW7bK8QaT0,2077
+math_spec_mapping/Load/policy.py,sha256=HvlhGHGJTweVs7DOI2HSL_2_diECr8ukDUmzoFLQELo,2444
 math_spec_mapping/Load/spaces.py,sha256=7zgGA57Te7T4hfuCCDElffiidWgn1lKm5E14e1yjt8M,1116
 math_spec_mapping/Load/state_update_transmission_channels.py,sha256=FJWp5n4HdtHAfof5BUQ6BnRakljatL2h8dWCapaVSc0,2238
 math_spec_mapping/Load/stateful_metrics.py,sha256=uGSTc6x6lld5xptgSUMHrO0Vg0QDRIL14C6zTg33S8o,1977
 math_spec_mapping/Load/states.py,sha256=cwo29SBAtj1FoQLEb8c0wkSCn038lIgM9RjNiZefUaE,1223
-math_spec_mapping/Load/type.py,sha256=R6d5t55TMMCKsOk8xXp_Cu5gvkt2DG4Yzvq6NREIefs,4174
+math_spec_mapping/Load/type.py,sha256=Wq2EYTofuq4v8_jGGSr23IXJjwavLMjsqSEyhX9VoAM,4217
 math_spec_mapping/Load/wiring.py,sha256=1dR94U5N1W_WI5rL6lYBltH25ZvApB2pIpq9r5Opkug,3083
 math_spec_mapping/Reports/__init__.py,sha256=W27I6S9Ro1hWeHmnxIokCA06awB__eYey7PvKD4Hc1s,933
 math_spec_mapping/Reports/boundary_actions.py,sha256=45BPp4QjWdD-3E9ZWwqgj_nI2-YdcI2ZZ19_Qv_K7Qk,1410
 math_spec_mapping/Reports/control_actions.py,sha256=NksekZKIPFSIkubttFstKFthc5AU9B9PWRLSl9j1wWs,1216
 math_spec_mapping/Reports/general.py,sha256=WOOn6Wlb8M4fsdN49FlKLwOka6vJPQ9aCUy88TL2ki0,1610
-math_spec_mapping/Reports/html.py,sha256=rBnwvWeFgCfP7O8nsBL6hWE63Y1Qd24QyGD2Z7CnZ-8,8094
-math_spec_mapping/Reports/markdown.py,sha256=pDGHYMdtZmeXHqvU9FB3BycyB4qflWXq0bf2m-wsXMU,21138
+math_spec_mapping/Reports/html.py,sha256=xf5jk3DHWg4CfZHZuF2JK5iZ515ecjDShJJsahiqb4g,8882
+math_spec_mapping/Reports/markdown.py,sha256=eJidreiLmfUznoq_-C4IsFTZ__Bka-PWLKjKYn6bhmw,21113
 math_spec_mapping/Reports/mechanisms.py,sha256=d2Rxt3JBYvqAOAYUynl0buYVoXEHrO8EGq7GK6hK8NA,1322
 math_spec_mapping/Reports/node_map.py,sha256=FdSMDQG16NX6n9sZcH-T5xwsvgjrV9OqBHc9J_VlNK0,3129
 math_spec_mapping/Reports/parameters.py,sha256=yizNG4lNGrgrlzYYcHMGfXKDFlPw4PMDYshDqZ3YARs,535
@@ -53,8 +53,8 @@ math_spec_mapping/Reports/spaces.py,sha256=-76hR5wQBv4lsG000ypBJ-OprjsNjI-rNRMYd
 math_spec_mapping/Reports/state.py,sha256=RSHDjzSiUj4ZjReWbkBW7k2njs3Ovp-q0rCC7GBfD-A,2203
 math_spec_mapping/Reports/tables.py,sha256=O0CNuqh3LMECq5uLjBOoxMUk5hUvkUK660FNnwWUxDY,1505
 math_spec_mapping/Reports/wiring.py,sha256=u9SvKWy6T-WJUEgFI6-zgZanoOaTTs_2YwmEceDLsV8,1618
-math_spec_mapping-0.2.6.7.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
-math_spec_mapping-0.2.6.7.dist-info/METADATA,sha256=RCtYITudw1OBgnI8de20W_3kdhG9LUNxZWmCc6A25nY,6014
-math_spec_mapping-0.2.6.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-math_spec_mapping-0.2.6.7.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
-math_spec_mapping-0.2.6.7.dist-info/RECORD,,
+math_spec_mapping-0.2.8.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
+math_spec_mapping-0.2.8.dist-info/METADATA,sha256=hXBDv_nbuvouVAYXB0jpyKlzNmPFI9xyMjCHn8RvtiE,6012
+math_spec_mapping-0.2.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+math_spec_mapping-0.2.8.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
+math_spec_mapping-0.2.8.dist-info/RECORD,,