process-bigraph-lang 0.1.0__py3-none-win_amd64.whl

process_bigraph_lang/v2/sbml.py

@@ -0,0 +1,234 @@
+"""
+`describe-model` for SBML: a model file's interface as data (see `docs/v2/design.md`, section 5.6).
+
+`describe_sbml` reads an SBML file with the standard library's XML parser (no libsbml, no process code) and
+returns a `ModelHeader`: the model's time unit, compartments, species (as concentrations unless the species has
+only substance units) and parameters, each with its value and its units composed from the model's unit
+definitions in a pint-readable spelling, plus the counts a solver cares about (reactions, events, rules) and the
+SBML level, version and packages. `to_dict` is the JSON form (`pblang-model/0`), which the CLI renders as the
+`.pblang` model header (`print_model_header`).
+"""
+
+from __future__ import annotations
+
+import json
+import tempfile
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+MODEL_HEADER_VERSION = "pblang-model/0"
+
+_KIND_SYMBOLS = {
+    "litre": "L",
+    "liter": "L",
+    "mole": "mol",
+    "second": "s",
+    "gram": "g",
+    "kilogram": "kg",
+    "metre": "m",
+    "meter": "m",
+    "item": "count",
+    "dimensionless": "dimensionless",
+    "hertz": "Hz",
+    "kelvin": "K",
+    "joule": "J",
+    "newton": "N",
+    "pascal": "Pa",
+    "watt": "W",
+    "volt": "V",
+    "ampere": "A",
+    "coulomb": "C",
+}
+_SCALE_PREFIX = {3: "k", 2: "h", 1: "da", -1: "d", -2: "c", -3: "m", -6: "u", -9: "n", -12: "p", -15: "f"}
+_TIME_MULTIPLES = {60.0: "min", 3600.0: "h", 86400.0: "day"}
+_SBML_DEFAULTS = {"substance": "mol", "volume": "L", "time": "s", "area": "m**2", "length": "m"}
+
+
+@dataclass
+class Quantity:
+    value: float | None
+    units: str | None = None
+    constant: bool = True
+
+
+@dataclass
+class SpeciesDecl:
+    initial: float | None
+    units: str | None
+    kind: str  # concentration | amount
+    compartment: str | None
+    constant: bool = False
+
+
+@dataclass
+class ModelHeader:
+    name: str
+    source: str
+    sbml_id: str | None = None
+    level: int | None = None
+    version: int | None = None
+    packages: list[str] = field(default_factory=list)
+    time_units: str | None = None
+    compartments: dict[str, Quantity] = field(default_factory=dict)
+    species: dict[str, SpeciesDecl] = field(default_factory=dict)
+    parameters: dict[str, Quantity] = field(default_factory=dict)
+    counts: dict[str, int] = field(default_factory=dict)
+    notes: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "schema_version": MODEL_HEADER_VERSION,
+            "name": self.name,
+            "source": self.source,
+            "sbml": {"id": self.sbml_id, "level": self.level, "version": self.version, "packages": self.packages},
+            "time_units": self.time_units,
+            "compartments": {k: {"value": q.value, "units": q.units} for k, q in self.compartments.items()},
+            "species": {
+                k: {
+                    "initial": s.initial,
+                    "units": s.units,
+                    "kind": s.kind,
+                    "compartment": s.compartment,
+                    "constant": s.constant,
+                }
+                for k, s in self.species.items()
+            },
+            "parameters": {
+                k: {"value": q.value, "units": q.units, "constant": q.constant} for k, q in self.parameters.items()
+            },
+            "counts": dict(self.counts),
+            "notes": list(self.notes),
+        }
+
+
+def describe_sbml(path: str | Path) -> ModelHeader:
+    """The model header of an SBML file."""
+    path = Path(path)
+    root = ET.parse(path).getroot()
+    model = root.find("{*}model")
+    if model is None:
+        raise ValueError(f"{path}: no <model> element")
+    header = ModelHeader(name=_identifier(path.stem), source=path.name, sbml_id=model.get("id"))
+    header.level, header.version = _int(root.get("level")), _int(root.get("version"))
+    header.packages = sorted({_package(k) for k in root.attrib if k.endswith(":required")} - {""})
+    unit_defs = {d.get("id", ""): _unit_text(d) for d in model.findall("{*}listOfUnitDefinitions/{*}unitDefinition")}
+
+    def units(reference: str | None, default_key: str) -> str | None:
+        if reference:
+            return unit_defs.get(reference) or _KIND_SYMBOLS.get(reference, reference)
+        return unit_defs.get(model.get(f"{default_key}Units") or default_key) or _SBML_DEFAULTS.get(default_key)
+
+    header.time_units = units(None, "time")
+    for c in model.findall("{*}listOfCompartments/{*}compartment"):
+        dims = _int(c.get("spatialDimensions")) if c.get("spatialDimensions") else 3
+        default = {3: "volume", 2: "area", 1: "length"}.get(dims or 3, "volume")
+        header.compartments[c.get("id", "")] = Quantity(_float_or_none(c.get("size")), units(c.get("units"), default))
+    for sp in model.findall("{*}listOfSpecies/{*}species"):
+        name = sp.get("id", "")
+        compartment = sp.get("compartment")
+        substance = units(sp.get("substanceUnits"), "substance")
+        comp_units = (
+            header.compartments[compartment].units if compartment in header.compartments else units(None, "volume")
+        )
+        only_substance = sp.get("hasOnlySubstanceUnits") == "true"
+        if only_substance:
+            initial, kind, unit_text = _float_or_none(sp.get("initialAmount")), "amount", substance
+        elif sp.get("initialConcentration") is not None:
+            initial, kind, unit_text = (
+                _float_or_none(sp.get("initialConcentration")),
+                "concentration",
+                _ratio(substance, comp_units),
+            )
+        else:
+            amount = _float_or_none(sp.get("initialAmount"))
+            size = header.compartments[compartment].value if compartment in header.compartments else None
+            initial = amount / size if amount is not None and size else amount
+            kind, unit_text = "concentration", _ratio(substance, comp_units)
+            if amount is not None and size:
+                header.notes.append(
+                    f"species {name}: initial amount {amount:g} converted to concentration by compartment size {size:g}"
+                )
+        header.species[name] = SpeciesDecl(initial, unit_text, kind, compartment, constant=sp.get("constant") == "true")
+    for pr in model.findall("{*}listOfParameters/{*}parameter"):
+        header.parameters[pr.get("id", "")] = Quantity(
+            _float_or_none(pr.get("value")),
+            units(pr.get("units"), "") if pr.get("units") else None,
+            pr.get("constant") != "false",
+        )
+    header.counts = {
+        "reactions": len(model.findall("{*}listOfReactions/{*}reaction")),
+        "events": len(model.findall("{*}listOfEvents/{*}event")),
+        "rules": len(model.findall("{*}listOfRules/*")),
+        "function_definitions": len(model.findall("{*}listOfFunctionDefinitions/{*}functionDefinition")),
+    }
+    return header
+
+
+def print_model_header(header: ModelHeader) -> str:
+    """The `.pblang` model header: a generated declaration to `import`, not a composite (rendered by the CLI)."""
+    from process_bigraph_lang.v2.langium import run_cli
+
+    with tempfile.TemporaryDirectory() as tmp:
+        source = Path(tmp) / "model.json"
+        source.write_text(json.dumps(header.to_dict()), encoding="utf-8")
+        return run_cli("model-header", str(source)).stdout
+
+
+# --- helpers -----------------------------------------------------------------------------------------------------
+
+
+def _unit_text(definition: ET.Element) -> str:
+    parts = []
+    for unit in definition.findall("{*}listOfUnits/{*}unit"):
+        kind = unit.get("kind", "dimensionless")
+        symbol = _KIND_SYMBOLS.get(kind, kind)
+        scale = _int(unit.get("scale")) or 0
+        multiplier = _float_or_none(unit.get("multiplier")) or 1.0
+        exponent = _float_or_none(unit.get("exponent")) or 1.0
+        if symbol == "dimensionless" and multiplier == 1.0 and scale == 0:
+            continue
+        if symbol == "s" and scale == 0 and multiplier in _TIME_MULTIPLES:
+            text = _TIME_MULTIPLES[multiplier]
+        elif multiplier == 1.0 and scale in _SCALE_PREFIX and symbol != "dimensionless":
+            text = f"{_SCALE_PREFIX[scale]}{symbol}"
+        elif multiplier == 1.0 and scale == 0:
+            text = symbol
+        else:
+            text = f"({multiplier:g}e{scale} * {symbol})"
+        if exponent != 1.0:
+            text += f"**{exponent:g}"
+        parts.append(text)
+    return " * ".join(parts) if parts else "dimensionless"
+
+
+def _ratio(numerator: str | None, denominator: str | None) -> str | None:
+    if not numerator:
+        return None
+    if not denominator or denominator == "dimensionless":
+        return numerator
+    return f"{numerator} / {denominator}" if " " not in denominator else f"{numerator} / ({denominator})"
+
+
+def _package(attribute: str) -> str:
+    return attribute.split("}")[0].lstrip("{").rsplit("/", 2)[-2] if "}" in attribute else ""
+
+
+def _identifier(text: str) -> str:
+    cleaned = "".join(c if c.isalnum() or c == "_" else "_" for c in text)
+    return cleaned if cleaned and not cleaned[0].isdigit() else f"m_{cleaned}"
+
+
+def _int(text: str | None) -> int | None:
+    try:
+        return int(text) if text is not None else None
+    except ValueError:
+        return None
+
+
+def _float_or_none(text: str | None) -> float | None:
+    try:
+        return float(text) if text is not None else None
+    except ValueError:
+        return None

process_bigraph_lang/v2/types.py

@@ -0,0 +1,244 @@
+"""
+Type expressions as data, for the normalizer and for `describe`: `parse_type` accepts both bigraph-schema
+forms, the string grammar (`list[float]`, `a:float|b:integer`, `A~B`, `array[(3|4),float]`, `float{3.5}`) and
+the dict form (`{"_type": "map", "_value": ...}`), and keeps the original (`source`) so that `to_bigraph` is
+lossless. The DSL spelling of a type lives in TypeScript (`dsl/src/language/v2/types.ts`).
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Any, Final
+
+from bigraph_schema.parse import parse_expression  # type: ignore[import-untyped]
+
+
+class _Missing:
+    """The absence of a default (distinct from `None`)."""
+
+    _instance: _Missing | None = None
+
+    def __new__(cls) -> _Missing:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __repr__(self) -> str:
+        return "MISSING"
+
+    def __bool__(self) -> bool:
+        return False
+
+
+MISSING: Final = _Missing()
+
+
+@dataclass
+class Named:
+    """A (possibly parametric) named type: `float`, `list[float]`, `map[string,float]`, `array[(3|4),float]`."""
+
+    name: str
+    args: list[TypeExpr] = field(default_factory=list)
+    default: Any = MISSING
+    units: str | None = None
+    source: Any = None
+
+
+@dataclass
+class Struct:
+    """A dict schema: `a:float|b:integer` or `{"a": "float", "b": "integer"}`."""
+
+    fields: dict[str, TypeExpr]
+    source: Any = None
+
+
+@dataclass
+class UnionType:
+    """A union: `A~B`."""
+
+    options: list[TypeExpr]
+    source: Any = None
+
+
+@dataclass
+class Group:
+    """A shape group inside an array type: `(3|4)`."""
+
+    items: list[int | str]
+
+
+@dataclass
+class Raw:
+    """A dict-form type with attributes that have no dedicated representation; kept verbatim."""
+
+    attrs: dict[str, Any]
+    source: Any = None
+
+
+TypeExpr = Named | Struct | UnionType | Group | Raw
+
+_PARAM_KEYS: dict[str, tuple[str, ...]] = {
+    "list": ("_element",),
+    "set": ("_element",),
+    "tree": ("_leaf",),
+    "map": ("_key", "_value"),
+    "tuple": ("_values",),
+    "enum": ("_values",),
+    "union": ("_options",),
+    "maybe": ("_value",),
+    "overwrite": ("_value",),
+    "const": ("_value",),
+    "quote": ("_value",),
+}
+_ARRAY_KEYS = ("_shape", "_data", "_units")
+_BIGRAPH_NAMES = {"int": "integer", "bool": "boolean"}
+_TRAILING_DEFAULT = re.compile(r"^([^{}]*)\{(.*)\}$")
+
+
+def parse_type(spec: Any) -> TypeExpr:
+    """Parse a bigraph-schema type (string or dict form) into a `TypeExpr` that remembers its source."""
+    if isinstance(spec, str):
+        return _from_string(spec)
+    if isinstance(spec, dict):
+        return _from_dict(spec)
+    raise TypeError(f"not a type expression: {spec!r}")
+
+
+def _from_string(text: str) -> TypeExpr:
+    source = text
+    stripped = text.strip()
+    default: Any = MISSING
+    match = _TRAILING_DEFAULT.match(stripped)
+    if match:
+        stripped, default = match.group(1), _literal(match.group(2))
+    expr = _from_parsed(parse_expression(stripped))
+    if default is not MISSING and isinstance(expr, Named):
+        expr.default = default
+    if not isinstance(expr, Group):
+        expr.source = source
+    return expr
+
+
+def _literal(text: str) -> Any:
+    try:
+        return json.loads(text)
+    except ValueError:
+        return text
+
+
+def _from_parsed(parsed: Any) -> TypeExpr:
+    if isinstance(parsed, str):
+        return Named(parsed)
+    if isinstance(parsed, list):
+        name, params = parsed
+        return Named(str(name), [_from_parsed(p) for p in params])
+    if isinstance(parsed, tuple):
+        return Group([_dim(p) for p in parsed])
+    if isinstance(parsed, dict):
+        if "_union" in parsed:
+            return UnionType([_from_parsed(p) for p in parsed["_union"]])
+        return Struct({str(k): _from_parsed(v) for k, v in parsed.items()})
+    raise TypeError(f"unexpected parse result: {parsed!r}")
+
+
+def _dim(value: Any) -> int | str:
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return int(value)
+    text = str(value)
+    return int(text) if text.lstrip("-").isdigit() else text
+
+
+def _from_dict(spec: dict[str, Any]) -> TypeExpr:
+    if "_type" not in spec:
+        if any(str(k).startswith("_") for k in spec):
+            return Raw(dict(spec), source=spec)
+        return Struct({str(k): parse_type(v) for k, v in spec.items()}, source=spec)
+    name = spec["_type"]
+    if not isinstance(name, str):
+        return Raw(dict(spec), source=spec)
+    if any(c in name for c in "[{|~") and set(spec) <= {"_type", "_default"}:
+        inner = _from_string(name)  # `{"_type": "list[string]", "_default": []}`
+        if isinstance(inner, Named) and "_default" in spec:
+            inner.default = spec["_default"]
+        if not isinstance(inner, Group):
+            inner.source = spec
+        return inner
+    keys = set(spec) - {"_type", "_default", "_units"}
+    args: list[TypeExpr] = []
+    units: str | None = spec.get("_units")
+    if name in _PARAM_KEYS and keys <= set(_PARAM_KEYS[name]):
+        for key in _PARAM_KEYS[name]:
+            if key not in spec:
+                continue
+            if key in ("_values", "_options"):
+                args.extend(Named(str(v)) if name == "enum" else parse_type(v) for v in spec[key])
+            else:
+                args.append(parse_type(spec[key]))
+    elif keys and keys <= set(_ARRAY_KEYS):
+        if "_shape" in spec:
+            args.append(Group([_dim(d) for d in spec["_shape"]]))
+        if "_data" in spec:
+            args.append(parse_type(spec["_data"]))
+    elif keys:
+        return Raw(dict(spec), source=spec)
+    return Named(name, args, default=spec.get("_default", MISSING), units=units, source=spec)
+
+
+def to_bigraph(expr: TypeExpr) -> Any:
+    """Render a `TypeExpr` as a bigraph-schema type (the original form when it came from one)."""
+    if not isinstance(expr, Group) and expr.source is not None:
+        return expr.source
+    if isinstance(expr, Named):
+        return _named_to_bigraph(expr)
+    if isinstance(expr, Struct):
+        return {k: to_bigraph(v) for k, v in expr.fields.items()}
+    if isinstance(expr, UnionType):
+        rendered = [to_bigraph(o) for o in expr.options]
+        if all(isinstance(r, str) for r in rendered):
+            return "~".join(rendered)
+        return {"_type": "union", "_options": rendered}
+    if isinstance(expr, Group):
+        return "(" + "|".join(str(i) for i in expr.items) + ")"
+    return expr.attrs
+
+
+def _named_to_bigraph(expr: Named) -> Any:
+    name = _BIGRAPH_NAMES.get(expr.name, expr.name)
+    shape = next((a for a in expr.args if isinstance(a, Group)), None)
+    others = [to_bigraph(a) for a in expr.args if not isinstance(a, Group)]
+    rendered: Any
+    if not expr.args:
+        rendered = name
+    elif shape is not None:
+        rendered = {"_type": name, "_shape": list(shape.items)}
+        if others:
+            rendered["_data"] = others[0]
+    elif all(isinstance(r, str) for r in others):
+        rendered = f"{name}[{','.join(others)}]"
+    elif name in ("list", "set"):
+        rendered = {"_type": name, "_element": others[0]}
+    elif name == "tree":
+        rendered = {"_type": name, "_leaf": others[0]}
+    elif name == "map":
+        rendered = {"_type": name, "_value": others[-1]}
+        if len(others) == 2:
+            rendered["_key"] = others[0]
+    elif name in ("tuple", "enum"):
+        rendered = {"_type": name, "_values": others}
+    elif name == "union":
+        rendered = {"_type": name, "_options": others}
+    else:
+        rendered = {"_type": name, "_value": others[0]}
+    if expr.units is not None:
+        rendered = (
+            {**rendered, "_units": expr.units}
+            if isinstance(rendered, dict)
+            else {"_type": rendered, "_units": expr.units}
+        )
+    if expr.default is not MISSING:
+        if isinstance(rendered, dict):
+            return {**rendered, "_default": expr.default}
+        return {"_type": rendered, "_default": expr.default}
+    return rendered

process_bigraph_lang-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: process_bigraph_lang
+Version: 0.1.0
+Summary: A language server, CLI and Python package for a domain specific language that describes process bigraphs.
+License-File: LICENSE
+Author: Jim Schaff
+Author-email: schaff@uchc.edu
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Dist: bigraph-schema (>=1.6.0,<2.0.0)
+Requires-Dist: numpy (>=1.26)
+Project-URL: Documentation, https://biosimulations.github.io/process-bigraph-lang/
+Project-URL: Repository, https://github.com/biosimulations/process-bigraph-lang
+Description-Content-Type: text/markdown
+
+# process-bigraph-lang
+
+[![Release](https://img.shields.io/github/v/release/biosimulations/process-bigraph-lang)](https://img.shields.io/github/v/release/biosimulations/process-bigraph-lang)
+[![Build status](https://img.shields.io/github/actions/workflow/status/biosimulations/process-bigraph-lang/main.yml?branch=main)](https://github.com/biosimulations/process-bigraph-lang/actions/workflows/main.yml?query=branch%3Amain)
+[![codecov](https://codecov.io/gh/biosimulations/process-bigraph-lang/branch/main/graph/badge.svg)](https://codecov.io/gh/biosimulations/process-bigraph-lang)
+[![Commit activity](https://img.shields.io/github/commit-activity/m/biosimulations/process-bigraph-lang)](https://img.shields.io/github/commit-activity/m/biosimulations/process-bigraph-lang)
+[![License](https://img.shields.io/github/license/biosimulations/process-bigraph-lang)](https://img.shields.io/github/license/biosimulations/process-bigraph-lang)
+
+A language server, CLI and Python package for `.pblang`, a domain specific language that describes
+[process bigraph](https://github.com/vivarium-collective/process-bigraph) composites: a tree-shaped, verifiable
+projection of the composite document, with imported interface declarations, parameters, open sites, units and
+model headers that the checker verifies before anything runs. See [the architecture](docs/architecture.md) and
+[the design](docs/v2/design.md).
+
+```bash
+pip install process_bigraph_lang
+python -m process_bigraph_lang.v2 compile composite.pblang --interfaces headers.manifest.json -o composite.json
+python -m process_bigraph_lang.v2 decompile composite.json
+python -m process_bigraph_lang.v2 check composite.pblang --interfaces headers.manifest.json
+python -m process_bigraph_lang.v2 describe my_package.processes --manifest headers.manifest.json --out headers/
+```
+
+- **Github repository**: <https://github.com/biosimulations/process-bigraph-lang/>
+- **Documentation** <https://biosimulations.github.io/process-bigraph-lang/>
+
+## Getting started with your project
+
+First, create a repository on GitHub with the same name as this project, and then run the following commands:
+
+```bash
+git init -b main
+git add .
+git commit -m "init commit"
+git remote add origin git@github.com:biosimulations/process-bigraph-lang.git
+git push -u origin main
+```
+
+Finally, install the environment and the pre-commit hooks with
+
+```bash
+make install
+```
+
+You are now ready to start development on your project!
+The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.
+
+To finalize the set-up for publishing to PyPI or Artifactory, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/publishing/#set-up-for-pypi).
+For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/mkdocs/#enabling-the-documentation-on-github).
+To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/codecov/).
+
+## Releasing a new version
+
+- Create an API Token on [PyPI](https://pypi.org/).
+- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/biosimulations/process-bigraph-lang/settings/secrets/actions/new).
+- Create a [new release](https://github.com/biosimulations/process-bigraph-lang/releases/new) on Github.
+- Create a new tag in the form `*.*.*`.
+- For more details, see [here](https://fpgmaas.github.io/cookiecutter-poetry/features/cicd/#how-to-trigger-a-release).
+
+---
+
+Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).
+

process_bigraph_lang-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+process_bigraph_lang/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+process_bigraph_lang/bin/.gitignore,sha256=Mc0TXahfdSsEA2MHbJ2xOafJsQEV0Lh5ZnAmdeB8C2g,75
+process_bigraph_lang/bin/cli-native.exe,sha256=EssQrGqEByA2sVeOsHo13LF1zdYeccoASv0eet6ttKQ,82848027
+process_bigraph_lang/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+process_bigraph_lang/v2/__init__.py,sha256=XbRZCZq13KSoa5i2qCqUjJ1GhVQpEwFo1kYj7rin7qg,2053
+process_bigraph_lang/v2/__main__.py,sha256=wvL0b5Lr7wvgFHQnIakOunwVBmIarr8fPpAzzZFWNbA,8773
+process_bigraph_lang/v2/api.py,sha256=7dVRu2F6E10IMORQTr5YbeOOZA4d_LhBm9GUH2tQZFU,7481
+process_bigraph_lang/v2/check.py,sha256=FnW39sxCYL1_c0M-9Edqvtx6v4s_Gpbf2HZDkZZFcDM,2835
+process_bigraph_lang/v2/interfaces.py,sha256=AYox41unDoCBjV-8P6OQoWhVqzUAByzNDmQf1GfkAoQ,9277
+process_bigraph_lang/v2/langium.py,sha256=KRT94Ptyy_yVLZ_rWgPW_dxy0ly9ni8HsO-dve4Wcq8,1597
+process_bigraph_lang/v2/normalize.py,sha256=y5aNmM9Q4Z_qietsFJxuf0Uk_M8nzIRNTKezqyg2TWw,17080
+process_bigraph_lang/v2/sbml.py,sha256=J1LFxPzOTVOOy0_6dpME6TJyuz24TDgT_fF16uAU_nk,9732
+process_bigraph_lang/v2/types.py,sha256=mX0LPaBFbnrMHUofVIztTTDpgJQN2WR6mQ_o3DD9z4M,8306
+process_bigraph_lang-0.1.0.dist-info/licenses/LICENSE,sha256=uuKYfnhjRd2IOKltacW_z7JSZLVs9Mqj50o9fVnRFyI,1089
+process_bigraph_lang-0.1.0.dist-info/METADATA,sha256=lNb9wBSZemfTFhRyzPfFEyO17XASWjnWHDXUAbKlnHQ,4510
+process_bigraph_lang-0.1.0.dist-info/WHEEL,sha256=hMN48yOIL1Tonvh8WM1EhFkq5MVedJfjGh-0PiW51jw,96
+process_bigraph_lang-0.1.0.dist-info/RECORD,,

process_bigraph_lang-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.5.0
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

process_bigraph_lang-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, Jim Schaff
+
+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.