math-spec-mapping 0.2.6.6__tar.gz → 0.2.7__tar.gz

{math-spec-mapping-0.2.6.6/src/math_spec_mapping.egg-info → math-spec-mapping-0.2.7}/PKG-INFO

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

@@ -3,7 +3,7 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "math-spec-mapping"
-version = "0.2.6.6"
+version = "0.2.7"
 authors = [
   { name="Sean McOwen", email="Sean@Block.Science" },
 ]
@@ -26,4 +26,7 @@ include-package-data = true
 package-dir = { "" = "src" }
 
 [tool.setuptools.packages.find]
-where = ["src"]
+where = ["src"]
+
+[tool.setuptools.package-data]
+'math_spec_mapping' = ['*.json']

{math-spec-mapping-0.2.6.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/src/math_spec_mapping/Classes/MathSpec.py

@@ -4,6 +4,7 @@ from .Policy import Policy
 from .Mechanism import Mechanism
 from .ControlAction import ControlAction
 from .BoundaryAction import BoundaryAction
+import os
 
 
 class MathSpec:
@@ -12,6 +13,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"]
@@ -349,3 +351,99 @@ class MathSpec:
         for metrics in self.stateful_metrics.values():
             sm.extend([x.name for x in metrics.metrics])
         return sm
+
+    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)

{math-spec-mapping-0.2.6.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.6 → math-spec-mapping-0.2.7}/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.7/src/math_spec_mapping/schema.schema.json

@@ -0,0 +1,753 @@
+{
+    "$schema": "http://json-schema.org/draft-06/schema#",
+    "$ref": "./schema.schema.json/#/definitions/MSMLSpec",
+    "title": "MSML",
+    "$id": "https://github.com/BlockScience/MSML/src/schema.schema.json",
+    "definitions": {
+        "MSMLSpec": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "Policies": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Policy"
+                    }
+                },
+                "Spaces": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Space"
+                    }
+                },
+                "State": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/State"
+                    }
+                },
+                "Stateful Metrics": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/StatefulMetric"
+                    }
+                },
+                "Parameters": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Parameter"
+                    }
+                },
+                "Mechanisms": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Mechanism"
+                    }
+                },
+                "Entities": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Entity"
+                    }
+                },
+                "Boundary Actions": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/BoundaryAction"
+                    }
+                },
+                "Control Actions": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/ControlAction"
+                    }
+                },
+                "Wiring": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Wiring"
+                    }
+                },
+                "Types": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Type"
+                    }
+                },
+                "Metrics": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Metric"
+                    }
+                },
+                "Displays": {"type": "object",
+                "additionalProperties": false,
+                "properties": {
+                    "wiring": {
+                        "type": "array",
+                        "items": {
+                            "$ref": "./schema.schema.json/#/definitions/WiringDisplay"
+                        }
+                    }
+                },
+                "required": [
+                    "wiring"
+                ]}
+            },
+            "required": [
+                "Boundary Actions",
+                "Control Actions",
+                "Entities",
+                "Mechanisms",
+                "Parameters",
+                "Policies",
+                "Spaces",
+                "State",
+                "Stateful Metrics",
+                "Types",
+                "Wiring",
+                "Metrics"
+            ],
+            "title": "MSMLSpec",
+            "description": "A JSON schema that is used in the mathematical specification mapping library to create the underlying MSML object."
+        },
+        "ControlAction": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "constraints": {
+                    "type": "array",
+                    "items": {}
+                },
+                "control_action_options": {
+                    "type": "array",
+                    "items": {}
+                },
+                "codomain": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "parameters_used": {
+                    "type": "array",
+                    "items": {"type": "string"}
+                }
+            },
+            "required": [
+                "codomain",
+                "constraints",
+                "control_action_options",
+                "description",
+                "name",
+                "parameters_used"
+            ],
+            "title": "ControlAction",
+            "description": "The definition of actions that the system might call, such as an action to refill the stock of an item when reserves run too low or something that could get triggered from a sensor. The key differentiator from boundary actions is that there is no entity calling it and it is not done with randomness."
+        },
+        "Entity": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "The name of the entity"
+                },
+                "notes": {
+                    "type": "string",
+                    "description": "Any notes on the entity"
+                },
+                "state": {
+                    "type": "string",
+                    "description": "The string key for the state associated with the entity"
+                },
+                "metadata": {"type": "object"}
+            },
+            "required": [
+                "name",
+                "notes",
+                "state"
+            ],
+            "title": "Entity",
+            "description": "Entities are any class of user or infrastructure that should have their own state and potentially ability to call boundary actions. Examples could be a customer or a company (for which a simulation might assume it is acting as one cohesive unit)"
+        },
+        "Mechanism": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "The name of the mechanism"
+                },
+                "description": {
+                    "type": "string",
+                    "description": "The description of what the mechanism does"
+                },
+                "constraints": {
+                    "type": "array",
+                    "description": "Any constraints which the mechanism must respect",
+                    "items": {"type": "string"}
+                },
+                "logic": {
+                    "type": "string",
+                    "description": "The logic of how the mechanism should work"
+                },
+                "domain": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "The spaces which are the input into the mechanism"
+                },
+                "parameters_used": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "The string keys of parameters which have an effect on the mechanism"
+                },
+                "updates": {
+                    "type": "array",
+                    "items": {
+                        "items": {
+                            "$ref": "./schema.schema.json/#/definitions/Update"
+                        }
+                    },
+                    "description": "The states updates that the mechanism causes in the form of (Entity, State Variable)"
+                },
+                "metadata": {"type": "object",
+            "description": "Any metadata that is added onto the mechanism"}
+            },
+            "required": [
+                "constraints",
+                "description",
+                "domain",
+                "logic",
+                "name",
+                "parameters_used",
+                "updates"
+            ],
+            "title": "Mechanism",
+            "description": "Anything that updates state in the system, usually policies will call these with the outputs of logic. The reasoning to split them out is so that if at some point you want to add a recording variable every time an account is changed or do something like have a variable listener, you can just change the mechanism responsible for it in only one place."
+        },
+        "Parameter": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "The name of the parameter set"
+                },
+                "notes": {
+                    "type": "string",
+                    "description": "Any notes about the parameter set"
+                },
+                "parameters": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/ParameterElement"
+                    },
+                    "description": "All parameters that are a part of this parameter set"
+                }
+            },
+            "required": [
+                "name",
+                "notes",
+                "parameters"
+            ],
+            "title": "Parameter",
+            "description": "Both local and global parameter sets in the system that could be set"
+        },
+        "ParameterElement": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "variable_type": {
+                    "type": "string",
+                    "description": "The type of that the parameter takes."
+                },
+                "name": {
+                    "type": "string",
+                    "description": "The unique name of the parameter"
+                },
+                "description": {
+                    "type": "string",
+                    "description": "The description of the parameter"
+                },
+                "symbol": {
+                    "type": ["string","null"],
+                    "description": "The symbol associated with the parameter (optional)"
+                },
+                "domain": {
+                    "type": ["string","null"],
+                    "description": "The mathematical domain of the parameter (optional)"
+                },
+                "parameter_class": {
+                    "type": "string",
+                    "description": "The type of paramter this is, of which the options are system (what you would find in production code of a system), behavioral (for what kinds of behavioral assumptions and distributions there are), and functional (for defining out different functional forms such as swapping in and out policies)"
+                }
+            },
+            "required": [
+                "description",
+                "domain",
+                "name",
+                "parameter_class",
+                "symbol",
+                "variable_type"
+            ],
+            "title": "ParameterElement"
+        },
+        "Policy": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "constraints": {
+                    "type": "array",
+                    "items": {}
+                },
+                "policy_options": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/PolicyOption"
+                    }
+                },
+                "domain": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "codomain": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "parameters_used": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "metrics_used": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "codomain",
+                "constraints",
+                "description",
+                "domain",
+                "name",
+                "parameters_used",
+                "policy_options",
+                "metrics_used"
+            ],
+            "title": "Policy",
+            "description": "A definition of the policies that handle all logical things. This could be, for example, a policy which determines what price is paid given a boundary action of someone putting in a market buy order for a stock."
+        },
+        "PolicyOption": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "logic": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "description",
+                "logic",
+                "name"
+            ],
+            "title": "PolicyOption",
+            "description": "The concrete possible implementations that a given policy block can reference or select"
+        },
+        "Space": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "schema": {
+                    "$ref": "./schema.schema.json/#/definitions/Schema"
+                }
+            },
+            "required": [
+                "name",
+                "schema"
+            ],
+            "title": "Space",
+            "description": "Spaces are similar to types in that they define a schema for data and are used as the domain/codomain for different blocks. They can be thought of as typed dictionaries."
+        },
+        "StatefulMetric": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "The name of the stateful metric set"
+                },
+                "notes": {
+                    "type": "string",
+                    "description": "Any notes about the stateful metric set"
+                },
+                "metrics": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/StatefulMetricVar",
+                        "description": "All the attatched stateful metrics"
+                    }
+                }
+            },
+            "required": [
+                "metrics",
+                "name",
+                "notes"
+            ],
+            "title": "Stateful Metric",
+            "description": "Variables that are not held directly in the state but can computed from the state & parameters."
+        },
+        "BoundaryAction": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "constraints": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "boundary_action_options": {
+                    "type": "array",
+                    "items": {}
+                },
+                "called_by": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "codomain": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "parameters_used": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "boundary_action_options",
+                "called_by",
+                "codomain",
+                "constraints",
+                "description",
+                "name",
+                "parameters_used"
+            ],
+            "title": "Boundary Action",
+            "description": "The definition of different actions that might happen outside of the system such as customers coming into a shop. Generally will be called by entities."
+        },
+        "Schema": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": [],
+            "title": "Schema"
+        },
+        "State": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Any notes about the state or its implementation"
+                },
+                "notes": {
+                    "type": "string",
+                    "description": "The name of the state"
+                },
+                "variables": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "./schema.schema.json/#/definitions/Variable"
+                    },
+                    "description": "All the attatched state variables for the component"
+                }
+            },
+            "required": [
+                "name",
+                "notes",
+                "variables"
+            ],
+            "title": "State",
+            "description": "The definition of states in the system. There is one global system state and then the rest of the definitions are local states, generally for recording what entity states there are."
+        },
+        "Variable": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "type": {
+                    "type": "string",
+                    "description": "The type of the variable"
+                },
+                "name": {
+                    "type": "string",
+                    "description": "Variable name"
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Description of what the variable is"
+                },
+                "symbol": {
+                    "type": ["string","null"],
+                    "description": "The symbol associated with the parameter (optional)"
+                },
+                "domain": {
+                    "type": ["string","null"],
+                    "description": "The mathematical domain of the parameter (optional)"
+                }
+            },
+            "required": [
+                "description",
+                "domain",
+                "name",
+                "symbol",
+                "type"
+            ],
+            "title": "Variable"
+        },
+        "Type": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "type": {
+                    "type": "string"
+                },
+                "notes": {
+                    "type": "string"
+                },
+                "metadata": {"type": "object"}
+            },
+            "required": [
+                "name",
+                "notes",
+                "type"
+            ],
+            "title": "Type",
+            "description": "This is for defining what a type might in its most basic form. These could be single typings or compound typings. The point here is to allow for changing typing in one single place and having it flow through anywhere else. I.e. if one were to define the currency type as USD, but then the project switched to using EUR, it would just require changing currency to be EUR."
+        },
+        "Metric": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "type": {
+                    "type": "string"
+                },
+                "name": {
+                    "type": "string"
+                },
+                "description": {
+                    "type": "string"
+                },
+                "variables_used": {
+                    "type": "array",
+                    "items": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        }
+                    }
+                },
+                "parameters_used": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "metrics_used": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "domain": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "logic": {
+                    "type": "string"
+                },
+                "symbol": {
+                    "type": ["string", "null"]
+                }
+            },
+            "required": [
+                "description",
+                "domain",
+                "logic",
+                "name",
+                "parameters_used",
+                "symbol",
+                "type",
+                "variables_used",
+                "metrics_used"
+            ],
+            "title": "Metric",
+            "description": "This component takes a variety of potential inputs and creates a metric from it. This can be used for defining out system success metrics or trying to modularize certain calculations that are needed across many other system components."
+        },
+        "Wiring": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "components": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "description": {
+                    "type": "string"
+                },
+                "constraints": {
+                    "type": "array",
+                    "items": {}
+                },
+                "type": {
+                    "$ref": "./schema.schema.json/#/definitions/TypeEnum"
+                },
+                "mermaid_show_name": {
+                    "type": "boolean"
+                },
+                "loop": {
+                    "type": "boolean"
+                },
+                "optional_indices": {
+                    "type": "array",
+                    "items": {
+                        "type": "integer"
+                    }
+                }
+            },
+            "required": [
+                "components",
+                "constraints",
+                "description",
+                "name",
+                "type"
+            ],
+            "title": "Wiring",
+            "description": "A wiring is a block composed of other blocks with specific behaviors or orders of execution. For instance, there can be wirings that have blocks run one after another, passing their codomains to the next block's domain. There can also be wirings for blocks that all should run in parallel."
+        },
+        "Update": {
+            "title": "Update"
+        },
+        "TypeEnum": {
+            "type": "string",
+            "enum": [
+                "Parallel",
+                "Stack"
+            ],
+            "title": "TypeEnum"
+        },
+        "WiringDisplay": {"type": "object",
+        "additionalProperties": false,
+        "properties": {
+            "name": {
+                "type": "string"
+            },
+            "description": {
+                "type": "string"
+            },
+            "components": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                }
+            }
+        },
+        "required": [
+            "components",
+            "name",
+            "description"
+        ]},
+        "StatefulMetricVar": {"type": "object",
+        "additionalProperties": false,
+        "properties": {
+            "type": {
+                "type": "string",
+                "description": "The type of the metric variable"
+            },
+            "name": {
+                "type": "string",
+                "description": "The name of the stateful metric variable"
+            },
+            "description": {
+                "type": "string",
+                "description": "The description of the computation"
+            },
+            "variables_used": {
+                "type": "array",
+                "items": {
+
+                },
+                "description": "The variables used for computation of the form (state, variable)"
+            },
+            "parameters_used": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "description": "The string keys of parameters which are used in the metric calculation"
+                }
+            },
+            "symbol": {
+                "type": ["string","null"],
+                "description": "The symbol associated with the stateful metric (optional)"
+            },
+            "domain": {
+                "type": ["string","null"],
+                "description": "The mathematical domain of the stateful metric (optional)"
+            }
+        }
+    }
+}
+}

{math-spec-mapping-0.2.6.6 → math-spec-mapping-0.2.7/src/math_spec_mapping.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: math-spec-mapping
-Version: 0.2.6.6
+Version: 0.2.7
 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.6 → math-spec-mapping-0.2.7}/src/math_spec_mapping.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 src/math_spec_mapping/__init__.py
 src/math_spec_mapping/schema.py
+src/math_spec_mapping/schema.schema.json
 src/math_spec_mapping.egg-info/PKG-INFO
 src/math_spec_mapping.egg-info/SOURCES.txt
 src/math_spec_mapping.egg-info/dependency_links.txt