math-spec-mapping 0.2.8__tar.gz → 0.3.1__tar.gz

{math-spec-mapping-0.2.8/src/math_spec_mapping.egg-info → math_spec_mapping-0.3.1}/PKG-INFO

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

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

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/Classes/MathSpec.py

@@ -6,6 +6,7 @@ from .ControlAction import ControlAction
 from .BoundaryAction import BoundaryAction
 import os
 from copy import deepcopy
+import shutil
 
 
 class MathSpec:
@@ -356,24 +357,31 @@ class MathSpec:
         return sm
 
     def _build_functional_parameters(self):
-        opts = [x for x in self.policies.values() if len(x.policy_options) > 1]
+        opts = [
+            (x, x.policy_options)
+            for x in self.policies.values()
+            if len(x.policy_options) > 1
+        ]
         opts.extend(
             [
-                x
+                (x, x.boundary_actions)
                 for x in self.boundary_actions.values()
                 if len(x.boundary_action_options) > 1
             ]
         )
         opts.extend(
             [
-                x
+                (x, x.control_actions)
                 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
+            x, y = x
+            self.functional_parameters["FP {}".format(x.name)] = {}
+            for y1 in y:
+                self.functional_parameters["FP {}".format(x.name)][y1.name] = y1
 
     def _build_parameter_types(self):
         system_parameters_types = {}
@@ -596,7 +604,184 @@ class MathSpec:
         with open(path, "w") as f:
             f.write(out)
 
+    def metaprogramming_julia_types(self, model_directory, overwrite=False):
+        path = model_directory + "/types.jl"
+        if not overwrite:
+            assert "types.jl" not in os.listdir(
+                model_directory
+            ), "The types file is already written, either delete it or switch to overwrite mode"
+
+        shutil.copyfile("src/TypeMappings/types.jl", path)
+
+    def metaprogramming_julia_spaces(
+        self, model_directory, cadCAD_path, overwrite=False
+    ):
+        path = model_directory + "/spaces.jl"
+        if not overwrite:
+            assert "spaces.jl" not in os.listdir(
+                model_directory
+            ), "The spaces file is already written, either delete it or switch to overwrite mode"
+
+        out = """include("{}")
+include("types.jl")
+using .Spaces: generate_space_type
+
+""".format(
+            cadCAD_path
+        )
+
+        for space in self.spaces:
+            name = self.spaces[space].name
+            schema = self.spaces[space].schema
+            schema = ["{}={}".format(x, schema[x].original_type_name) for x in schema]
+            if len(schema) >= 1:
+                schema = ", ".join(schema) + ","
+                out += 'generate_space_type(({}), "{}")'.format(schema, name)
+                out += "\n"
+            # out += "{} = Spaces.{}".format(name, name)
+
+        with open(path, "w") as f:
+            f.write(out)
+
+    def build_implementation(self, params):
+        return MathSpecImplementation(self, params)
+
 
 class MathSpecImplementation:
     def __init__(self, ms: MathSpec, params):
         self.ms = deepcopy(ms)
+        self.params = params
+        self.control_actions = self.load_control_actions()
+        self.boundary_actions = {}
+        self.policies = self.load_policies()
+        self.mechanisms = self.load_mechanisms()
+        self.load_wiring()
+
+    def load_control_actions(self):
+        control_actions = {}
+        for ca in self.ms.control_actions:
+            ca = self.ms.control_actions[ca]
+            opts = ca.control_action_options
+            if len(opts) == 0:
+                print("{} has no control action options".format(ca.name))
+            else:
+                if len(opts) == 1:
+                    opt = opts[0]
+                else:
+                    assert (
+                        "FP {}".format(ca.name) in self.params
+                    ), "No functional parameterization for {}".format(ca.name)
+                    opt = self.ms.functional_parameters["FP {}".format(ca.name)][
+                        self.params["FP {}".format(ca.name)]
+                    ]
+
+                assert (
+                    "python" in opt.implementations
+                ), "No python implementation for {} / {}".format(ca.name, opt.name)
+
+                control_actions[ca.name] = opt.implementations["python"]
+        return control_actions
+
+    def load_mechanisms(self):
+        mechanisms = {}
+        for m in self.ms.mechanisms:
+            m = self.ms.mechanisms[m]
+            if "python" not in m.implementations:
+                print("No python implementation for {}".format(m.name))
+            else:
+                mechanisms[m.name] = m.implementations["python"]
+        return mechanisms
+
+    def load_single_wiring(self, wiring):
+        components = [x.name for x in wiring.components]
+        if wiring.block_type == "Stack Block":
+
+            def wiring(state, params, spaces):
+                for component in components:
+                    spaces = self.blocks[component](state, params, spaces)
+                return spaces
+
+        elif wiring.block_type == "Parallel Block":
+
+            spaces_mapping = {}
+            for x in wiring.components:
+                spaces_mapping[x.name] = []
+
+            for i, x in enumerate([x.name for x in wiring.domain_blocks]):
+                spaces_mapping[x].append(i)
+
+            def wiring(state, params, spaces):
+                codomain = []
+                for component in components:
+                    spaces_i = [spaces[i] for i in spaces_mapping[component]]
+                    spaces_i = self.blocks[component](state, params, spaces_i)
+                    if spaces_i:
+                        codomain.extend(spaces_i)
+                return codomain
+
+        else:
+            assert False
+
+        return wiring
+
+    def load_policies(self):
+        policies = {}
+        for p in self.ms.policies:
+            p = self.ms.policies[p]
+            opts = p.policy_options
+            if len(opts) == 0:
+                print("{} has no policy options".format(p.name))
+            else:
+                if len(opts) == 1:
+                    opt = opts[0]
+                else:
+                    assert (
+                        "FP {}".format(p.name) in self.params
+                    ), "No functional parameterization for {}".format(p.name)
+                    opt = self.ms.functional_parameters["FP {}".format(p.name)][
+                        self.params["FP {}".format(p.name)]
+                    ]
+
+                if "python" not in opt.implementations:
+                    print(
+                        "No python implementation for {} / {}".format(p.name, opt.name)
+                    )
+                else:
+                    policies[p.name] = opt.implementations["python"]
+        return policies
+
+    def load_wiring(
+        self,
+    ):
+        self.blocks = {}
+        self.blocks.update(self.boundary_actions)
+        self.blocks.update(self.control_actions)
+        self.blocks.update(self.policies)
+        self.blocks.update(self.mechanisms)
+
+        self.wiring = {}
+
+        wiring = [x for x in self.ms.wiring.values()]
+
+        i = 1
+        while i > 0:
+            i = 0
+            hold = []
+            for w in wiring:
+                components = [x.name for x in w.components]
+                if all([x in self.blocks for x in components]):
+                    i += 1
+                    w2 = self.load_single_wiring(w)
+                    assert w.name not in self.blocks, "{} was a repeated block".format(
+                        w.name
+                    )
+                    if w2:
+                        self.blocks[w.name] = w2
+                        self.wiring[w.name] = w2
+
+                else:
+                    hold.append(w)
+            wiring = hold
+        if len(wiring) > 0:
+            wiring = [x.name for x in wiring]
+            print("The following wirings were not loading: {}".format(wiring))

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/Classes/State.py

@@ -45,6 +45,7 @@ class StateVariable:
         self.symbol = data["symbol"]
         self.domain = data["domain"]
         self.updated_by = []
+        self.metadata = data["metadata"]
 
         # Add check for type of List
         if hasattr(self.type, "_name"):

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/Load/metrics.py

@@ -100,5 +100,9 @@ def load_metrics(ms: Dict, json: Dict, stateful_metrics_map) -> None:
         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])
+            assert (
+                x in ms["Metrics"] or x in stateful_metrics_map
+            ), "{} not a valid metric or stateful metric".format(x)
+            policy.metrics_used.append(
+                ms["Metrics"][x] if x in ms["Metrics"] else stateful_metrics_map[x]
+            )

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/Load/states.py

@@ -27,6 +27,8 @@ def convert_state(ms, data: Dict) -> State:
         check_json_keys(var, "State Variable")
         assert var["type"] in ms["Types"], "Type not in ms"
         var["type"] = ms["Types"][var["type"]]
+        if "metadata" not in var:
+            var["metadata"] = {}
         new_variables.append(StateVariable(var))
     data["variables"] = new_variables
 

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/Load/type.py

@@ -111,6 +111,9 @@ def load_julia_type_key(path):
         elif x.startswith("struct"):
             name = name[7:]
             name = name[: name.index("\n")].strip()
+        if x.startswith("const"):
+            name = name[6:]
+            name = name[: name.index("=")].strip()
         else:
             assert False
 

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/Reports/html.py

@@ -152,7 +152,10 @@ cssclasses:
         else:
             out += symbol2 + name + "\n"
         for var in ms.state[name].variable_map.keys():
-            out += symbol3 + var + "\n"
+            if linking:
+                out += symbol3 + "[[{}-{}\|{}]]".format(name, var, var) + "\n"
+            else:
+                out += symbol3 + var + "\n"
 
     out += symbol1 + "**Stateful Metrics**\n"
     for name in ms.stateful_metrics.keys():

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/Reports/markdown.py

@@ -145,7 +145,7 @@ def write_boundary_action_markdown_report(ms, path, boundary_action, add_metadat
         out += "\n"
     out += "\n"
 
-    out += "## Constraints"
+    out += "## Constraints\n"
     for i, x in enumerate(boundary_action.constraints):
         out += "{}. {}".format(i + 1, x)
         out += "\n"
@@ -179,6 +179,8 @@ def write_policy_markdown_report(ms, path, policy, add_metadata=True):
     policy = ms.policies[policy]
     if "Policies" not in os.listdir(path):
         os.makedirs(path + "/Policies")
+
+    out = ""
     if add_metadata:
         metadata = policy.metadata
         if len(metadata) > 0:
@@ -188,7 +190,7 @@ def write_policy_markdown_report(ms, path, policy, add_metadata=True):
 """.format(
                 "\n".join(["{}: {}".format(x, metadata[x]) for x in metadata])
             )
-    out = ""
+
     out += "## Description"
     out += "\n"
     out += "\n"
@@ -292,7 +294,9 @@ def write_mechanism_markdown_report(ms, path, mechanism, add_metadata=True):
     out += "\n\n"
     out += "## Updates\n\n"
     for i, x in enumerate(mechanism.updates):
-        out += "{}. [[{}]].{}".format(i + 1, x[0].name, x[1].name)
+        out += "{}. [[{}]].[[{}|{}]]".format(
+            i + 1, x[0].name, x[0].state.name + "-" + x[1].name, x[1].name
+        )
         out += "\n"
 
     with open("{}/Mechanisms/{}.md".format(path, mechanism.label), "w") as f:
@@ -472,8 +476,14 @@ def write_wiring_markdown_report(ms, path, wiring, add_metadata=True):
     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 += "{}. [[{}]].[[{}|{}]]".format(
+            i + 1,
+            x[0].name,
+            ms.entities[x[0].name].state.name + "-" + x[1].name,
+            x[1].name,
+        )
         out += "\n"
     out += "\n"
 
@@ -608,6 +618,45 @@ def write_displays_markdown_reports(ms, path, add_metadata=True):
         )
 
 
+def write_state_variables_markdown_reports(ms, path, state, add_metadata=True):
+    if "State Variables" not in os.listdir(path):
+        os.makedirs(path + "/State Variables")
+    state = ms.state[state]
+    for variable in state.variables:
+        out = ""
+        if add_metadata:
+            metadata = variable.metadata
+            if len(metadata) > 0:
+                out += """---
+        {}
+---
+""".format(
+                    "\n".join(["{}: {}".format(x, metadata[x]) for x in metadata])
+                )
+        out += "Description: "
+        out += variable.description
+        out += "\n\n"
+        out += "Type: [["
+        out += variable.type.name
+        out += "]]\n\n"
+        out += "Symbol: "
+        if variable.symbol:
+            out += variable.symbol
+        out += "\n\n"
+        out += "Domain: "
+        if variable.domain:
+            out += variable.domain
+        out += "\n\n"
+
+        with open(
+            "{}/State Variables/{}.md".format(
+                path, "{}-{}".format(state.name, variable.name)
+            ),
+            "w",
+        ) as f:
+            f.write(out)
+
+
 def write_wiring_display_markdown_report(ms, path, wiring, add_metadata=True):
     wirings = [ms.wiring[w] for w in wiring["components"]]
     out = ""
@@ -696,6 +745,7 @@ def write_all_markdown_reports(ms, path, clear_folders=False):
     states = list(ms.state.keys())
     for x in states:
         write_state_markdown_report(ms, path, x)
+        write_state_variables_markdown_reports(ms, path, x)
 
     # Write types
     for t in ms.types.values():

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/Reports/state.py

@@ -51,6 +51,8 @@ def write_state_variable_table_markdown(target_state, links=False):
             if tv:
                 if links and i == 2:
                     table += "[[{}]]".format(tv)
+                elif links and i == 0:
+                    table += "[[{}-{}\|{}]]".format(target_state.name, tv, tv)
                 else:
                     table += "{}".format(tv)
             table += "|"

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1}/src/math_spec_mapping/schema.schema.json

@@ -360,7 +360,8 @@
                         "type": "string"
                     },
                     "description": "All metrics used in implementation of policies"
-                }
+                },
+                "metadata": {"type": "object"}
             },
             "required": [
                 "codomain",
@@ -390,7 +391,8 @@
                 "logic": {
                     "type": "string",
                     "description": "Any logic associated with the implementation"
-                }
+                },
+                "metadata": {"type": "object"}
             },
             "required": [
                 "description",
@@ -561,7 +563,8 @@
                 "domain": {
                     "type": ["string","null"],
                     "description": "The mathematical domain of the parameter (optional)"
-                }
+                },
+                "metadata": {"type": "object"}
             },
             "required": [
                 "description",

{math-spec-mapping-0.2.8 → math_spec_mapping-0.3.1/src/math_spec_mapping.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.2.8
+Version: 0.3.1
 Summary: A library for easy mapping of mathematical specifications.
 Author-email: Sean McOwen <Sean@Block.Science>
 Classifier: Programming Language :: Python :: 3