mathspec 0.1.0__py3-none-any.whl

mathspec/validation.py

@@ -0,0 +1,338 @@
+# SPDX-FileCopyrightText: mathspec Contributors
+#
+# SPDX-License-Identifier: MIT
+
+"""The front door, and the rules a declaration is held to against the others before any expression is read.
+
+:func:`to_spec` reads a model definition into a :class:`~mathspec.model.Spec`.
+:func:`reference_errors` holds the rules one declaration is held to against
+the others — a name declared once, a frame over declared dimensions, a bound
+naming a numeric parameter, a set over one dim of one variable, a curve
+through parameters carrying its breakpoints — which lowering runs before it
+reads any expression, since resolution assumes every one of them.
+:func:`emitted_name_errors` is read off the program instead: what a block's
+expansion writes is decided by the block as lowered. The rules that need a
+typed expression stay with the expressions in :func:`~mathspec.lowering.lower`:
+a macro formal against a dimension, a curve's links, and every dim rule.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+from mathspec._yaml import read_model
+from mathspec.errors import SchemaError
+from mathspec.model import NUMERIC_DTYPES, Spec, side_columns
+from mathspec.operators import BUILTIN_NAMES
+from mathspec.piecewise import Emitted as EmittedCurve
+from mathspec.sos import Emitted as EmittedSet
+from mathspec.sos import coefficients
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+    from pathlib import Path
+
+    from mathspec.program import Program
+
+
+def to_spec(model: str | Path | Mapping[str, object] | Spec) -> Spec:
+    """Load and validate a model definition — the language's front door.
+
+    Everything decidable without data is decided here: schema shape, every
+    rule one declaration is held to against the others, every expression and
+    where string, and every macro template.
+
+    Args:
+        model: A YAML path — a :class:`~pathlib.Path`, or a ``str`` with no
+            newline in it — the YAML text itself as a ``str`` with one, a
+            mapping, or a loaded :class:`Spec`.
+
+    Returns:
+        The schema *as the file declares it*, ``piecewise:`` intact.
+
+    Raises:
+        LanguageError: Anything the language does not accept, a text that is
+            not a mapping of sections included.
+        FileNotFoundError: A ``str`` with no newline that names no file.
+    """
+    if isinstance(model, (list, tuple)):
+        msg = 'a model is one file, one dict or one Spec, never a list of them; merge the declarations into one dict.'
+        raise SchemaError(msg)
+    if isinstance(model, Spec):
+        return model
+    return Spec.model_validate(model if isinstance(model, Mapping) else read_model(model))
+
+
+def emitted_name_errors(schema: Spec, program: Program) -> list[str]:
+    """Every name a set or curve of *program* would write out that *schema* already declares.
+
+    Read off the program rather than the file, since what a curve writes is
+    decided by the curve as lowered — its links, its method, its mask.
+    """
+    by_block = [
+        *((f"Sos '{name}'", EmittedSet.of(name, block.sos_type).by_kind) for name, block in program.sos.items()),
+        *((f"piecewise '{name}'", EmittedCurve.of(name, curve).by_kind) for name, curve in program.piecewise.items()),
+    ]
+    return [error for context, by_kind in by_block for error in _collisions(schema, context, by_kind)]
+
+
+def reference_errors(schema: Spec) -> list[str]:
+    """Every cross-declaration rule *schema* breaks, collected rather than raised on the first."""
+    return [
+        *_name_collisions(schema),
+        *_frame_dimensions(schema),
+        *_relation_targets(schema),
+        *_bound_names(schema),
+        *_sos_shapes(schema),
+        *_sos_bounds(schema),
+        *_piecewise_references(schema),
+    ]
+
+
+def undeclared_dimension(kind: str, name: str, dimension: str) -> str:
+    """The one wording for a declaration naming a dimension the file does not declare."""
+    return f"{kind} '{name}' references undeclared dimension '{dimension}'. Declare it under 'dimensions:'."
+
+
+def _flat_namespace(schema: Spec) -> list[tuple[str, Iterable[str]]]:
+    """Each kind of declaration whose names share the one namespace an expression reads, in declaration order."""
+    return [
+        ('dimension', schema.dimensions),
+        ('relation', schema.relations),
+        ('parameter', schema.parameters),
+        ('variable', schema.variables),
+        ('named expression', schema.expressions),
+        ('macro', schema.macros),
+    ]
+
+
+def _name_collisions(schema: Spec) -> Iterator[str]:
+    """A name is declared once, and never as a built-in operator."""
+    seen: dict[str, str] = {}
+    for kind, group in _flat_namespace(schema):
+        for name in group:
+            if name in BUILTIN_NAMES:
+                yield (
+                    f"{kind.capitalize()} '{name}' collides with the built-in operator "
+                    f"'{name}'. The operator set is closed and its names are reserved; "
+                    f'rename the {kind}.'
+                )
+            if name in seen:
+                yield (
+                    f"{kind.capitalize()} '{name}' collides with the {seen[name]} of "
+                    f'the same name. Names share one flat namespace — rename one of them.'
+                )
+            else:
+                seen[name] = kind
+
+
+def _frame_dimensions(schema: Spec) -> Iterator[str]:
+    """Every frame is a product of distinct, declared dimensions."""
+    frames = [
+        *(('Parameter', name, p.dims) for name, p in schema.parameters.items()),
+        *(('Variable', name, v.dims) for name, v in schema.variables.items()),
+        *(('Constraint', name, c.dims) for name, c in schema.constraints.items()),
+        *(('Named expression', name, e.dims or []) for name, e in schema.expressions.items()),
+    ]
+    for kind, name, dims in frames:
+        yield from (undeclared_dimension(kind, name, d) for d in dims if d not in schema.dimensions)
+        yield from (
+            f"{kind} '{name}' names dimension '{d}' twice. A frame is a product of distinct dimensions."
+            for d, count in Counter(dims).items()
+            if count > 1
+        )
+
+
+def _relation_targets(schema: Spec) -> Iterator[str]:
+    """A relation has at least two columns over declared dimensions, each named once, and a key naming some of them."""
+    for lname, lk in schema.relations.items():
+        if len(lk.pairs) < 2:
+            yield (
+                f"Relation '{lname}' has {len(lk.pairs)} column(s). A relation relates dimensions, so 'key:' and "
+                f"'values:' name at least two between them — a label on one dimension is a parameter over it."
+            )
+        if not lk.key_roles:
+            yield (
+                f"Relation '{lname}' names no key column. A relation is keyed by the columns a row is identified "
+                f"by — name them under 'key:', and leave the columns they determine to 'values:'."
+            )
+        for side, written in (('key', lk.key), ('values', lk.values)):
+            yield from (
+                f"Relation '{lname}' names dimension '{d}' twice under '{side}:'. Give the two columns roles: "
+                f'{side}: {{{d}0: {d}, {d}1: {d}}}.'
+                for d, count in Counter(dim for _, dim in side_columns(written)).items()
+                if count > 1 and not isinstance(written, dict)
+            )
+        yield from (
+            f"Relation '{lname}' names column '{role}' under both 'key:' and 'values:'. A relation names each "
+            f'column once — name the value column after what it holds: values: {{<name>: {dict(lk.pairs)[role]}}}.'
+            for role in dict.fromkeys(lk.key_roles)
+            if role in lk.value_roles
+        )
+        yield from (
+            undeclared_dimension('Relation', lname, d) for d in dict.fromkeys(lk.dims) if d not in schema.dimensions
+        )
+        yield from (
+            f"Relation '{lname}' names column '{role}' after dimension '{role}', but the column is over "
+            f"'{dim}'. A column named like a dimension is read as over it — name it after what it holds."
+            for role, dim in lk.pairs
+            if role in schema.dimensions and role != dim
+        )
+        if lk.value_roles:
+            yield from (
+                f"Relation '{lname}' has two key columns over '{d}' "
+                f'({[k for k in lk.key_roles if dict(lk.pairs)[k] == d]}). A key that determines a value is read '
+                f'its dimensions, and no frame carries a dimension twice — key the table by one column over '
+                f'each, or leave one of them a value column.'
+                for d, count in Counter(dict(lk.pairs)[k] for k in lk.key_roles).items()
+                if count > 1
+            )
+
+
+def _bound_names(schema: Spec) -> Iterator[str]:
+    """A named bound is a numeric parameter."""
+    for vname, vdef in schema.variables.items():
+        for side in ('lower', 'upper'):
+            val = getattr(vdef.bounds, side)
+            if not isinstance(val, str):
+                continue
+            if val in schema.parameters:
+                dtype = schema.parameters[val].dtype
+                if dtype not in NUMERIC_DTYPES:
+                    yield (
+                        f"Variable '{vname}' bounds.{side}: '{val}' is a {dtype} parameter, and a bound "
+                        f'is a number. Declare it dtype: float or int, or bound the variable by another.'
+                    )
+                continue
+            detail = (
+                f"'{val}' is not a declared parameter"
+                if val.isidentifier()
+                else f'bounds accept a parameter name or a number, not an expression (got {val!r}). '
+                f'Precompute it as a parameter'
+            )
+            yield (f"Variable '{vname}' bounds.{side}: {detail}.")
+
+
+def _sos_shapes(schema: Spec) -> Iterator[str]:
+    """A set runs along one dim of one declared variable, and a variable carries one set."""
+    claimed: dict[str, str] = {}
+    for sname, block in schema.sos.items():
+        context = f"Sos '{sname}'"
+        if block.along not in schema.dimensions:
+            yield (undeclared_dimension('Sos', sname, block.along))
+        elif block.variable not in schema.variables:
+            yield (
+                f"{context}: '{block.variable}' is not a declared variable.\n"
+                f'  Variables: {sorted(schema.variables)}\n'
+                f'A set is over one variable, so a parameter or an expression cannot carry one.'
+            )
+        elif block.along not in schema.variables[block.variable].dims:
+            yield (
+                f"{context}: along '{block.along}' is not a dim of variable "
+                f"'{block.variable}' (dims {schema.variables[block.variable].dims}). The set runs "
+                f"along one of the variable's own dims — one set per coordinate of the rest."
+            )
+        elif block.variable in claimed:
+            yield (
+                f"{context}: variable '{block.variable}' already carries the set declared by "
+                f"'{claimed[block.variable]}'. A variable holds one set — declare a second "
+                f'variable, or state the other restriction as a constraint.'
+            )
+        else:
+            claimed[block.variable] = sname
+
+
+def _sos_bounds(schema: Spec) -> Iterator[str]:
+    """A set states what the binaries it expands to state: each side of a member carries a coefficient.
+
+    The rewrite holds an unpicked member at zero from both sides, so a side
+    the model leaves open leaves the member free of it. Either coefficient
+    may be a parameter, because a row multiplies by it rather than reading
+    it. Decided here rather than where the rewrite runs, so a set the
+    language cannot state twice is refused before any data exists.
+    """
+    for sname, block in schema.sos.items():
+        if (member := schema.variables.get(block.variable)) is None:
+            continue
+        context = f"Sos '{sname}'"
+        below, above = coefficients(member.domain, member.bounds.lower, member.bounds.upper)
+        if below is None:
+            yield (
+                f"{context}: variable '{block.variable}' has no lower bound, and the set expands to rows "
+                f'that hold an unpicked member at zero from below as well as above. Declare bounds.lower, '
+                f'as a number or a parameter.'
+            )
+        if above is None:
+            yield (
+                f"{context}: variable '{block.variable}' has no upper bound, and the set expands to rows "
+                f'that hold an unpicked member at zero from above as well as below. Declare bounds.upper, '
+                f'as a number or a parameter.'
+            )
+
+
+def _piecewise_references(schema: Spec) -> Iterator[str]:
+    """A curve runs along a declared dimension through numeric values parameters carrying it, gated by a binary, masked by a bool."""
+    for name, pw in schema.piecewise.items():
+        context = f"piecewise '{name}'"
+        if pw.over not in schema.dimensions:
+            yield undeclared_dimension('piecewise', name, pw.over)
+            continue
+        for i, link in enumerate(pw.links):
+            if link.values not in schema.parameters:
+                yield f"{context}: link {i} values references undeclared parameter '{link.values}'"
+            elif (dtype := schema.parameters[link.values].dtype) not in NUMERIC_DTYPES:
+                yield (
+                    f"{context}: link {i} values parameter '{link.values}' is declared dtype: {dtype}, and a "
+                    f'breakpoint is a number. Declare it dtype: float or int.'
+                )
+            elif pw.over not in schema.parameters[link.values].dims:
+                yield (
+                    f"{context}: link {i} values parameter '{link.values}' must carry dim "
+                    f"'{pw.over}' (has {schema.parameters[link.values].dims})"
+                )
+        if (activity := pw.activity) is not None:
+            if activity not in schema.variables:
+                yield (
+                    f"{context}: activity '{activity}' is not a declared variable. A gate is a binary variable; "
+                    f'declare it, or drop activity: for weights that sum to 1.'
+                )
+            elif schema.variables[activity].domain != 'binary':
+                yield f"{context}: activity variable '{activity}' must be binary"
+        if (points := pw.points) is None or pw.nominated is not None:
+            continue
+        if points not in schema.parameters:
+            yield f"{context}: points references undeclared parameter '{points}'"
+        elif (dtype := schema.parameters[points].dtype) != 'bool':
+            yield (
+                f"{context}: points parameter '{points}' is {dtype}, and a mask is a bool parameter — one "
+                f'saying, per breakpoint, whether the curve reaches it. Declare it dtype: bool.'
+            )
+        elif pw.over not in schema.parameters[points].dims:
+            yield (
+                f"{context}: points parameter '{points}' must carry dim '{pw.over}' — "
+                f'it says how far each curve runs along it (has {schema.parameters[points].dims})'
+            )
+
+
+def _collisions(schema: Spec, context: str, by_kind: Iterable[tuple[str, Iterable[str]]]) -> Iterator[str]:
+    """The refusal for each name *context*'s expansion writes that the file already declares, by kind.
+
+    An emitted variable joins the flat namespace, so any declaration there
+    takes its name; a constraint, a set and an assumption each have their own.
+    """
+    sections = {'named expression': 'expressions', 'sos': 'sos'}
+    declared: dict[str, dict[str, str]] = {
+        'variable': {name: kind for kind, group in _flat_namespace(schema) for name in group},
+        'constraint': dict.fromkeys(schema.constraints, 'constraint'),
+        'sos': dict.fromkeys(schema.sos, 'sos'),
+        'assumption': dict.fromkeys(schema.assumptions, 'assumption'),
+    }
+    for kind, names in by_kind:
+        yield from (
+            f"{context}: its expansion writes {kind} '{one}', which this file already declares under "
+            f"'{sections.get(declared[kind][one], declared[kind][one] + 's')}:'. Rename one of them."
+            for one in names
+            if one in declared[kind]
+        )

mathspec-0.1.0.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.5
+Name: mathspec
+Version: 0.1.0
+Summary: Write an optimisation model as a YAML file. Check it and print it as math, with no data and no solver.
+Project-URL: Documentation, https://mathspec.readthedocs.io
+Project-URL: Repository, https://github.com/energy-models/mathspec
+Project-URL: Issues, https://github.com/energy-models/mathspec/issues
+Project-URL: Changelog, https://github.com/energy-models/mathspec/blob/main/CHANGELOG.md
+Author-email: Felix Bumann <117816358+FBumann@users.noreply.github.com>, Bryn Pickering <17178478+brynpickering@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: energy system modelling,latex,linear programming,optimisation,yaml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.1
+Requires-Dist: pyparsing>=3.1
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+<!--
+SPDX-FileCopyrightText: mathspec contributors
+SPDX-License-Identifier: CC-BY-4.0
+-->
+
+# mathspec
+
+<!--- --8<-- [start:badges] -->
+
+[![CI](https://img.shields.io/github/actions/workflow/status/energy-models/mathspec/ci.yml?style=flat-square&branch=main)](https://github.com/energy-models/mathspec/actions/workflows/ci.yml)
+[![conda-forge](https://img.shields.io/conda/vn/conda-forge/mathspec?logoColor=white&logo=conda-forge&style=flat-square)](https://prefix.dev/channels/conda-forge/packages/mathspec)
+[![pypi-version](https://img.shields.io/pypi/v/mathspec.svg?logo=pypi&logoColor=white&style=flat-square)](https://pypi.org/project/mathspec)
+[![python-version](https://img.shields.io/pypi/pyversions/mathspec?logoColor=white&logo=python&style=flat-square)](https://pypi.org/project/mathspec)
+[![Documentation build status](https://readthedocs.org/projects/mathspec/badge/?version=latest&style=flat-square)](https://mathspec.readthedocs.io)
+
+<!--- --8<-- [end:badges] -->
+
+**Write an optimisation model as a YAML file. Check it and print it as math,
+with no data and no solver.**
+
+A mathspec file declares four things: the axes the model runs over, such as
+`snapshot` and `generator`; the data it expects, such as `load` and `cost`; the
+decisions the solver makes, such as `dispatch`; and the rules those decisions
+obey, such as `sum(dispatch, over=generator) == load`. The file
+[below](#example) is a complete model.
+
+<!--- --8<-- [start:engines] -->
+
+mathspec builds nothing and solves nothing itself.
+[specsolve](https://github.com/fluxopt/specsolve) and
+[linopy](https://github.com/PyPSA/linopy) build and solve a mathspec model.
+Support in both is work in progress.
+
+<!--- --8<-- [end:engines] -->
+
+<!--- --8<-- [start:benefits] -->
+
+- **Check models in CI, with no data.** A wrong name or
+  dimension fails when the file loads, and the error names the fix.
+  [Errors →](https://mathspec.readthedocs.io/en/latest/reference/language/errors/)
+- **Publish the math you solve.** The equations in the paper
+  print from the file the solver reads.
+  [Typeset →](https://mathspec.readthedocs.io/en/latest/reference/typeset/)
+- **One model, many tools.** Engines, renderers and analysers read the model
+  through one public API, so no two of them can read the file differently.
+  [Program API →](https://mathspec.readthedocs.io/en/latest/reference/program/)
+- **Write full-size models.** PyPSA's `n.optimize()` model is
+  one file, with stochastic, multi-period and quadratic variants.
+  [PyPSA in one file →](https://mathspec.readthedocs.io/en/latest/examples/pypsa/)
+
+<!--- --8<-- [end:benefits] -->
+
+## Example
+
+<!--- --8<-- [start:model] -->
+
+```yaml title="dispatch.yaml"
+description: Least-cost dispatch of a generator fleet against an hourly load.
+
+dimensions:
+  snapshot: { dtype: int, description: dispatch periods }
+  generator: { description: generating units }
+
+parameters:
+  capacity: { dims: [generator], description: installed capacity }
+  load: { dims: [snapshot], description: demand to be met }
+  cost: { dims: [generator], description: marginal cost }
+
+variables:
+  dispatch:
+    description: output of a generator in a snapshot
+    dims: [snapshot, generator]
+    where: "capacity > 0"
+    bounds: { lower: 0, upper: capacity }
+
+constraints:
+  power_balance:
+    dims: [snapshot]
+    expression: sum(dispatch, over=generator) == load
+
+objective:
+  sense: minimize
+  expression: sum(dispatch * cost)
+```
+
+<!--- --8<-- [end:model] -->
+
+### The math it prints
+
+The typesetter prints the file above as math, with no data and no solver.
+Markdown is one of three formats, and GitHub renders it here.
+
+<!-- Prettier pads the legend tables that the generator emits unpadded, so the
+     two would rewrite each other forever. The range keeps this file formatted
+     and the block below byte-for-byte what the typesetter printed. -->
+<!-- prettier-ignore-start -->
+<!-- readme-math:begin -->
+
+Least-cost dispatch of a generator fleet against an hourly load.
+
+#### Objective
+
+```math
+\min \sum_{t \in \mathcal{T},\ g \in \mathcal{G}} \mathit{dispatch}_{t,g} \cdot \mathrm{cost}_{g}
+```
+
+#### Subject to
+
+**`power_balance`**
+
+```math
+\sum_{g \in \mathcal{G}} \mathit{dispatch}_{t,g} = \mathrm{load}_{t} \qquad \forall\, t \in \mathcal{T}
+```
+
+#### Variable domains
+
+**`dispatch`**
+
+```math
+0 \le \mathit{dispatch}_{t,g} \le \mathrm{capacity}_{g} \qquad \forall\, t \in \mathcal{T},\ g \in \mathcal{G} \,:\, \mathrm{capacity}_{g} > 0
+```
+
+<details>
+<summary>The whole document: a symbol table, and the legend it prints</summary>
+
+Least-cost dispatch of a generator fleet against an hourly load.
+
+#### Sets
+
+| Symbol | Meaning |
+|---|---|
+| $`\mathcal{S}`$ | index $`s`$ — `snapshot` — dispatch periods |
+| $`\mathcal{G}`$ | index $`g`$ — `generator` — generating units |
+
+#### Parameters
+
+| Symbol | Meaning |
+|---|---|
+| $`\bar p`$ | `capacity` over $`\mathcal{G}`$ — installed capacity |
+| $`\ell`$ | `load` over $`\mathcal{S}`$ — demand to be met |
+| $`c`$ | `cost` over $`\mathcal{G}`$ — marginal cost |
+
+#### Variables
+
+| Symbol | Meaning |
+|---|---|
+| $`\mathit{dispatch}`$ | `dispatch` over $`\mathcal{S} \times \mathcal{G}`$ — output of a generator in a snapshot |
+
+#### Objective
+
+$`\min \sum_{s \in \mathcal{S},\ g \in \mathcal{G}} \mathit{dispatch}_{s,g} \cdot c_{g}`$
+
+#### Subject to
+
+**`power_balance`**
+
+$`\sum_{g \in \mathcal{G}} \mathit{dispatch}_{s,g} = \ell_{s} \qquad \forall\, s \in \mathcal{S}`$
+
+#### Variable domains
+
+**`dispatch`**
+
+$`0 \le \mathit{dispatch}_{s,g} \le \bar p_{g} \qquad \forall\, s \in \mathcal{S},\ g \in \mathcal{G} \,:\, \bar p_{g} > 0`$
+
+</details>
+
+<!-- readme-math:end -->
+<!-- prettier-ignore-end -->
+
+Each format is one call:
+
+```python
+import mathspec as ms
+
+spec = ms.to_spec('dispatch.yaml')
+
+ms.to_markdown(spec)
+ms.to_latex(spec)
+ms.to_typst(spec)
+```
+
+A [symbol table](https://mathspec.readthedocs.io/en/latest/reference/typeset/#symbol-tables) gives the names their
+conventional spelling, as in the folded block.
+[Print a model as math](https://mathspec.readthedocs.io/en/latest/howto/print/) does the same from a shell.
+
+## Documentation
+
+The documentation is at <https://mathspec.readthedocs.io>.
+
+## Installation
+
+See [installation](https://mathspec.readthedocs.io/en/latest/howto/installation/). To work on mathspec, see
+[contributing](https://mathspec.readthedocs.io/en/latest/contributing/#setting-up-a-development-environment).
+
+## Prior art
+
+Every file under `src/` was written in [specsolve](https://github.com/fluxopt/specsolve)
+and extracted here. The keys themselves,
+which are YAML math, a block per component, `dims:` and a `where:` string,
+come from [Calliope](https://github.com/calliope-project/calliope).
+[linopy](https://github.com/PyPSA/linopy) supplies the vocabulary that
+`sum(over=)` and the dimension rules are named against.
+
+## Status
+
+Alpha, pre-1.0.
+
+<!--- --8<-- [start:status] -->
+
+**Breaking changes land without a deprecation cycle.** Pin an exact version if
+you depend on this, and read the
+[changelog](https://github.com/energy-models/mathspec/blob/main/CHANGELOG.md)
+before upgrading. Every construct round-trips through the schema, the parsers
+and all three typeset formats, and the LaTeX is compiled. The accepted YAML is
+not yet frozen.
+
+<!--- --8<-- [end:status] -->
+
+## Licence
+
+The code is [MIT](https://github.com/energy-models/mathspec/blob/main/LICENSE), and the prose is
+[CC-BY-4.0](https://github.com/energy-models/mathspec/blob/main/LICENSES/CC-BY-4.0.txt).

mathspec-0.1.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+mathspec/__init__.py,sha256=Jd2Y28k8XhQ3HOu_PXYJa43_uyH-sbZpu2cun6KjqPw,1583
+mathspec/__main__.py,sha256=LM-csTCgz1KW4CW19f5SxmXc_RQ43SNOAOSE1iw781o,3292
+mathspec/_expression_parser.py,sha256=S1zJRn1jLCA-Ou9YwXfY-0oCGZsfj9i85H4GCABbwyo,16682
+mathspec/_expression_resolver.py,sha256=yPhLVDa7qXdmHUjInwbqGwPtcuz9QKdKizo-dU1xZCE,34354
+mathspec/_sealed.py,sha256=gWNRdwnmEKtIemF8uyyzm1tcb_MbCRNOyEcf8Gy9kiM,1867
+mathspec/_where_parser.py,sha256=Pvrn9PCZnNJFhzXIhSSCbKQD7hVE3V2_gD6p1QaoDm8,10851
+mathspec/_where_resolver.py,sha256=29VZPAlYoJBs2khmTZ7e_WiLMM2R7NYKuUyfaVQFQNA,34892
+mathspec/_yaml.py,sha256=OzPtA2zj_FVqec1FOskTlg-FZLryXHzfydLyeSt2KVw,5567
+mathspec/advice.py,sha256=t568Orp2_wzOtrMtO5BMj3w2PUL8LkxHCbqpbIKVaP4,2904
+mathspec/boundedness.py,sha256=D3KOpMucUak9USQ6xexDegQAr-PcLFYL1SesCcZ-670,6318
+mathspec/degree.py,sha256=AbYQiCnTJdbo7Rm7Ux1zDHcyJJaGhO7r5PXD0GJaEXg,8911
+mathspec/dimensions.py,sha256=-LmJTVmNkTnjwYNbtmUU1oymlb0VVEuxvewJ9HD1ejs,16289
+mathspec/errors.py,sha256=KlRMkHbr7YeeLxVcCz_VxsHElbAgWBH4WA4bZQLGpDI,3466
+mathspec/exclusivity.py,sha256=y8o5NmHXHTGFiFm1VyNES1CK7BJGlvGpqg-vlynd4jk,24193
+mathspec/expansion.py,sha256=nSc5PIrRQQVHr4JVTlh4hJnZFR9JOyWe1E9j31E8_Wo,4878
+mathspec/lowering.py,sha256=kdLruVuXZ5i88lyj_RjtE1FVB04j8UpMJlO3XMRqpVg,12544
+mathspec/model.py,sha256=9BnNrI_l8XARAPBZG_CP3r4mFzvB7X7ZZA7Lfu8gMEI,36629
+mathspec/operators.py,sha256=1R1PjXyPlSG_3qh7Tea-y4iHb9wNX-lJ56P7vtu4woM,9731
+mathspec/piecewise.py,sha256=UTFJclwGzJifFc7KwY4GcM--IOQbLngKYgwSurrcjwI,23653
+mathspec/program.py,sha256=WNNA4Qja6rxlAnp_ZYmTdnT8ENgJegLNBPaTH7HaFJ4,57120
+mathspec/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mathspec/resolution.py,sha256=NtyK7US1vWn0sCELJl2SZmtvDdjjjw_x64hgdNj4Lt0,20362
+mathspec/separability.py,sha256=SDc-FZcCWz3CrbuMU4qCbPY_2zR1JQCprZSgQqiaSxY,7914
+mathspec/sos.py,sha256=HgKh5bNd4mcVMKfKfiQ3mCbadLH2e9nGq6SS-ow2eo0,6650
+mathspec/validation.py,sha256=0WozInIA3QghmzsZQoKy5ebvdehg4Z6r2oBzdIgI4Kc,16423
+mathspec/typesetting/README.md,sha256=VwaKV8GQaVeAL622P1Zl6xMw0JzdiMj5jsS6Qee_Qq4,5664
+mathspec/typesetting/__init__.py,sha256=qiHzvlaoEHohO3k3-A3PdAyFEFBLhUN_bcEozpM50uQ,8888
+mathspec/typesetting/format.py,sha256=9oCbX032IP69kfaZWcI75jqaEmTnuMkXQmmNxcGEbqk,8884
+mathspec/typesetting/latex.py,sha256=l65UPmIAtilHTb8nhNdRXzjYZbqZg9aKQF5GcDv90xo,4664
+mathspec/typesetting/legend.py,sha256=_IiC-UO7tgQbkxc81oX1O-NqLioqZkMHVRuDKn2kMd8,13259
+mathspec/typesetting/markdown.py,sha256=yOh_0AQJFooZZYwDk2H7pa7gV-mPNI9hK7Zy31Ya42w,4129
+mathspec/typesetting/symbols.py,sha256=kBDkmTXGu0aU6NpvpRVKEntFBWbVg2I8Sp7qTVR4yFQ,12962
+mathspec/typesetting/typst.py,sha256=zSwAQDpiq2L27k_l69nKrJKWT5aLpGsy1GpWeQiOi2s,5037
+mathspec/typesetting/walk.py,sha256=mfjfRGkDZEjI_n4IXRNg3IHF2OqIrhrzjT9WHw2pB8I,44457
+mathspec-0.1.0.dist-info/METADATA,sha256=P3yy8AILnLA1A8xuiHm7k7Y_Fd-9UyfnD-MM72y1o14,8713
+mathspec-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+mathspec-0.1.0.dist-info/licenses/LICENSE,sha256=UnTZoIrNZRqtydvUET5bawvnclcEVLKfhzVaKe2Yk7M,1070
+mathspec-0.1.0.dist-info/RECORD,,

mathspec-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mathspec-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 energy-models
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.