math-spec-mapping 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

Classes/Block.py

@@ -21,6 +21,7 @@ class Block:
             self.called_by = []
         self.calls = []
         self.block_type = "Block"
+        self.all_updates = []
         # Will be overwritten in composite blocks to represent individual components
         self.domain_blocks = tuple(
             [
@@ -61,16 +62,85 @@ class Block:
             for _ in range(len([x for x in self.codomain if x == TerminatingSpace]))
         )
 
+        self.find_all_spaces_used(data)
+
     def render_mermaid(self, i):
         i += 1
-        return "X{}[{}]".format(i, self.name), i
+        out = 'X{}["{}"]'.format(i, self.name)
+        if self.block_type == "Mechanism":
+            for u in self.updates:
+                out += "\n"
+                out += "X{} --> {}".format(
+                    i,
+                    (u[0].name + "-" + u[1].name).replace(" ", "-"),
+                )
+        return out, i
+
+    def render_ending_entities(self):
+        if self.block_type == "Mechanism":
+            updates = self.updates
+        elif self.block_type in ["Parallel Block", "Stack Block", "Split Block"]:
+            updates = self.all_updates
+        else:
+            return "\n", {}
+
+        out = "\n"
+        out += 'subgraph SVS["State Variables"]\n'
+
+        # Render the entities
+        entity_mapping = {}
+        entities = set([x[0] for x in updates])
+        for i, x in enumerate(entities):
+            entity_mapping[x.name] = "EE{}".format(i)
+            out += '{}[("{}")]'.format(entity_mapping[x.name], x.name)
+            out += "\n"
+
+        entity_variable_mapping = {}
+        # Render the state variables
+        for i, x in enumerate(updates):
+            entity_variable_mapping[(x[0].name + "-" + x[1].name).replace(" ", "-")] = (
+                "EES{}".format(i)
+            )
+            out += '{}(["{}"])'.format("EES{}".format(i), x[1].name)
+            out += "\n"
+
+            out += "{} --- {}".format("EES{}".format(i), entity_mapping[x[0].name])
+            out += "\n"
+        out += "end\n"
+        out += "\n"
+        return out, entity_variable_mapping
 
     def render_mermaid_root(self):
         out = """```mermaid\ngraph TB\n"""
+        add, entity_variable_mapping = self.render_ending_entities()
+        out += add
         out += self.render_mermaid(0)[0]
+
+        for key in entity_variable_mapping:
+            out = out.replace(key, entity_variable_mapping[key])
         out += "\n```"
+
         return out
 
+    def find_all_spaces_used(self, data):
+        self.all_spaces_used = []
+        self.all_spaces_used.extend(self.domain)
+        self.all_spaces_used.extend(self.codomain)
+        if "components" in data:
+            for x in data["components"]:
+                self.all_spaces_used.extend(x.all_spaces_used)
+        self.all_spaces_used = list(set(self.all_spaces_used))
+
+    def find_all_updates(self, data):
+        self.all_updates = []
+        if "components" in data:
+            for x in data["components"]:
+                if x.block_type == "Mechanism":
+                    self.all_updates.extend(x.updates)
+                else:
+                    self.all_updates.extend(x.all_updates)
+        self.all_updates = list(set(self.all_updates))
+
 
 class ParallelBlock(Block):
     def __init__(self, data: Dict):
@@ -123,8 +193,9 @@ class ParallelBlock(Block):
 
         self.called_by = []
         self.calls = []
-        self.block_type = "Paralell Block"
+        self.block_type = "Parallel Block"
         self.metadata = data["metadata"]
+        self.find_all_spaces_used(data)
 
     def render_mermaid(self, i):
         multi = None
@@ -139,6 +210,7 @@ class ParallelBlock(Block):
         # Render components
         domain_map = {}
         codomain_map = {}
+
         for component in self.components:
             domain = component.domain
             codomain = component.codomain
@@ -182,22 +254,27 @@ class ParallelBlock(Block):
         for ix1 in nodes:
             d = domain_map[ix1]
             if len(d) > 0:
+                d_length = len(d)
                 d = "\n".join(d)
                 d = '"{}"'.format(d)
-                out += "X{} --{}--> X{}".format(domain_i, d, ix1)
+                out += "X{} --{}{}-> X{}".format(domain_i, d, "-" * d_length, ix1)
             else:
                 out += "X{} --> X{}".format(domain_i, ix1)
             out += "\n"
 
+        codomain_connections = 0
         for ix1 in nodes:
             d = codomain_map[ix1]
             if len(d) > 0:
                 d = "\n".join(d)
                 d = '"{}"'.format(d)
                 out += "X{} --{}--> X{}".format(ix1, d, codomain_i)
-            else:
-                out += "X{} --> X{}".format(ix1, codomain_i)
-            out += "\n"
+                codomain_connections += 1
+                out += "\n"
+            # else:
+            #    out += "X{} --> X{}".format(ix1, codomain_i)
+        if codomain_connections == 0:
+            out = out.replace("X{}[Codomain]".format(codomain_i), "")
 
         # Subgraph it
         if self.mermaid_show_name:
@@ -205,7 +282,7 @@ class ParallelBlock(Block):
         else:
             name = " "
         i += 1
-        out = "subgraph X{}[{}]\ndirection TB\n".format(i, name) + out
+        out = 'subgraph X{}["{}"]\ndirection TB\n'.format(i, name) + out
 
         out += "end"
 
@@ -241,6 +318,7 @@ class StackBlock(Block):
 
         self.block_type = "Stack Block"
         self.metadata = data["metadata"]
+        self.find_all_spaces_used(data)
 
     def _check_domain_mapping(self):
         x = self.components[:-1]
@@ -340,12 +418,13 @@ class StackBlock(Block):
                     d = domain_map[ix4]
                     optional = global_optional
                     if len(d) > 0:
+                        d_length = len(d)
                         d = "\n".join(d)
                         d = '"{}"'.format(d)
                         if optional:
-                            out += "X{}-.{}.->X{}".format(ix3, d, ix4)
+                            out += "X{}-.{}.{}->X{}".format(ix3, d, "." * d_length, ix4)
                         else:
-                            out += "X{}--{}-->X{}".format(ix3, d, ix4)
+                            out += "X{}--{}-{}->X{}".format(ix3, d, "-" * d_length, ix4)
                     else:
                         if optional:
                             out += "X{}-.->X{}".format(ix3, ix4)
@@ -359,7 +438,7 @@ class StackBlock(Block):
         else:
             name = " "
         i += 1
-        out = "subgraph X{}[{}]\ndirection TB\n".format(i, name) + out
+        out = 'subgraph X{}["{}"]\ndirection TB\n'.format(i, name) + out
         out += "end"
 
         return out, i
@@ -419,6 +498,7 @@ class SplitBlock(Block):
 
         self.block_type = "Split Block"
         self.metadata = data["metadata"]
+        self.find_all_spaces_used(data)
 
     def render_mermaid(self, i):
         multi = None

Classes/MathSpec.py

@@ -11,6 +11,7 @@ class MathSpec:
         # Internal variables to keep track
         self._ms_dict = ms_dict
         self._json = json
+        self.type_keys = ms_dict["Type Keys"]
         self.action_transmission_channels = ms_dict["Action Transmission Channels"]
         self.boundary_actions = ms_dict["Boundary Actions"]
         self.control_actions = ms_dict["Control Actions"]
@@ -28,6 +29,11 @@ class MathSpec:
         self.blocks = ms_dict["Blocks"]
         self.types = ms_dict["Types"]
         self.metrics = ms_dict["Metrics"]
+        self.displays = ms_dict["Displays"]
+        self.stateful_metrics_map = {}
+        for x in self.stateful_metrics:
+            for y in self.stateful_metrics[x].metrics:
+                self.stateful_metrics_map[y.name] = y
 
         self._check_parameters()
         self._crawl_parameters()

Classes/Policy.py

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

Classes/Type.py

@@ -3,5 +3,6 @@ class Type:
     def __init__(self, data):
         self.name = data["name"]
         self.type = data["type"]
+        self.type_name = data["type_name"]
         self.notes = data["notes"]
         self.metadata = data["metadata"]

Load/displays.py

@@ -0,0 +1,13 @@
+def load_displays(ms, json) -> None:
+    ms["Displays"] = {}
+    load_wiring(ms, json)
+
+
+def load_wiring(ms, json):
+    ms["Displays"]["Wiring"] = []
+    for display in json["Displays"]["wiring"]:
+        for component in display["components"]:
+            assert component in ms["Blocks"], "{} is not a valid block".format(
+                component
+            )
+        ms["Displays"]["Wiring"].append(display)

Load/general.py

@@ -4,6 +4,7 @@ from ..schema import schema
 
 
 def check_json_keys(json: Dict, check_set_key: str) -> None:
+    pass
     """Function to check the correct keys are in the json dictionary
 
     Args:
@@ -11,7 +12,7 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
         check_set_key (str): The key for what checking set to use
     """
 
-    # Get a temporary list of keys
+    """# Get a temporary list of keys
     keys = list(json.keys())
 
     # Pick the correct checking set
@@ -46,6 +47,7 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             "Wiring",
             "Types",
             "Metrics",
+            "Displays",
         ],
         "State": ["name", "label", "notes", "variables", "metadata"],
         "State Variable": ["type", "name", "description", "symbol", "domain"],
@@ -152,7 +154,7 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
             keys.remove(k)
 
     # Make sure there are no extra keys in the json
-    assert len(keys) == 0, "There are extra keys in json: {}".format(", ".join(keys))
+    assert len(keys) == 0, "There are extra keys in json: {}".format(", ".join(keys))"""
 
 
 def validate_json_schema(json):

Load/load.py

@@ -13,8 +13,9 @@ from .policy import load_policies
 from .spaces import load_spaces
 from .stateful_metrics import load_stateful_metrics
 from .wiring import load_wiring
-from .type import load_types
+from .type import load_types, load_type_keys
 from .metrics import load_metrics
+from .displays import load_displays
 
 
 def load_from_json(json: Dict) -> MathSpec:
@@ -36,6 +37,8 @@ def load_from_json(json: Dict) -> MathSpec:
     ms = {}
 
     # Do loading one by one to transfer the json
+
+    load_type_keys(ms)
     load_types(ms, json)
     load_spaces(ms, json)
     load_states(ms, json)
@@ -46,10 +49,28 @@ def load_from_json(json: Dict) -> MathSpec:
     load_parameters(ms, json)
     load_policies(ms, json)
     load_stateful_metrics(ms, json)
+
+    stateful_metrics_map = {}
+    for x in ms["Stateful Metrics"]:
+        for y in ms["Stateful Metrics"][x].metrics:
+            stateful_metrics_map[y.name] = y
+
     action_transmission_channels = load_wiring(ms, json)
     load_action_transmission_channels(ms, action_transmission_channels)
     load_state_update_transmission_channels(ms, state_update_transmission_channels)
-    load_metrics(ms, json)
+
+    temp = {}
+    for w in json["Wiring"]:
+        temp[w["name"]] = w
+    for w in ms["Wiring"]:
+        w = temp[w]
+        ms["Wiring"][w["name"]].find_all_updates(w)
+
+    load_metrics(ms, json, stateful_metrics_map)
+    if "Displays" in json:
+        load_displays(ms, json)
+    else:
+        ms["Displays"] = None
 
     # Assert all keys are correct for the ms version
     check_json_keys(ms, "Math Spec")

Load/metrics.py

@@ -3,7 +3,7 @@ from ..Classes import Metric
 from .general import check_json_keys
 
 
-def convert_metric(ms, data: Dict) -> Metric:
+def convert_metric(ms, data: Dict, stateful_metrics_map) -> Metric:
     """Function to convert metric
 
     Args:
@@ -33,7 +33,7 @@ def convert_metric(ms, data: Dict) -> Metric:
             x[1]
         )
     for x in data["parameters_used"]:
-        assert x in ms["Parameters"].all_parameters
+        assert x in ms["Parameters"].all_parameters, "{} not in parameters".format(x)
 
     data["domain"] = tuple(data["domain"])
     for x in data["domain"]:
@@ -41,15 +41,20 @@ def convert_metric(ms, data: Dict) -> Metric:
     data["domain"] = tuple(ms["Spaces"][x] for x in data["domain"])
 
     for x in data["metrics_used"]:
-        assert x in ms["Metrics"], "{} not a valid metric".format(x)
+        assert (
+            x in ms["Metrics"] or x in stateful_metrics_map
+        ), "{} not a valid metric".format(x)
 
-    data["metrics_used"] = tuple(ms["Metrics"][x] for x in data["metrics_used"])
+    data["metrics_used"] = tuple(
+        ms["Metrics"][x] if x in ms["Metrics"] else stateful_metrics_map[x]
+        for x in data["metrics_used"]
+    )
 
     # Build the metric object
     return Metric(data)
 
 
-def load_metrics(ms: Dict, json: Dict) -> None:
+def load_metrics(ms: Dict, json: Dict, stateful_metrics_map) -> None:
     """Function to load metrics into the new dictionary
 
     Args:
@@ -65,9 +70,14 @@ def load_metrics(ms: Dict, json: Dict) -> None:
         i = 0
         hold = []
         for metric in metrics:
-            if all([x in ms["Metrics"] for x in metric["metrics_used"]]):
+            if all(
+                [
+                    x in ms["Metrics"] or x in stateful_metrics_map
+                    for x in metric["metrics_used"]
+                ]
+            ):
                 i += 1
-                metric = convert_metric(ms, metric)
+                metric = convert_metric(ms, metric, stateful_metrics_map)
                 assert (
                     metric.name not in ms["Metrics"]
                 ), "{} was a repeated metric".format(metric.name)
@@ -80,6 +90,15 @@ def load_metrics(ms: Dict, json: Dict) -> None:
         for y in metrics:
             for z in y["metrics_used"]:
                 assert (
-                    z in ms["Metrics"] or z in names
+                    z in ms["Metrics"] or z in names or z in stateful_metrics_map
                 ), "{} is not defined in the spec".format(z)
         assert len(metrics) == 0, "There are circular references"
+
+    # Load the metrics into the policies
+    for key in ms["Policies"]:
+        policy = ms["Policies"][key]
+        hold = policy.metrics_used[:]
+        policy.metrics_used = []
+        for x in hold:
+            assert x in ms["Metrics"], "{} not a valid metric".format(x)
+            policy.metrics_used.append(ms["Metrics"][x])

Load/type.py

@@ -1,5 +1,7 @@
 from .general import check_json_keys
 from ..Classes import Type
+import os
+from typing import _UnionGenericAlias
 
 
 def convert_type(data, ms):
@@ -13,6 +15,32 @@ def convert_type(data, ms):
     # Copy
     data = data.copy()
 
+    type_name = data["type"]
+    data["type"] = {}
+    data["type_name"] = {}
+
+    if "python" in ms["Type Keys"]:
+
+        if type_name in ms["Type Keys"]["python"]:
+            data["type"]["python"] = ms["Type Keys"]["python"][type_name]
+            if type(data["type"]["python"]) == dict:
+                out = {}
+                for key in data["type"]["python"]:
+                    val = data["type"]["python"][key]
+                    if type(val) == str:
+                        val = ms["Types"][val].name
+                    else:
+                        val = val.__name__
+                    out[key] = val
+                data["type_name"]["python"] = str(out)
+            elif type(data["type"]["python"]) == _UnionGenericAlias:
+                data["type_name"]["python"] = data["type"]["python"].__repr__()
+            else:
+                data["type_name"]["python"] = data["type"]["python"].__name__
+        if type_name in ms["Type Keys"]["typescript"]:
+            data["type"]["typescript"] = ms["Type Keys"]["typescript"][type_name]
+            data["type_name"]["typescript"] = ms["Type Keys"]["typescript"][type_name]
+
     # Build the type object
     return Type(data)
 
@@ -22,3 +50,51 @@ def load_types(ms, json) -> None:
     ms["Types"] = {}
     for data in json["Types"]:
         ms["Types"][data["name"]] = convert_type(data, ms)
+
+
+def load_python_type_key():
+    from src.TypeMappings.types import mapping
+
+    return mapping
+
+
+def load_typescript_type_key(path):
+    with open(path, "r") as file:
+        type_definitions = file.read()
+    type_definitions = type_definitions.split("\n")
+    type_definitions = [x for x in type_definitions if len(x) > 0]
+    hold = type_definitions[:]
+    type_definitions = []
+    type_definitions.append(hold.pop(0))
+    while len(hold) > 0:
+        curr = hold.pop(0)
+        if "type" in curr or "interface" in curr:
+            type_definitions.append(curr)
+        else:
+            type_definitions[-1] += "\n" + curr
+
+    hold = type_definitions[:]
+    type_definitions = {}
+    for x in hold:
+        name = x
+        if x.startswith("type"):
+            name = name[5:]
+        elif x.startswith("interface"):
+            name = name[10:]
+        else:
+            assert False
+        name = name[: name.index("=")].strip()
+        type_definitions[name] = x
+    return type_definitions
+
+
+def load_type_keys(ms) -> dict:
+    type_keys = {}
+    python_path = "src/TypeMappings/types.py"
+    typescript_path = "src/TypeMappings/types.ts"
+    if os.path.exists(python_path):
+        type_keys["python"] = load_python_type_key()
+    if os.path.exists(typescript_path):
+        type_keys["typescript"] = load_typescript_type_key(typescript_path)
+
+    ms["Type Keys"] = type_keys

Reports/html.py

@@ -111,7 +111,9 @@ def write_entity_reports(ms: MathSpec, directory: str, entities: List[str]) -> N
             f.write(out)
 
 
-def write_spec_tree(ms: MathSpec, path=None, linking=False, add_tabbing=False) -> str:
+def write_spec_tree(
+    ms: MathSpec, path=None, linking=False, add_tabbing=False, readme=False
+) -> str:
     """Write the tree of the specification structure
 
     Args:
@@ -198,6 +200,9 @@ def write_spec_tree(ms: MathSpec, path=None, linking=False, add_tabbing=False) -
         out = out.split("\n")
         out = ["\t" + x for x in out]
         out = "\n".join(out)
+    if readme:
+        out = "\n\n```\n{}\n```".format(out)
+        out = out.replace("**", "")
 
     if path:
         with open("{}/Spec Tree.md".format(path), "w") as f:
@@ -211,6 +216,6 @@ def write_overview(ms: MathSpec, name: str, file_path: str, summary: str = None)
         out += "<h2>Summary</h2>"
         out += "<p>{}</p>".format(summary)
     out += "<h2>Specification Tree</h2>"
-    out += write_spec_tree(ms)
+    out += write_spec_tree(ms, readme=True)
     with open(file_path, "w") as f:
         f.write(out)

Reports/markdown.py

@@ -90,8 +90,16 @@ def write_types_markdown_report(ms, path, t, add_metadata=True):
 
     out += "## Type"
     out += "\n"
-    out += str(t.type)
-    out += "\n\n"
+
+    if "python" in t.type:
+        out += "### Python Type\n"
+        out += t.type_name["python"]
+        out += "\n"
+    if "typescript" in t.type:
+        out += "### Typescript Type\n"
+        out += t.type_name["typescript"]
+        out += "\n"
+    out += "\n"
     out += "## Notes"
     out += "\n\n"
     out += t.notes
@@ -204,6 +212,16 @@ def write_policy_markdown_report(ms, path, policy, add_metadata=True):
         out += "{}. {}".format(i + 1, x)
         out += "\n"
 
+    out += "## Parameters Used\n"
+    for i, x in enumerate(policy.parameters_used):
+        out += "{}. [[{}]]".format(i + 1, x)
+        out += "\n"
+
+    out += "## Metrics Used\n"
+    for i, x in enumerate(policy.metrics_used):
+        out += "{}. [[{}]]".format(i + 1, x.name)
+        out += "\n"
+
     if policy.policy_options:
         out += "## Policy Options\n"
         for i, x in enumerate(policy.policy_options):
@@ -292,7 +310,9 @@ def write_space_markdown_report(ms, path, space, add_metadata=True):
     out += "\n"
     out += "\n"
     d = space.schema
-    d = ",\n".join(["{}: {}".format(a, b.name) for a, b in zip(d.keys(), d.values())])
+    d = ",\n".join(
+        ["{}: [[{}]]".format(a, b.name) for a, b in zip(d.keys(), d.values())]
+    )
     d = "{" + d + "}"
     out += d
     out += "\n"
@@ -337,18 +357,14 @@ def write_control_action_markdown_report(ms, path, control_action, add_metadata=
     if control_action.control_action_options:
         out += "## Control Action Options:\n"
         for i, x in enumerate(control_action.control_action_options):
-            out += "<details>"
-            out += "<summary><b>{}. {}</b></summary>".format(i + 1, x.name)
-            out += "<p>"
+            out += "### {}. {}\n".format(i + 1, x.name)
+            out += "#### Description\n"
             out += x.description
-            out += "</p>"
-
-            out += "<p>"
-            out += "Logic: {}".format(x.logic)
-            out += "</p>"
+            out += "\n"
 
-            out += "</details>"
-        out += "<br/>"
+            out += "#### Logic\n"
+            out += x.logic
+            out += "\n\n"
 
     with open("{}/Control Actions/{}.md".format(path, control_action.label), "w") as f:
         f.write(out)
@@ -408,6 +424,12 @@ def write_wiring_markdown_report(ms, path, wiring, add_metadata=True):
         out += "\n"
     out += "\n"
 
+    out += "## All Spaces Used\n"
+    for i, x in enumerate(wiring.all_spaces_used):
+        out += "{}. [[{}]]".format(i + 1, x.name)
+        out += "\n"
+    out += "\n"
+
     out += "## Parameters Used\n"
     for i, x in enumerate(wiring.parameters_used):
         out += "{}. [[{}]]".format(i + 1, x)
@@ -426,6 +448,12 @@ def write_wiring_markdown_report(ms, path, wiring, add_metadata=True):
         out += "\n"
     out += "\n"
 
+    out += "## All State Updates\n"
+    for i, x in enumerate(wiring.all_updates):
+        out += "{}. [[{}]].{}".format(i + 1, x[0].name, x[1].name)
+        out += "\n"
+    out += "\n"
+
     with open("{}/Wiring/{}.md".format(path, wiring.name), "w") as f:
         f.write(out)
 
@@ -539,6 +567,77 @@ def write_metrics_markdown_report(ms, path, metric, add_metadata=True):
         f.write(out)
 
 
+def write_displays_markdown_reports(ms, path, add_metadata=True):
+    if "Displays" not in os.listdir(path):
+        os.makedirs(path + "/Displays")
+    if "Wiring" not in os.listdir(path + "/Displays"):
+        os.makedirs(path + "/Displays/Wiring")
+
+    for wiring in ms.displays["Wiring"]:
+        write_wiring_display_markdown_report(
+            ms, path, wiring, add_metadata=add_metadata
+        )
+
+
+def write_wiring_display_markdown_report(ms, path, wiring, add_metadata=True):
+    wirings = [ms.wiring[w] for w in wiring["components"]]
+    out = ""
+
+    out += "## Wiring Diagrams"
+    out += "\n"
+    out += "\n"
+    for w in wirings:
+        out += w.render_mermaid_root()
+        out += "\n"
+        out += "\n"
+    out += "## Description"
+    out += "\n"
+    out += "\n"
+    out += wiring["description"]
+    out += "\n"
+
+    out += "## Wirings\n"
+    for i, x in enumerate(wiring["components"]):
+        out += "{}. [[{}]]".format(i + 1, x)
+        out += "\n"
+    out += "\n"
+
+    out += "## Unique Components Used\n"
+    components = [set(x.components) for x in wirings]
+    components = set().union(*components)
+    for i, x in enumerate(components):
+        out += "{}. [[{}]]".format(i + 1, x.name)
+        out += "\n"
+    out += "\n"
+
+    """domain = [set(x.domain) for x in wirings]
+    domain = set().union(*domain)
+    out += "## Unique Domain Spaces\n"
+    for i, x in enumerate(domain):
+        out += "{}. [[{}]]".format(i + 1, x.name)
+        out += "\n"
+    out += "\n"
+
+    codomain = [set(x.codomain) for x in wirings]
+    codomain = set().union(*codomain)
+    out += "## Unique Codomain Spaces\n"
+    for i, x in enumerate(codomain):
+        out += "{}. [[{}]]".format(i + 1, x.name)
+        out += "\n"
+    out += "\n"""
+
+    parameters = [set(x.parameters_used) for x in wirings]
+    parameters = set().union(*parameters)
+    out += "## Unique Parameters Used\n"
+    for i, x in enumerate(parameters):
+        out += "{}. [[{}]]".format(i + 1, x)
+        out += "\n"
+    out += "\n"
+
+    with open("{}/Displays/Wiring/{}.md".format(path, wiring["name"]), "w") as f:
+        f.write(out)
+
+
 def write_all_markdown_reports(ms, path):
 
     # Write entities
@@ -598,3 +697,7 @@ def write_all_markdown_reports(ms, path):
     # Write metrics
     for x in ms.metrics:
         write_metrics_markdown_report(ms, path, x)
+
+    # Write displays
+    if ms.displays:
+        write_displays_markdown_reports(ms, path, add_metadata=True)

{math_spec_mapping-0.2.2.dist-info → math_spec_mapping-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math_spec_mapping
-Version: 0.2.2
+Version: 0.2.4
 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.2.dist-info → math_spec_mapping-0.2.4.dist-info}/RECORD

@@ -1,20 +1,20 @@
 __init__.py,sha256=bWYy9HVSz89bN8y7H7fP7Xrd1TLliPp73zWBUe3KuFE,846
 schema.py,sha256=6mrRqzEnTTSXjb19xJ63MBp0KjKH0s7i6TfT4MkAY9k,233
 Classes/ActionTransmissionChannel.py,sha256=zWMo5QsgPh5WGIWXl-xOrZNMXYJXmK6Vejw1dQvi0og,246
-Classes/Block.py,sha256=ZBGzwMy_mcGGPMjM78n4MT06G-8rtWHfg2O1Fa1ghL4,14058
+Classes/Block.py,sha256=HUM_ziEE40DBy_mG-XFnHjg3MTTO2C5e6ONyZIAy77Q,17000
 Classes/BoundaryAction.py,sha256=AOENCqCEfpjotnHhzUj_F2SOP0SGpkN1tNPr8Mtl6Tc,476
 Classes/ControlAction.py,sha256=xaU3_WVeWOoOFX3O86x30_9Eiirfe76KrO3M2kfjcmo,471
 Classes/Entity.py,sha256=fA0-b128_OHHxfCg4pzqyQV083EYev1HlVpy86S5igg,1226
-Classes/MathSpec.py,sha256=VoZWXHKSmBkerFNI955x1ty6tLhYBxPfKxpSLkfaW34,12952
+Classes/MathSpec.py,sha256=P4FPfv6tpbrY1ytmOQ61hXBey83YoCMgMKOpo6xikxU,13230
 Classes/Mechanism.py,sha256=7jj6bcPI6H2iv1VZZTlpbG4G2k9s4MYkrH8Sfj9uGM4,324
 Classes/Metric.py,sha256=AhPgYppOP6q49xvR8S9STxQsXUKJlTWx7wI1LfZEtww,581
 Classes/Parameter.py,sha256=ZuJ_w0sChvRElJ4sOnXZ2EV4Ell2xXFulKLjVOpgz2E,1237
-Classes/Policy.py,sha256=r0m9oCeAYun2ujoEH0BasuknFV4Rsvlu4Obq4TUO8zk,426
+Classes/Policy.py,sha256=HUEooO4Liy7olmHwegb6A-hcreNMNCevl9QKKwOjSik,475
 Classes/Space.py,sha256=96Cdi8ERkfsgJnh5UyhecKiuU4hWwI6w-i1U1jtwX6A,398
 Classes/State.py,sha256=Mdn0D21G198f6q13-2tVBYUbnzhRwoDivWpFtH4XJq0,1423
 Classes/StateUpdateTransmissionChannel.py,sha256=3hBLvD1lE64PkwqksBXAfFWv7foOZzGQLAFQWy42tOA,257
 Classes/StatefulMetric.py,sha256=UCis1BJ7fsajHHxFF05ZiyDean2D4s4a95uYYW1Mjq4,749
-Classes/Type.py,sha256=gntb5kMEouOKTkUWKZ2YE_EwyeCNM2vl8jja0dz7wn8,185
+Classes/Type.py,sha256=ZDHSiaDixHOxasOJlHbuBsMjZ29O2O5K_nmHOmlO-Ck,228
 Classes/__init__.py,sha256=_hXyZMJanmIex_W6yCR2H7Jw8iU2JJIf3U7VcvBSOGU,737
 Convenience/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 Convenience/starter.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,25 +22,26 @@ Load/__init__.py,sha256=_ga5nHi7U5rY5lCF36_XI9Qmybq4P8R4m5I5mmjLBk8,33
 Load/action_transmission_channel.py,sha256=9Wer7g2s5SSOcUYuZ0PqSKUVVnW3EvGQJZNXJTwW__0,2561
 Load/boundary_actions.py,sha256=WvEj2tqN0pUZtE4EiKUuGzMdAcWsMlLslJJeFjIu6gk,2058
 Load/control_actions.py,sha256=VmjezReijEqe9cdPHQubGZTGVPsYbMzWfLu5Dfm9WvY,1563
+Load/displays.py,sha256=ooHWT_OryzEkp7F3LcGywwdLMRJLxuyPK82zJ3gcyN0,414
 Load/entities.py,sha256=rMD_Pja-zqH1Z14rsO_Ia7dg3BIi5_HoQmqGAoEYofA,1208
-Load/general.py,sha256=1hj35gnZiq93UsoFhuiHv5rNB-VDu8f2sBmJZMdtMNA,4424
-Load/load.py,sha256=-ZrwHH8oc_2rX7vL-VECkRElHFSZBe_GLZ4vjTyl3U0,1870
+Load/general.py,sha256=2q6aGKxXhebiHHTZhtACvM4nWIkTben0o5rXuvfv2Vw,4463
+Load/load.py,sha256=VEiZRsiO3QQnw5ZIJ0RQzgQ5hKoWLz6b36Zv9tG-XvI,2405
 Load/mechanism.py,sha256=aIpMzgQn8f1aywgOHxL5kHQUn1N8K9pmHOVs51bv3Hk,1673
-Load/metrics.py,sha256=UCFYTwDhcIlTtKZFFdr1lxuOfWyWqgHQE5jwPG-33EY,2567
+Load/metrics.py,sha256=gD68mt0Y5jSgofZUwscV8PFatOMV_LPwYyPrwV9SdtE,3273
 Load/parameters.py,sha256=aid_vqYub9643s82NDtMAXLRdV9BPQkri5MadA0L0eQ,1334
 Load/policy.py,sha256=fDBuOe1LWw-6C_xcYtvtx9dpjWoD9GNEumW7bK8QaT0,2077
 Load/spaces.py,sha256=7zgGA57Te7T4hfuCCDElffiidWgn1lKm5E14e1yjt8M,1116
 Load/state_update_transmission_channels.py,sha256=FJWp5n4HdtHAfof5BUQ6BnRakljatL2h8dWCapaVSc0,2238
 Load/stateful_metrics.py,sha256=Z4S1BWVRfE0cGtcUikJnhmYLKW4k1CurAPrOfjObSKo,1795
 Load/states.py,sha256=cwo29SBAtj1FoQLEb8c0wkSCn038lIgM9RjNiZefUaE,1223
-Load/type.py,sha256=fSXO-HrlGC0YYU5mDTfeGr450Wo96Ks0W6Nk0RvRcvU,458
+Load/type.py,sha256=cKfeLAmYG4hl4mxYA3FvWoQt16ReWrL64H98wgehp6U,3043
 Load/wiring.py,sha256=1dR94U5N1W_WI5rL6lYBltH25ZvApB2pIpq9r5Opkug,3083
 Reports/__init__.py,sha256=W27I6S9Ro1hWeHmnxIokCA06awB__eYey7PvKD4Hc1s,933
 Reports/boundary_actions.py,sha256=45BPp4QjWdD-3E9ZWwqgj_nI2-YdcI2ZZ19_Qv_K7Qk,1410
 Reports/control_actions.py,sha256=NksekZKIPFSIkubttFstKFthc5AU9B9PWRLSl9j1wWs,1216
 Reports/general.py,sha256=WOOn6Wlb8M4fsdN49FlKLwOka6vJPQ9aCUy88TL2ki0,1610
-Reports/html.py,sha256=EKuQg7PwhvY0NDZtJj1nVTZeSheez8PDAsj43tdtvio,7737
-Reports/markdown.py,sha256=3YCCuqQQhH0FJ1OVgemG2PznhMeu58FEohEJynFtCsE,16612
+Reports/html.py,sha256=4wpry61_URAc_LeVemQWowVWGlhMwayjaS3eyUSm0rM,7866
+Reports/markdown.py,sha256=j5QYmk9HXZK9mL3LQqJaW7FJ9oqCmBpEfmvtElljiso,19643
 Reports/mechanisms.py,sha256=d2Rxt3JBYvqAOAYUynl0buYVoXEHrO8EGq7GK6hK8NA,1322
 Reports/node_map.py,sha256=FdSMDQG16NX6n9sZcH-T5xwsvgjrV9OqBHc9J_VlNK0,3129
 Reports/parameters.py,sha256=yizNG4lNGrgrlzYYcHMGfXKDFlPw4PMDYshDqZ3YARs,535
@@ -49,8 +50,8 @@ Reports/spaces.py,sha256=-76hR5wQBv4lsG000ypBJ-OprjsNjI-rNRMYdtsYnjQ,579
 Reports/state.py,sha256=RSHDjzSiUj4ZjReWbkBW7k2njs3Ovp-q0rCC7GBfD-A,2203
 Reports/tables.py,sha256=O0CNuqh3LMECq5uLjBOoxMUk5hUvkUK660FNnwWUxDY,1505
 Reports/wiring.py,sha256=u9SvKWy6T-WJUEgFI6-zgZanoOaTTs_2YwmEceDLsV8,1618
-math_spec_mapping-0.2.2.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
-math_spec_mapping-0.2.2.dist-info/METADATA,sha256=To-PMn_1vdVw0pN3v3Mrp3qo03pDy-VNGi7Y-Y7-L_I,5898
-math_spec_mapping-0.2.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-math_spec_mapping-0.2.2.dist-info/top_level.txt,sha256=DKHirRZ28B4EfLjV3iAU31Sdj6q90EDPTSkRGRZf3uo,49
-math_spec_mapping-0.2.2.dist-info/RECORD,,
+math_spec_mapping-0.2.4.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
+math_spec_mapping-0.2.4.dist-info/METADATA,sha256=LuLoWfDUlm2t-bKaYix2Pc6C4Fdzq-jVBJ1meGJKKsc,5898
+math_spec_mapping-0.2.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+math_spec_mapping-0.2.4.dist-info/top_level.txt,sha256=DKHirRZ28B4EfLjV3iAU31Sdj6q90EDPTSkRGRZf3uo,49
+math_spec_mapping-0.2.4.dist-info/RECORD,,

{math_spec_mapping-0.2.2.dist-info → math_spec_mapping-0.2.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any