math-spec-mapping 0.3.18__tar.gz → 0.3.20__tar.gz

{math_spec_mapping-0.3.18/src/math_spec_mapping.egg-info → math_spec_mapping-0.3.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.3.18
+Version: 0.3.20
 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.3.18 → math_spec_mapping-0.3.20}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "math-spec-mapping"
-version = "0.3.18"
+version = "0.3.20"
 authors = [
   { name="Sean McOwen", email="Sean@Block.Science" },
 ]

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Classes/Block.py

@@ -172,6 +172,9 @@ class Block:
         out = list(set(out))
         return out
 
+    def __repr__(self):
+        return "<{}>".format(self.name)
+
 
 class ParallelBlock(Block):
     def __init__(self, data: Dict):

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Classes/MathSpec.py

@@ -8,7 +8,7 @@ import os
 from copy import deepcopy
 import shutil
 import pandas as pd
-from inspect import signature, getsource, getfile
+from inspect import signature, getsource, getfile, getsourcelines
 from IPython.display import display, Markdown
 
 
@@ -439,7 +439,14 @@ class MathSpec:
 
         self._used_spaces = list(set().union(*self._used_spaces))
         us_names = [y.name for y in self._used_spaces]
-        self._unused_spaces = [self.spaces[x] for x in self.spaces if x not in us_names]
+        self._unused_spaces = [
+            self.spaces[x]
+            for x in self.spaces
+            if x not in us_names and x not in ["Terminating Space", "Empty Space"]
+        ]
+
+        if len(self._unused_spaces) > 0:
+            print("The following spaces are not used: {}".format(self._unused_spaces))
 
     def _add_spec_tree(self, tree):
         self.tree = tree
@@ -535,8 +542,17 @@ class MathSpec:
                             component
                         ]
             elif folder == "Displays":
-                print("Displays not implemented")
-                # keys = [x["name"] for x in ms.displays["Wiring"]]
+
+                for component in self.displays["Wiring"]:
+                    if component["name"] not in tree:
+                        print(
+                            "Can't find component code source in {} for {}".format(
+                                folder, component["name"]
+                            )
+                        )
+                        component["Source Code Location"] = None
+                    else:
+                        component["Source Code Location"] = tree[component["name"]]
             elif folder == "Spaces":
                 for component in self.spaces:
                     if component in ["Terminating Space", "Empty Space"]:
@@ -955,23 +971,31 @@ using .Spaces: generate_space_type
         with open(path, "w") as f:
             f.write(out)
 
-    def build_implementation(self, params):
-        return MathSpecImplementation(self, params)
+    def build_implementation(self, params, domain_codomain_checking=False):
+        return MathSpecImplementation(
+            self, params, domain_codomain_checking=domain_codomain_checking
+        )
 
     def _set_source_code(self):
         if "python" not in self.implementations:
             self.source_code = None
             return
         self.source_code = deepcopy(self.implementations["python"])
+        self.source_code_lines = {}
         for x in self.source_code:
+            self.source_code_lines[x] = {}
             for y in self.source_code[x]:
+                self.source_code_lines[x][y] = "#L{}".format(
+                    getsourcelines(self.source_code[x][y])[1]
+                )
                 self.source_code[x][y] = getsource(self.source_code[x][y])
 
 
 class MathSpecImplementation:
-    def __init__(self, ms: MathSpec, params):
+    def __init__(self, ms: MathSpec, params, domain_codomain_checking):
         self.ms = deepcopy(ms)
         self.params = params
+        self.domain_codomain_checking = domain_codomain_checking
         self.control_actions = self.load_control_actions()
         self.boundary_actions = self.load_boundary_actions()
         self.policies = self.load_policies()
@@ -1010,6 +1034,14 @@ class MathSpecImplementation:
                     )
                 else:
                     control_actions[ca.name] = opt.implementations["python"]
+
+                for opt_i in [x for x in ca.control_action_options if x != opt]:
+                    if "python" not in opt_i.implementations:
+                        print(
+                            "No python implementation for {} / {}. To fix this, go to Implementations/Python/ControlActions and add {}".format(
+                                ca.name, opt_i.name, opt_i.name
+                            )
+                        )
         return control_actions
 
     def load_boundary_actions(self):
@@ -1041,6 +1073,14 @@ class MathSpecImplementation:
                     )
                 else:
                     boundary_actions[ba.name] = opt.implementations["python"]
+
+                for opt_i in [x for x in ba.boundary_action_options if x != opt]:
+                    if "python" not in opt_i.implementations:
+                        print(
+                            "No python implementation for {} / {}. To fix this, go to Implementations/Python/BoundaryActions and add {}".format(
+                                ba.name, opt_i.name, opt_i.name
+                            )
+                        )
         return boundary_actions
 
     def load_mechanisms(self):
@@ -1137,6 +1177,14 @@ class MathSpecImplementation:
                     )
                 else:
                     policies[p.name] = opt.implementations["python"]
+            for opt_i in [x for x in p.policy_options if x != opt]:
+                if "python" not in opt_i.implementations:
+                    print(
+                        "No python implementation for {} / {}. To fix this, go to Implementations/Python/Policies and add {}".format(
+                            p.name, opt_i.name, opt_i.name
+                        )
+                    )
+
         return policies
 
     def load_stateful_metrics(self):
@@ -1283,6 +1331,60 @@ class MathSpecImplementation:
         self.components.update(self.mechanisms)
         self.components.update(self.wiring)
 
+        self.components_enhanced = {}
+
+        def create_wrapper(component, domain_codomain_checking):
+            def wrapper(
+                state,
+                params,
+                spaces,
+                domain_codomain_checking=self.domain_codomain_checking,
+            ):
+                domain = spaces
+
+                # Domain Checking
+                if domain_codomain_checking:
+                    prototype_spaces = self.ms.blocks[component].domain
+                    prototype_spaces = [
+                        x.schema for x in prototype_spaces if x.name != "Empty Space"
+                    ]
+                    assert len(prototype_spaces) == len(
+                        domain
+                    ), "Length of domain incorrect for {}".format(component)
+                    for space1, space2 in zip(domain, prototype_spaces):
+                        assert set(space1.keys()) == set(
+                            space2.keys()
+                        ), "Keys for domain schema of {} is not matched by {} in {} component".format(
+                            set(space2.keys()), set(space1.keys()), component
+                        )
+
+                codomain = self.components[component](state, params, spaces)
+
+                # Codomain Checking
+                if domain_codomain_checking and codomain:
+                    prototype_spaces = self.ms.blocks[component].codomain
+                    prototype_spaces = [
+                        x.schema for x in prototype_spaces if x.name != "Empty Space"
+                    ]
+                    assert len(prototype_spaces) == len(
+                        codomain
+                    ), "Length of codomain incorrect for {}".format(component)
+                    for space1, space2 in zip(codomain, prototype_spaces):
+                        assert set(space1.keys()) == set(
+                            space2.keys()
+                        ), "Keys for codomain schema of {} is not matched by {} in {} component".format(
+                            set(space2.keys()), set(space1.keys()), component
+                        )
+                return codomain
+
+            return wrapper
+
+        for component in self.components:
+
+            self.components_enhanced[component] = create_wrapper(
+                component, self.domain_codomain_checking
+            )
+
     def execute_blocks(self, state, params, blocks):
         for block in blocks:
             self.components[block](state, params, [])

math_spec_mapping-0.3.20/src/math_spec_mapping/Classes/Space.py

@@ -0,0 +1,33 @@
+from typing import Dict
+
+
+class Space:
+    def __init__(self, data: Dict):
+        self.name = data["name"]
+        self.schema = data["schema"]
+        self.metadata = data["metadata"]
+        self.description = data["description"]
+        self.name_variable = self.name.replace(" ", "").replace("-", "_")
+        self.domain_blocks = []
+        self.codomain_blocks = []
+
+    def __repr__(self):
+        return self.name
+
+
+TerminatingSpace = Space(
+    {
+        "name": "Terminating Space",
+        "schema": {},
+        "metadata": {},
+        "description": "Built-in space for denoting termination of block",
+    }
+)
+EmptySpace = Space(
+    {
+        "name": "Empty Space",
+        "schema": {},
+        "metadata": {},
+        "description": "Built-in space for denoting returning no data",
+    }
+)

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Classes/Type.py

@@ -7,3 +7,6 @@ class Type:
         self.notes = data["notes"]
         self.metadata = data["metadata"]
         self.original_type_name = data["original_type_name"]
+
+    def __repr__(self):
+        return self.name

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/action_transmission_channel.py

@@ -50,8 +50,14 @@ def convert_action_transmission_channel(
         data["target"] = ms["Mechanisms"][target]
 
     # Add in called by and called here with origin and target
-    data["origin"].calls.append((data["target"], data["optional"], data["space"]))
-    data["target"].called_by.append((data["origin"], data["optional"], data["space"]))
+    if (data["target"], data["optional"], data["space"]) not in data["origin"].calls:
+        data["origin"].calls.append((data["target"], data["optional"], data["space"]))
+    if (data["origin"], data["optional"], data["space"]) not in data[
+        "target"
+    ].called_by:
+        data["target"].called_by.append(
+            (data["origin"], data["optional"], data["space"])
+        )
 
     # Build the action transmission channel object
     return ActionTransmissionChannel(data)

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/boundary_actions.py

@@ -1,6 +1,6 @@
 from typing import Dict
 from ..Classes import BoundaryAction, BoundaryActionOption
-from .general import check_json_keys
+from .general import check_json_keys, check_domain_codomain_spaces
 
 
 def convert_boundary_action(data: Dict, ms: Dict) -> BoundaryAction:
@@ -24,6 +24,8 @@ def convert_boundary_action(data: Dict, ms: Dict) -> BoundaryAction:
         data["name"]
     )
 
+    check_domain_codomain_spaces(data, ms)
+
     if len(data["codomain"]) == 0:
         data["codomain"] = ("Empty Space",)
 

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/control_actions.py

@@ -1,6 +1,6 @@
 from typing import Dict
 from ..Classes import ControlAction, ControlActionOption
-from .general import check_json_keys
+from .general import check_json_keys, check_domain_codomain_spaces
 
 
 def convert_control_action(data: Dict, ms: Dict) -> ControlAction:
@@ -25,6 +25,8 @@ def convert_control_action(data: Dict, ms: Dict) -> ControlAction:
         data["name"]
     )
 
+    check_domain_codomain_spaces(data, ms)
+
     if len(data["codomain"]) == 0:
         data["codomain"] = ("Empty Space",)
 

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/general.py

@@ -159,3 +159,12 @@ def check_json_keys(json: Dict, check_set_key: str) -> None:
 
 def validate_json_schema(json):
     validate(json, schema)
+
+
+def check_domain_codomain_spaces(json: Dict, ms) -> None:
+    if "domain" in json:
+        for key in json["domain"]:
+            assert key in ms["Spaces"], "{} not in spaces".format(key)
+    if "codomain" in json:
+        for key in json["codomain"]:
+            assert key in ms["Spaces"], "{} not in spaces".format(key)

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/mechanism.py

@@ -1,6 +1,6 @@
 from typing import Dict
 from ..Classes import Mechanism
-from .general import check_json_keys
+from .general import check_json_keys, check_domain_codomain_spaces
 
 
 def convert_mechanism(data: Dict, ms: Dict) -> Mechanism:
@@ -26,6 +26,8 @@ def convert_mechanism(data: Dict, ms: Dict) -> Mechanism:
     if len(data["domain"]) == 0:
         data["domain"] = ("Empty Space",)
 
+    check_domain_codomain_spaces(data, ms)
+
     # Copy
     data = data.copy()
 

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/policy.py

@@ -2,7 +2,7 @@ from typing import Dict
 from ..Classes import Policy, PolicyOption
 
 
-from .general import check_json_keys
+from .general import check_json_keys, check_domain_codomain_spaces
 
 
 def convert_policy_options(data: Dict, ms) -> PolicyOption:
@@ -58,6 +58,7 @@ def convert_policy(data: Dict, ms: Dict) -> Policy:
     assert type(data["domain"]) == tuple, "{} domain is not a tuple".format(
         data["name"]
     )
+    check_domain_codomain_spaces(data, ms)
 
     if len(data["codomain"]) == 0:
         data["codomain"] = ("Empty Space",)

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/spaces.py

@@ -20,6 +20,9 @@ def convert_space(ms, data: Dict) -> Space:
         )
         data["schema"][x] = ms["Types"][data["schema"][x]]
 
+    if "description" not in data:
+        data["description"] = None
+
     # Build the space object
     return Space(data)
 

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/spec_tree.py

@@ -2,6 +2,18 @@ import ast
 import os
 
 
+def index_to_line_and_column(lines, index):
+    cumulative_length = 0
+    for line_number, line in enumerate(lines):
+        line_length = len(line) + 1  # +1 for the newline character
+        if cumulative_length + line_length > index:
+            column = index - cumulative_length
+            return line_number, column
+        cumulative_length += line_length
+
+    raise ValueError("Index out of range")
+
+
 def load_spec_tree(path, ms):
     tree = {}
     for folder in [
@@ -61,11 +73,20 @@ def load_spec_tree(path, ms):
                     assert False, "Not implemented for imports that are not import from"
                 elif isinstance(node, ast.ImportFrom):
                     if node.module:
-                        for name in node.names:
-                            file_path = "{}/{}/{}.py".format(path, folder, node.module)
-                            with open(file_path, "r") as file2:
-                                contents = file2.read()
-                            for key in keys:
-                                if key in contents:
-                                    tree[folder][key] = os.path.abspath(file_path)
+                        file_path = "{}/{}/{}.py".format(path, folder, node.module)
+
+                        with open(file_path, "r") as file2:
+                            contents = file2.read()
+                        split = contents.split("\n")
+                        for key in keys:
+                            if key in contents:
+                                line_number = (
+                                    index_to_line_and_column(
+                                        split, contents.index(key)
+                                    )[0]
+                                    + 1
+                                )
+                                tree[folder][key] = os.path.abspath(
+                                    file_path
+                                ) + "#L{}".format(line_number)
     return tree

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Load/stateful_metrics.py

@@ -40,6 +40,12 @@ def convert_stateful_metric(ms, data: Dict) -> StatefulMetricSet:
                 x[1]
             )
 
+        assert (
+            var["type"] in ms["Types"] or var["type"] in ms["Spaces"]
+        ), "{} type/space referenced by {} is not present in math spec".format(
+            var["type"], var["name"]
+        )
+
         var["implementations"] = {}
         if "python" in ms["Implementations"]:
             if "stateful_metrics" in ms["Implementations"]["python"]:

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Reports/html.py

@@ -169,6 +169,13 @@ cssclasses:
             else:
                 out += symbol3 + "{}".format(var.name) + "\n"
 
+    out += symbol1 + "**Metrics**\n"
+    for name in ms.metrics.keys():
+        if linking:
+            out += symbol2 + "[[{}]]".format(name) + "\n"
+        else:
+            out += symbol2 + "{}".format(name) + "\n"
+
     out += symbol1 + "**Types**\n"
     for name in ms.types.keys():
         if linking:
@@ -221,6 +228,12 @@ cssclasses:
             out += symbol2 + "[[{}]]".format(name) + "\n"
         else:
             out += symbol2 + name + "\n"
+    out += symbol1 + "**Wirings**\n"
+    for name in ms.wiring.keys():
+        if linking:
+            out += symbol2 + "[[{}]]".format(name) + "\n"
+        else:
+            out += symbol2 + name + "\n"
 
     if add_tabbing:
         out = out.split("\n")

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/Reports/markdown.py

@@ -1,6 +1,6 @@
 import os
 from .state import write_state_section
-from inspect import signature, getsource, getfile
+from inspect import signature, getsource, getfile, getsourcelines
 
 
 def get_source_code(
@@ -16,7 +16,7 @@ def get_source_code(
 {}```""".format(
         getsource(code)
     )
-    file_path = getfile(code)
+    file_path = getfile(code) + "#L{}".format(getsourcelines(code)[1])
     return source_code, file_path
 
 
@@ -67,7 +67,10 @@ def write_entity_markdown_report(ms, path, entity, add_metadata=True):
 
 
 def write_source_code_block(component, text, path):
-    file_path = component.source_code_location
+    if hasattr(component, "source_code_location"):
+        file_path = component.source_code_location
+    else:
+        file_path = component["Source Code Location"]
     if file_path:
         file_path = os.path.relpath(file_path, path)
         text += "## Spec Source Code Location\n\n"
@@ -434,6 +437,13 @@ def write_space_markdown_report(ms, path, space, add_metadata=True):
                 "\n".join(["{}: {}".format(x, metadata[x]) for x in metadata])
             )
 
+    if space.description:
+        out += "## Description"
+        out += "\n"
+        out += space.description
+        out += "\n"
+        out += "\n"
+
     out += "## Schema"
     out += "\n"
     out += "\n"
@@ -855,6 +865,8 @@ def write_state_variables_markdown_reports(ms, path, state, add_metadata=True):
         out += "Description: "
         out += variable.description
         out += "\n\n"
+        out += "Underlying state: [[{}]]".format(state.name)
+        out += "\n\n"
         out += "Type: [["
         out += variable.type.name
         out += "]]\n\n"
@@ -939,7 +951,10 @@ def write_wiring_display_markdown_report(ms, path, wiring, add_metadata=True):
         out += "\n"
     out += "\n"
 
-    with open("{}/Displays/Wiring/{}.md".format(path, wiring["name"]), "w") as f:
+    path = "{}/Displays/Wiring/{}.md".format(path, wiring["name"])
+    out = write_source_code_block(wiring, out, path)
+
+    with open(path, "w") as f:
         f.write(out)
 
 

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20}/src/math_spec_mapping/schema.schema.json

@@ -441,6 +441,9 @@
                 "name": {
                     "type": "string"
                 },
+                "description": {
+                    "type": "string"
+                },
                 "schema": {
                     "$ref": "./schema.schema.json/#/definitions/Schema"
                 }

{math_spec_mapping-0.3.18 → math_spec_mapping-0.3.20/src/math_spec_mapping.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.3.18
+Version: 0.3.20
 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.3.18/src/math_spec_mapping/Classes/Space.py

@@ -1,18 +0,0 @@
-from typing import Dict
-
-
-class Space:
-    def __init__(self, data: Dict):
-        self.name = data["name"]
-        self.schema = data["schema"]
-        self.metadata = data["metadata"]
-        self.name_variable = self.name.replace(" ", "").replace("-", "_")
-        self.domain_blocks = []
-        self.codomain_blocks = []
-
-    def __repr__(self):
-        return self.name
-
-
-TerminatingSpace = Space({"name": "Terminating Space", "schema": {}, "metadata": {}})
-EmptySpace = Space({"name": "Empty Space", "schema": {}, "metadata": {}})