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

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

@@ -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 → math-spec-mapping-0.2.8}/pyproject.toml

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

{math-spec-mapping-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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-0.2.6.7 → math-spec-mapping-0.2.8}/src/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 → math-spec-mapping-0.2.8/src/math_spec_mapping.egg-info}/PKG-INFO

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