math-spec-mapping 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

math_spec_mapping/Classes/MathSpec.py

@@ -5,6 +5,7 @@ from .Mechanism import Mechanism
 from .ControlAction import ControlAction
 from .BoundaryAction import BoundaryAction
 import os
+from copy import deepcopy
 
 
 class MathSpec:
@@ -41,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:
@@ -352,6 +355,56 @@ class MathSpec:
             sm.extend([x.name for x in metrics.metrics])
         return sm
 
+    def _build_functional_parameters(self):
+        opts = [
+            (x, x.policy_options)
+            for x in self.policies.values()
+            if len(x.policy_options) > 1
+        ]
+        opts.extend(
+            [
+                (x, x.boundary_actions)
+                for x in self.boundary_actions.values()
+                if len(x.boundary_action_options) > 1
+            ]
+        )
+        opts.extend(
+            [
+                (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:
+            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 = {}
+        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:
@@ -447,3 +500,248 @@ class MathSpec:
 
         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)
+
+    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/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/Reports/markdown.py

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

math_spec_mapping/schema.schema.json

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

{math_spec_mapping-0.2.7.dist-info → math_spec_mapping-0.3.0.dist-info}/METADATA

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

@@ -1,12 +1,12 @@
 math_spec_mapping/__init__.py,sha256=k5KVhqX1_iIkGjTBHAHezWUeh0b3ilWpJaSIVSbKMcg,907
 math_spec_mapping/schema.py,sha256=6mrRqzEnTTSXjb19xJ63MBp0KjKH0s7i6TfT4MkAY9k,233
-math_spec_mapping/schema.schema.json,sha256=E8-TQIiv7AjIMXnAIB84z_O4cMLfGuDmDCFCoIlwQz0,27174
+math_spec_mapping/schema.schema.json,sha256=DTrPuYbA-n27jatLt2h76WgMm7pWVgkFwC3zGDnlptQ,29208
 math_spec_mapping/Classes/ActionTransmissionChannel.py,sha256=zWMo5QsgPh5WGIWXl-xOrZNMXYJXmK6Vejw1dQvi0og,246
 math_spec_mapping/Classes/Block.py,sha256=hXQO221IP-TqZm_TwFKfURpEEjZm7L1TPZDCYlaOdho,17302
 math_spec_mapping/Classes/BoundaryAction.py,sha256=AOENCqCEfpjotnHhzUj_F2SOP0SGpkN1tNPr8Mtl6Tc,476
 math_spec_mapping/Classes/ControlAction.py,sha256=ysqpgANwdizVdwqtgZmnxXMpCqrzmVEF_6YT0M3l4Ho,526
 math_spec_mapping/Classes/Entity.py,sha256=fA0-b128_OHHxfCg4pzqyQV083EYev1HlVpy86S5igg,1226
-math_spec_mapping/Classes/MathSpec.py,sha256=eweFUB8iuEI5Y-9VOULbAWbIeHd18Iw-I_VPUjvnn0E,16999
+math_spec_mapping/Classes/MathSpec.py,sha256=FTxArDTLt7PBwXE79VqhP7qIA4Gf6zgXAo_iQWOh_7U,27443
 math_spec_mapping/Classes/Mechanism.py,sha256=2sLm3wYBIeTQaMBcsJ9btqIWsbS895Ra8NY6Y9_G_Dg,379
 math_spec_mapping/Classes/Metric.py,sha256=AhPgYppOP6q49xvR8S9STxQsXUKJlTWx7wI1LfZEtww,581
 math_spec_mapping/Classes/Parameter.py,sha256=ZuJ_w0sChvRElJ4sOnXZ2EV4Ell2xXFulKLjVOpgz2E,1237
@@ -16,7 +16,7 @@ math_spec_mapping/Classes/State.py,sha256=0gJHHTNjTrz1fL2K-yPu-dJlaCsU_NMxClw6ne
 math_spec_mapping/Classes/StateUpdateTransmissionChannel.py,sha256=3hBLvD1lE64PkwqksBXAfFWv7foOZzGQLAFQWy42tOA,257
 math_spec_mapping/Classes/StatefulMetric.py,sha256=UCis1BJ7fsajHHxFF05ZiyDean2D4s4a95uYYW1Mjq4,749
 math_spec_mapping/Classes/Type.py,sha256=2KFY8d3cv1PzJJ7SSMHJf1zcfQ3ZbqxotK2KgTaLZdM,289
-math_spec_mapping/Classes/__init__.py,sha256=_hXyZMJanmIex_W6yCR2H7Jw8iU2JJIf3U7VcvBSOGU,737
+math_spec_mapping/Classes/__init__.py,sha256=0zxgOqns_9JybD74HKMVh6aw8ij8WVbfQ4Q_1uWzof0,761
 math_spec_mapping/Convenience/__init__.py,sha256=-hNZVoaNSgTmZTiyZoMfWyg14xonC3ppz-diQk1VlUY,60
 math_spec_mapping/Convenience/documentation.py,sha256=Jf7-JJIk_vZkNBIGV4bs5LM3B0RVaCCtuwJ164thGfY,1607
 math_spec_mapping/Convenience/starter.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -44,7 +44,7 @@ math_spec_mapping/Reports/boundary_actions.py,sha256=45BPp4QjWdD-3E9ZWwqgj_nI2-Y
 math_spec_mapping/Reports/control_actions.py,sha256=NksekZKIPFSIkubttFstKFthc5AU9B9PWRLSl9j1wWs,1216
 math_spec_mapping/Reports/general.py,sha256=WOOn6Wlb8M4fsdN49FlKLwOka6vJPQ9aCUy88TL2ki0,1610
 math_spec_mapping/Reports/html.py,sha256=xf5jk3DHWg4CfZHZuF2JK5iZ515ecjDShJJsahiqb4g,8882
-math_spec_mapping/Reports/markdown.py,sha256=pDGHYMdtZmeXHqvU9FB3BycyB4qflWXq0bf2m-wsXMU,21138
+math_spec_mapping/Reports/markdown.py,sha256=eJidreiLmfUznoq_-C4IsFTZ__Bka-PWLKjKYn6bhmw,21113
 math_spec_mapping/Reports/mechanisms.py,sha256=d2Rxt3JBYvqAOAYUynl0buYVoXEHrO8EGq7GK6hK8NA,1322
 math_spec_mapping/Reports/node_map.py,sha256=FdSMDQG16NX6n9sZcH-T5xwsvgjrV9OqBHc9J_VlNK0,3129
 math_spec_mapping/Reports/parameters.py,sha256=yizNG4lNGrgrlzYYcHMGfXKDFlPw4PMDYshDqZ3YARs,535
@@ -53,8 +53,8 @@ math_spec_mapping/Reports/spaces.py,sha256=-76hR5wQBv4lsG000ypBJ-OprjsNjI-rNRMYd
 math_spec_mapping/Reports/state.py,sha256=RSHDjzSiUj4ZjReWbkBW7k2njs3Ovp-q0rCC7GBfD-A,2203
 math_spec_mapping/Reports/tables.py,sha256=O0CNuqh3LMECq5uLjBOoxMUk5hUvkUK660FNnwWUxDY,1505
 math_spec_mapping/Reports/wiring.py,sha256=u9SvKWy6T-WJUEgFI6-zgZanoOaTTs_2YwmEceDLsV8,1618
-math_spec_mapping-0.2.7.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
-math_spec_mapping-0.2.7.dist-info/METADATA,sha256=H3plPQQrT7sss_57Z2341oAlBkMpW7_QHihqFoZcgUM,6012
-math_spec_mapping-0.2.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-math_spec_mapping-0.2.7.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
-math_spec_mapping-0.2.7.dist-info/RECORD,,
+math_spec_mapping-0.3.0.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
+math_spec_mapping-0.3.0.dist-info/METADATA,sha256=Vc8ZOoyIufYp8gQkctaAbFV6cuSPNQnOWZw2SaYJXPI,6012
+math_spec_mapping-0.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+math_spec_mapping-0.3.0.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
+math_spec_mapping-0.3.0.dist-info/RECORD,,