math-spec-mapping 0.2.8__py3-none-any.whl → 0.3.1__py3-none-any.whl

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/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/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/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/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/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/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/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/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.dist-info → math_spec_mapping-0.3.1.dist-info}/METADATA

@@ -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.dist-info → math_spec_mapping-0.3.1.dist-info}/RECORD

@@ -1,18 +1,18 @@
 math_spec_mapping/__init__.py,sha256=k5KVhqX1_iIkGjTBHAHezWUeh0b3ilWpJaSIVSbKMcg,907
 math_spec_mapping/schema.py,sha256=6mrRqzEnTTSXjb19xJ63MBp0KjKH0s7i6TfT4MkAY9k,233
-math_spec_mapping/schema.schema.json,sha256=DTrPuYbA-n27jatLt2h76WgMm7pWVgkFwC3zGDnlptQ,29208
+math_spec_mapping/schema.schema.json,sha256=gvKfsWNuxnwdwtLCdQPi4GYno_QfZfRNo86ThNUckF0,29352
 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=gzTi7QSsFEWPTfHaz8YU0R7X5g4rVDFFBlKdBj4B0Pk,22244
+math_spec_mapping/Classes/MathSpec.py,sha256=KEk7oUs21YznNmsdCUtldpOl7p-rwFmpZcolVNHlaTo,28854
 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
 math_spec_mapping/Classes/Policy.py,sha256=fzV85tB3QScjiYGfhw_dyQt9L1BYYfTyTIQQcxeT8ac,530
 math_spec_mapping/Classes/Space.py,sha256=QsahxoUfRsDWQLBL683KnGx72MAmRxv7CDE7TMgCG-E,472
-math_spec_mapping/Classes/State.py,sha256=0gJHHTNjTrz1fL2K-yPu-dJlaCsU_NMxClw6neDv6gE,1497
+math_spec_mapping/Classes/State.py,sha256=2Yn4wQnbBK-Au40tx5YHR8ZsLA7NHHbWvVPjDzU6Tq0,1538
 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
@@ -30,31 +30,31 @@ math_spec_mapping/Load/general.py,sha256=2q6aGKxXhebiHHTZhtACvM4nWIkTben0o5rXuvf
 math_spec_mapping/Load/implementations.py,sha256=SGKZ_YXeNpJUTnw5fajQTXji7S2bNQo8sh-7YcIO6pk,395
 math_spec_mapping/Load/load.py,sha256=CLprDhJpbwm9RAzKM2Ghwr8eqBu0a-wvGDOCMmc01YE,2484
 math_spec_mapping/Load/mechanism.py,sha256=JBy-QpB4W0Z2OcNiakONjD4_RtEgxlFKtLXfDqfhR-0,2037
-math_spec_mapping/Load/metrics.py,sha256=gD68mt0Y5jSgofZUwscV8PFatOMV_LPwYyPrwV9SdtE,3273
+math_spec_mapping/Load/metrics.py,sha256=EyCFEgHpyffBPKaqISdIeTyqUtPtu2xoS0gZjh-6i3U,3434
 math_spec_mapping/Load/parameters.py,sha256=aid_vqYub9643s82NDtMAXLRdV9BPQkri5MadA0L0eQ,1334
 math_spec_mapping/Load/policy.py,sha256=HvlhGHGJTweVs7DOI2HSL_2_diECr8ukDUmzoFLQELo,2444
 math_spec_mapping/Load/spaces.py,sha256=7zgGA57Te7T4hfuCCDElffiidWgn1lKm5E14e1yjt8M,1116
 math_spec_mapping/Load/state_update_transmission_channels.py,sha256=FJWp5n4HdtHAfof5BUQ6BnRakljatL2h8dWCapaVSc0,2238
 math_spec_mapping/Load/stateful_metrics.py,sha256=uGSTc6x6lld5xptgSUMHrO0Vg0QDRIL14C6zTg33S8o,1977
-math_spec_mapping/Load/states.py,sha256=cwo29SBAtj1FoQLEb8c0wkSCn038lIgM9RjNiZefUaE,1223
-math_spec_mapping/Load/type.py,sha256=Wq2EYTofuq4v8_jGGSr23IXJjwavLMjsqSEyhX9VoAM,4217
+math_spec_mapping/Load/states.py,sha256=gAiCGxqc8_js8Gd0aRRrK4PeUW4jgZsgukR6e-5fcg4,1290
+math_spec_mapping/Load/type.py,sha256=wrzT3bmLn2ghvuy8hZhtQZ479HZNntKoLdIC2TcMrgw,4330
 math_spec_mapping/Load/wiring.py,sha256=1dR94U5N1W_WI5rL6lYBltH25ZvApB2pIpq9r5Opkug,3083
 math_spec_mapping/Reports/__init__.py,sha256=W27I6S9Ro1hWeHmnxIokCA06awB__eYey7PvKD4Hc1s,933
 math_spec_mapping/Reports/boundary_actions.py,sha256=45BPp4QjWdD-3E9ZWwqgj_nI2-YdcI2ZZ19_Qv_K7Qk,1410
 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=eJidreiLmfUznoq_-C4IsFTZ__Bka-PWLKjKYn6bhmw,21113
+math_spec_mapping/Reports/html.py,sha256=tqydmwFWz_1Bg_J_avG4t9LtE-DUGbOKAPNuwg6lgRI,9007
+math_spec_mapping/Reports/markdown.py,sha256=r9tHxuGvmwbUy92GVoChqcs7h8pvrGMwXgogAfla4O0,22479
 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
 math_spec_mapping/Reports/policies.py,sha256=EuBzBsTM6QSS_GHFcAyhGgWvDDZwRuKe7Eos9nX13ho,1814
 math_spec_mapping/Reports/spaces.py,sha256=-76hR5wQBv4lsG000ypBJ-OprjsNjI-rNRMYdtsYnjQ,579
-math_spec_mapping/Reports/state.py,sha256=RSHDjzSiUj4ZjReWbkBW7k2njs3Ovp-q0rCC7GBfD-A,2203
+math_spec_mapping/Reports/state.py,sha256=RkqfSonar74KVC8PpA9GgI2xaHX6BrkNdAuWMZlYQfI,2321
 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.8.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
-math_spec_mapping-0.2.8.dist-info/METADATA,sha256=hXBDv_nbuvouVAYXB0jpyKlzNmPFI9xyMjCHn8RvtiE,6012
-math_spec_mapping-0.2.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-math_spec_mapping-0.2.8.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
-math_spec_mapping-0.2.8.dist-info/RECORD,,
+math_spec_mapping-0.3.1.dist-info/LICENSE,sha256=ObyEzSw8kgCaFbEfpu1zP4TrcAKLA0xhqHMZZfyh7N0,1069
+math_spec_mapping-0.3.1.dist-info/METADATA,sha256=dhHFXSeznJ8iViRkPXM7IC0TOFEkuvSVX41dMIzpuT0,6012
+math_spec_mapping-0.3.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+math_spec_mapping-0.3.1.dist-info/top_level.txt,sha256=AImhn9wgazkdV0a9vfiphtQR8uGe2nq-ZIOp-6yUk9o,18
+math_spec_mapping-0.3.1.dist-info/RECORD,,