meds-algorithm 0.4.0a4__py3-none-any.whl

meds_algorithm/serialization.py

@@ -0,0 +1,122 @@
+"""Strict, explicit-class serialization for immutable configuration and requests."""
+
+from __future__ import annotations
+
+import json
+import math
+import types
+from dataclasses import fields, is_dataclass
+from enum import Enum
+from pathlib import Path
+from typing import ClassVar, Union, get_args, get_origin, get_type_hints
+
+
+def encode(value):
+    """JSON values only; never turn unsupported Python objects into arbitrary strings."""
+    if is_dataclass(value) and not isinstance(value, type):
+        if not value.__dataclass_params__.frozen:
+            raise TypeError("Serializable dataclasses must be frozen")
+        return {field.name: encode(getattr(value, field.name)) for field in fields(value)}
+    if isinstance(value, Enum):
+        return value.value
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, tuple):
+        return [encode(item) for item in value]
+    if value is None or type(value) in (str, bool, int):
+        return value
+    if type(value) is float and math.isfinite(value):
+        return value
+    raise TypeError(f"Unsupported serialization value: {type(value).__name__}")
+
+
+def decode(annotation, value, *, base: Path):
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+    if origin in (Union, types.UnionType):
+        for option in args:
+            try:
+                return decode(option, value, base=base)
+            except (TypeError, ValueError):
+                pass
+        raise TypeError(f"Value does not match {annotation}")
+    if annotation is type(None) and value is None:
+        return None
+    if annotation is Path:
+        if not isinstance(value, (str, Path)) or not str(value).strip():
+            raise TypeError("Expected a nonempty path")
+        path = Path(value)
+        return (base / path).resolve() if not path.is_absolute() else path.resolve()
+    if origin is tuple:
+        if not isinstance(value, (tuple, list)):
+            raise TypeError("Expected an array")
+        if len(args) == 2 and args[1] is Ellipsis:
+            return tuple(decode(args[0], item, base=base) for item in value)
+        if len(args) != len(value):
+            raise TypeError("Wrong tuple length")
+        return tuple(decode(kind, item, base=base) for kind, item in zip(args, value, strict=True))
+    if isinstance(annotation, type) and issubclass(annotation, Enum):
+        return annotation(value)
+    if is_dataclass(annotation):
+        if isinstance(value, annotation):
+            value = encode(value)
+        if not isinstance(value, dict):
+            raise TypeError(f"Expected an object for {annotation.__name__}")
+        names = {field.name for field in fields(annotation)}
+        if unknown := value.keys() - names:
+            raise ValueError(f"Unknown fields for {annotation.__name__}: {sorted(unknown)}")
+        hints = get_type_hints(annotation)
+        return annotation(**{key: decode(hints[key], item, base=base) for key, item in value.items()})
+    if annotation is float and type(value) in (int, float) and math.isfinite(value):
+        return float(value)
+    if annotation in (str, int, bool) and type(value) is annotation:
+        return value
+    raise TypeError(f"Expected {annotation}, got {type(value).__name__}")
+
+
+class Serializable:
+    """Subclass with a frozen dataclass. Loading never imports a class named by a file."""
+
+    schema_version: ClassVar[int] = 1
+
+    def __post_init__(self):
+        hints = get_type_hints(type(self))
+        for field in fields(self):
+            object.__setattr__(
+                self, field.name, decode(hints[field.name], getattr(self, field.name), base=Path.cwd())
+            )
+        encode(self)
+        self.validate()
+
+    def validate(self) -> None:
+        """Override to enforce algorithm-specific value constraints."""
+
+    def to_dict(self) -> dict:
+        return encode(self)
+
+    @classmethod
+    def from_dict(cls, values: dict, *, base: Path | None = None):
+        return decode(cls, values, base=Path.cwd() if base is None else Path(base).resolve())
+
+    def save(self, path: Path | str) -> Path:
+        path = Path(path)
+        envelope = {
+            "schema_version": self.schema_version,
+            "type": f"{type(self).__module__}.{type(self).__qualname__}",
+            "values": self.to_dict(),
+        }
+        path.write_text(json.dumps(envelope, sort_keys=True, indent=2, allow_nan=False), encoding="utf-8")
+        return path
+
+    @classmethod
+    def load(cls, path: Path | str):
+        path = Path(path).resolve()
+        envelope = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(envelope, dict) or set(envelope) != {"schema_version", "type", "values"}:
+            raise ValueError("Invalid serialized envelope")
+        if (
+            envelope["schema_version"] != cls.schema_version
+            or envelope["type"] != f"{cls.__module__}.{cls.__qualname__}"
+        ):
+            raise ValueError("Serialized type or schema version mismatch")
+        return cls.from_dict(envelope["values"], base=path.parent)

meds_algorithm/spec.py

@@ -0,0 +1,23 @@
+"""Read the one normative specification shipped with the installed core version."""
+
+import argparse
+from importlib.resources import files
+
+
+def specification() -> str:
+    return files("meds_algorithm").joinpath("CONTRACT.md").read_text(encoding="utf-8")
+
+
+def architecture() -> str:
+    """Read the bundled API/UML guide maintained as ARCHITECTURE.md in the repository."""
+    return files("meds_algorithm").joinpath("ARCHITECTURE.md").read_text(encoding="utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    print(specification())
+
+
+if __name__ == "__main__":
+    main()

meds_algorithm/tasks/__init__.py

@@ -0,0 +1 @@
+"""Task identity and declared semantic relaxations."""

meds_algorithm/tasks/spec.py

@@ -0,0 +1,136 @@
+"""The zero-shot task boundary: task specification, label-blind index, and relaxation ledger.
+
+A supervised algorithm learns *what* to predict from labels. A zero-shot algorithm is never shown labels,
+so the task definition itself must cross the contract boundary. The task language is ACES: a criteria
+file plus, optionally, a dataset predicates file.
+
+The contract fixes only the inputs (task, index, MEDS data), the final predictions, the semantics digest
+that ties every artifact to the exact task it answers, and a minimal ledger of how the answered task
+differs from the requested one. How a algorithm turns the task into predictions is its own; the
+implementation guide recommends an encode -> infer -> decode shape.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+INDEX_COLUMNS = ("subject_id", "prediction_time")
+RELAXATIONS_FILENAME = "relaxations.yaml"
+PREDICTED_PROBABILITY = "predicted_boolean_probability"
+
+
+def _digest_file(path: Path) -> str:
+    return f"sha256:{hashlib.sha256(path.read_bytes()).hexdigest()}"
+
+
+@dataclass(frozen=True)
+class TaskSpec:
+    """A task in the overall task language: an ACES criteria file and its optional predicates file."""
+
+    criteria_file: Path
+    predicates_file: Path | None = None
+    name: str | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "criteria_file", Path(self.criteria_file))
+        if self.predicates_file is not None:
+            object.__setattr__(self, "predicates_file", Path(self.predicates_file))
+        for path in (self.criteria_file, self.predicates_file):
+            if path is not None and not path.is_file():
+                raise FileNotFoundError(f"Task file {path} does not exist")
+
+    @classmethod
+    def from_arguments(cls, arguments: Mapping[str, Any]) -> TaskSpec:
+        """Read the standard ``external_task_criteria_file`` / ``external_predicates_file`` arguments."""
+        criteria = arguments.get("external_task_criteria_file")
+        if not criteria:
+            raise ValueError(
+                "zero-shot commands require external_task_criteria_file=<ACES task YAML>; without it the "
+                "algorithm cannot know what to predict"
+            )
+        return cls(
+            criteria_file=criteria,
+            predicates_file=arguments.get("external_predicates_file") or None,
+            name=arguments.get("task_name") or None,
+        )
+
+    def semantics_digest(self) -> str:
+        """A digest of exactly what was asked: the criteria bytes and the predicates bytes.
+
+        Artifacts may be combined only when their semantics digests agree. The digest changes when either
+        file changes, including when the same criteria are bound to another dataset's predicates.
+        """
+        digest = hashlib.sha256()
+        for label, path in (("criteria", self.criteria_file), ("predicates", self.predicates_file)):
+            digest.update(label.encode())
+            digest.update(b"\0" if path is None else hashlib.sha256(path.read_bytes()).digest())
+        return f"sha256:{digest.hexdigest()}"
+
+    def provenance(self) -> dict[str, Any]:
+        """The manifest ``inputs`` entry recording which task was answered."""
+
+        def entry(path: Path | None) -> dict[str, str] | None:
+            return None if path is None else {"path": str(path.resolve()), "digest": _digest_file(path)}
+
+        return {
+            "name": self.name,
+            "criteria_file": entry(self.criteria_file),
+            "predicates_file": entry(self.predicates_file),
+        }
+
+
+@dataclass(frozen=True)
+class RelaxationLedger:
+    """What a zero-shot prediction actually estimates, written as ``relaxations.yaml``.
+
+    Only ``query_language``, ``decoded_quantity``, and ``exact`` are required. ``steps`` is free-form: one
+    mapping per rewrite or assumption between the requested and the answered task. The implementation
+    guide recommends ``name``, ``kind``, ``direction``, and ``detail`` keys; the contract does not validate
+    them. An exact algorithm writes ``exact: true`` and no steps.
+    """
+
+    query_language: str
+    decoded_quantity: str
+    exact: bool
+    steps: Sequence[Mapping[str, Any]] = field(default_factory=tuple)
+
+    def __post_init__(self) -> None:
+        for name in ("query_language", "decoded_quantity"):
+            if not isinstance(getattr(self, name), str) or not getattr(self, name).strip():
+                raise ValueError(f"{RELAXATIONS_FILENAME} requires a non-empty {name}")
+        if not isinstance(self.exact, bool):
+            raise ValueError(f"{RELAXATIONS_FILENAME} requires exact: true or false")
+        object.__setattr__(self, "steps", tuple(dict(step) for step in self.steps))
+
+    def write(self, directory: Path | str) -> Path:
+        path = Path(directory) / RELAXATIONS_FILENAME
+        value = {
+            "query_language": self.query_language,
+            "decoded_quantity": self.decoded_quantity,
+            "exact": self.exact,
+            "steps": [dict(step) for step in self.steps],
+        }
+        path.write_text(yaml.safe_dump(value, sort_keys=False))
+        return path
+
+    @classmethod
+    def read(cls, directory: Path | str) -> RelaxationLedger:
+        path = Path(directory) / RELAXATIONS_FILENAME
+        if not path.is_file():
+            raise FileNotFoundError(f"{directory} has no {RELAXATIONS_FILENAME}")
+        value = yaml.safe_load(path.read_text()) or {}
+        missing = {"query_language", "decoded_quantity", "exact"} - set(value)
+        if missing:
+            raise ValueError(f"{path} lacks required fields {sorted(missing)}")
+        return cls(
+            query_language=value["query_language"],
+            decoded_quantity=value["decoded_quantity"],
+            exact=value["exact"],
+            steps=value.get("steps") or (),
+        )

meds_algorithm/version.py

@@ -0,0 +1,3 @@
+"""Artifact contract version, independent of the package release."""
+
+CONTRACT_VERSION = "4"

meds_algorithm-0.4.0a4.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.5
+Name: meds-algorithm
+Version: 0.4.0a4
+Summary: Shared MEDS algorithm contracts and conformance boundaries.
+Project-URL: Repository, https://github.com/McDermottHealthAI/meds-algorithm
+Project-URL: Documentation, https://github.com/McDermottHealthAI/meds-algorithm/blob/main/ARCHITECTURE.md
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6
+Provides-Extra: conformance
+Requires-Dist: meds-evaluation==0.0.3; extra == 'conformance'
+Requires-Dist: polars>=1; extra == 'conformance'
+Requires-Dist: pyarrow>=15; extra == 'conformance'
+Requires-Dist: pytest>=8; extra == 'conformance'
+Provides-Extra: data
+Requires-Dist: polars>=1; extra == 'data'
+Provides-Extra: test
+Requires-Dist: meds-evaluation==0.0.3; extra == 'test'
+Requires-Dist: polars>=1; extra == 'test'
+Requires-Dist: pyarrow>=15; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# meds-algorithm
+
+[![Python 3.11+](https://img.shields.io/badge/Python-3.11%2B-blue?logo=python&logoColor=white)](https://www.python.org/downloads/)
+[![PyPI: unreleased](https://img.shields.io/badge/PyPI-unreleased-lightgrey)](https://github.com/McDermottHealthAI/meds-algorithm/blob/main/RELEASING.md)
+[![Tests and code quality](https://github.com/McDermottHealthAI/meds-algorithm/actions/workflows/ci.yml/badge.svg)](https://github.com/McDermottHealthAI/meds-algorithm/actions/workflows/ci.yml)
+[![Documentation](https://img.shields.io/badge/docs-architecture-blue)](https://github.com/McDermottHealthAI/meds-algorithm/blob/main/ARCHITECTURE.md)
+[![Contributors](https://img.shields.io/github/contributors/McDermottHealthAI/meds-algorithm)](https://github.com/McDermottHealthAI/meds-algorithm/graphs/contributors)
+[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen)](https://github.com/McDermottHealthAI/meds-algorithm/pulls)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green)](https://github.com/McDermottHealthAI/meds-algorithm/blob/main/LICENSE)
+
+Shared infrastructure for implementing and validating MEDS algorithm repositories. The package defines
+algorithm profiles and command contracts, manages artifacts and run provenance, reads prediction indices
+and training targets, validates prediction outputs, and provides reusable conformance tests.
+
+Algorithm repositories import these utilities so fixes can be distributed through a package update.
+Algorithm architectures, tokenizers, training objectives and task-specific logic stay in the algorithm repository.
+
+See the [architecture and UML diagrams](https://github.com/McDermottHealthAI/meds-algorithm/blob/main/ARCHITECTURE.md) for the profile hierarchy, typed requests,
+algorithm-owned configuration, artifact references and shared execution path.
+
+## Package layout
+
+```text
+src/meds_algorithm/
+├── CONTRACT.md                 # canonical normative specification, included in the wheel
+├── spec.py                     # installed specification reader
+├── algorithms.py               # Algorithm and profile ABCs, lifecycle order
+├── requests.py                 # frozen per-step requests and CLI field mappings
+├── configuration.py            # AlgorithmConfig, NNConfig and execution options
+├── serialization.py            # strict, versioned config/request JSON serialization
+├── runner.py                   # validate, execute, measure, publish; CLI adapter
+├── contracts/commands.py       # derived compatibility views and legacy dispatch
+├── artifacts/
+│   ├── references.py           # lazy typed artifact references and payload metadata
+│   ├── manifest.py             # measured artifacts, envelope reading and digests
+│   ├── publication.py          # unique staging, exclusive writers and overwrite rollback
+│   ├── inputs.py               # resolve recorded upstream artifact paths
+│   └── results.py              # structured run evidence
+├── runtime/
+│   ├── provenance.py           # explicitly supplied algorithm checkout
+│   ├── resources.py            # process-tree memory sampling and platform fallback
+│   └── process.py              # bounded subprocess execution
+├── data/                       # split selection, key-only index reads, context targets
+├── tasks/spec.py               # TaskSpec and RelaxationLedger
+├── evaluation/predictions.py   # keyed probabilities and post-score truth attachment
+├── integrations/meds_dev.py    # per-profile registration and CLI
+└── conformance/                # assertions, synthetic fixtures, full-lifecycle checks,
+                               # opt-in MEDS-DEV provisioning and algorithm adapter result types
+```
+
+## Installation and dependencies
+
+Install a reviewed revision with
+`pip install 'meds-algorithm @ git+https://github.com/McDermottHealthAI/meds-algorithm.git@<full-commit-sha>'`.
+The template currently records the exact SHA. For package-index release checks and publishing setup,
+see the [release guide](https://github.com/McDermottHealthAI/meds-algorithm/blob/main/RELEASING.md).
+
+- Base package: PyYAML; no dataframe engine, test runner, GPU or algorithm framework is imported by base APIs.
+- `data` extra: Polars for index/target reads and prediction validation.
+- `conformance` extra: pytest, Polars, PyArrow and the pinned MEDS evaluation schema implementation.
+- `test` extra: dependencies for developing and testing this package.
+
+The installed CLI provides `meds-algorithm-spec`, `meds-algorithm-resolve-input`, and
+`meds-algorithm-add-to-meds-dev`. Algorithm repositories provide their own `meds-algorithm` entry point.
+
+New algorithm repositories implement `Algorithm` profile subclasses, receive frozen typed requests, and
+execute through `AlgorithmRepository`/`StepRunner`. Their own frozen `AlgorithmConfig` subclass defines
+hyperparameters, defaults and validation. Use `config_file=...` for a JSON/YAML values mapping or a
+previously saved `config.json`. Typed prediction execution requires the `data` extra. See the
+[architecture guide](https://github.com/McDermottHealthAI/meds-algorithm/blob/main/ARCHITECTURE.md) for the complete ownership and serialization algorithm.
+
+Neural algorithms can extend `NNConfig` for a capacity multiplier, learning rate, batch size,
+weight decay and dropout. Concrete algorithms define the multiplier-to-architecture mapping and training
+defaults. See [neural configuration and scaling](https://github.com/McDermottHealthAI/meds-algorithm/blob/main/ARCHITECTURE.md#neural-network-configuration-and-scaling-experiments)
+for an extensible example and the recommended upstream ownership of data scaling.
+
+## Ownership
+
+The template imports this package directly; it does not generate a `meds_algorithm_contract` package or
+copy these implementations. Generated files contain algorithm command skeletons, selected profile YAMLs,
+execution adapters in `tests/e2e.py`, algorithm-specific tests, and project/cluster configuration.
+Family sharing belongs inside one algorithm-family repository with several profiles. Tokenizers,
+architectures, objectives, payload layouts and task translators remain algorithm-owned.
+
+`CONTRACT.md` is the only normative document. Template documentation renders it from the installed
+package. Algorithm `SPEC.md` files point to it; algorithm implementation reports record local decisions.
+
+MEDS-DEV's upstream interface still uses `model.yaml`, `src/MEDS_DEV/models`, `meds-dev-model`,
+`model=`, and `{model_initialization_dir}`. Registration translates the local `algorithms/<profile>/`
+layout into that interface; these upstream names are not part of this package's rename.
+
+## Publication, provenance and measurement
+
+Pass the algorithm checkout explicitly to `StepRunner(repo=algorithm_root)` or, for legacy implementations,
+`measured_artifact(..., repo=algorithm_root)`. The package never
+infers the algorithm from its own installation path or the working directory. Without a supplied checkout,
+commit and dirty state are unknown (`null`); wheel deployments must retain algorithm build provenance
+separately rather than inventing a checkout revision.
+
+Publication uses a unique sibling staging directory and an exclusive destination lock. A new artifact
+appears in one rename. Overwrite retains the old directory as a backup until the new directory is
+published, and restores it if publication fails. Replacement uses two renames, so concurrent readers
+can briefly observe an absent destination. Prefer immutable output paths for concurrent readers.
+This is not a power-loss transaction: after a process crash, inspect the `.lock`, `.staging-*` and
+`.backup-*` siblings before manually recovering. If restoration itself fails, the exception names the
+preserved backup; it is never silently deleted. Locks apply to cooperating core writers.
+
+Linux sampling visits the children of every process thread, including subprocesses launched by worker
+threads. Sampling can miss short-lived peaks; inaccessible descendants are not a complete measurement.
+On platforms without `/proc`, use process-only `getrusage` when available; otherwise report unavailable
+values as `null`. GPU instrumentation remains the algorithm/framework's responsibility.
+
+## Validation
+
+```bash
+uv sync --extra test --group dev
+uv run ruff check .
+uv run ruff format --check .
+uv run pytest -q
+uv build
+```
+
+Tests inject publication/restoration failures, launch a child from a worker thread, check explicit
+algorithm provenance, reject missing/mixed/overlapping label inputs, and exercise all six lifecycles with
+synthetic command implementations. Full-lifecycle conformance reruns algorithm adapters with forbidden
+outcomes removed and fresh artifacts; algorithm-specific cutoff, frozen-weight, compatibility and primary
+behavior tests remain required. Package tests do not establish scientific validity of a downstream algorithm.
+
+MEDS-DEV provisioning requires explicit `-m meds_dev` or `-m real_data` selection; setting
+`MEDS_DEV_DIR` only supplies a source checkout. Unit tests do not download a real dataset or launch
+training. Keep each algorithm's data-access and cluster approval rules in its own repository.
+
+## Changes
+
+### 0.4.0a4
+
+- Rename the repository/distribution from `meds-algorithm-core` to `meds-algorithm`, the Python package
+  from `meds_algorithm_core` to `meds_algorithm`, and the contract command to `meds-algorithm-spec`.
+  Update imports and dependency pins together. No old-name aliases are installed; serialized envelopes
+  with old package-qualified type names require an explicit migration before loading.
+
+### 0.4.0a3
+
+- Add optional `NNConfig(AlgorithmConfig)` with a scalar capacity multiplier and strict immutable settings,
+  inherited serialization, validation and runner provenance, without neural-framework dependencies.
+- Document capacity semantics, configuration sweeps and the distinction between implemented configuration
+  and future upstream data-scaling/consumption-reporting integrations.
+
+### 0.4.0a2
+
+- Add optional `AlgorithmConfig.additional_predicates_file` for dataset-specific feature predicates.
+  Preprocessing composes it with the base, rejects duplicate names/keys, preserves the resolved file
+  and source digests, and keeps task predicates unchanged. Later steps do not reopen temporary sources.
+
+### 0.4.0a1
+
+- Add profile ABCs, typed requests/artifact references and a shared runner that owns validation,
+  measured publication and post-score truth attachment.
+- Add strict immutable algorithm-owned configuration and versioned config/request serialization; record
+  complete resolved values, upstream manifest identities and key-only index identities.
+- Derive profile/step metadata from the new classes. Rename the package, Python API, CLI and artifact
+  types/arguments to algorithm terminology under contract version 4. No old-name aliases are installed;
+  migrations remain separate. Mapping-based execution is available as `LegacyAlgorithmRepository`.
+- Include the canonical API/UML architecture guide in the wheel for downstream documentation.
+
+### 0.3.0a3
+
+- Compare seeded full-lifecycle predictions with and without forbidden labels, preserving separate
+  training, index and evaluation inputs.
+- Validate original and rerun probabilities across every prediction shard, and accept a separate
+  evaluation index when checking context-label overlap.
+- Terminate subprocess trees on timeout or interruption; deliberately detached services are unsupported.
+
+### 0.3.0a2
+
+- Complete the extraction of shared artifact, runtime, data, task, evaluation, MEDS-DEV and
+  conformance utilities from the template; replace the reserved placeholder modules with implementations.
+- Add exclusive artifact writers, overwrite rollback, explicit algorithm-checkout provenance and
+  process-tree memory sampling with platform fallbacks.
+- Reject ambiguous splits, overlapping context/evaluation keys, invalid probabilities and malformed
+  artifact manifests; rerun complete profile lifecycles to check for outcome-label leakage.
+- Make the core package the source of the contract and shared tests, removing generated copies from
+  the template. Migration of existing algorithm repositories is separate.
+
+### 0.3.0a1
+
+- Introduce contract version 3, profile/command definitions, the installed specification reader and
+  a key-only prediction index reader.

meds_algorithm-0.4.0a4.dist-info/RECORD

@@ -0,0 +1,46 @@
+meds_algorithm/CONTRACT.md,sha256=xntPBoiX20BrgKIwINrMIuGfZ69jWSXzD8xhgTg1rTc,42152
+meds_algorithm/__init__.py,sha256=Mu7qfI8R8ErHNkvhalMsxa6G12cGt-5YPtZyzLKlt5A,2526
+meds_algorithm/algorithms.py,sha256=4C9r9qHSBDK3RldbL2oSQ-MsQuCSpYp7eMxbFdelypU,5653
+meds_algorithm/configuration.py,sha256=JeCl14sHTTso2PQNJ3x4YKlT_CtF2UPTiV8w9mY2xqE,2163
+meds_algorithm/requests.py,sha256=Jhouni-ifB698j007WowPPjP36ZDGGlQd2Zrzty16R0,10196
+meds_algorithm/runner.py,sha256=1o3eQ7Zq79YYXPVG8-Ur_-eTf7KzfRWOZ33acTcPJtM,10988
+meds_algorithm/serialization.py,sha256=A2Kw3eIqgKv5T1iWzc8m3DiK_beob-33lip_PtD2BJM,5059
+meds_algorithm/spec.py,sha256=905AEeaHiltB0WpjZnzKWcmmEn6xuaLWYabh7UinbhE,637
+meds_algorithm/version.py,sha256=ZZ9-aff2JbQFi-0cPGgZlE0q46rN6lNLQIrLTrd68lU,93
+meds_algorithm/artifacts/__init__.py,sha256=U0LxpaI6dp7bUj-6UwyNgONOeSYLjC1l4j7SMZYbUvQ,74
+meds_algorithm/artifacts/inputs.py,sha256=ReLGWzdicazWw25pXXKKgbP2UvVz8STyonW9Yw_gO8A,1561
+meds_algorithm/artifacts/manifest.py,sha256=ogw27Mki-P4J9ZGpGbSV4rM2u9YzkG17cUmJ1s-1tck,5914
+meds_algorithm/artifacts/publication.py,sha256=hPS96rGzmkORz3x7-oVSsaD9z8gjw9zWwgPHOIx8bUk,2922
+meds_algorithm/artifacts/references.py,sha256=GBMsBrm9INRtjnaHNbPe8thKyZe_f0jJW_L610Gnw8Q,2139
+meds_algorithm/artifacts/results.py,sha256=ov00gdQzldVv0igd47gkS-UJy7S8IXPNoW9WPyNxC_A,2786
+meds_algorithm/conformance/__init__.py,sha256=6yj79ojbhg2QuUCQW6f3TtZWHDN4bffTrfuAcpkQ0_Q,96
+meds_algorithm/conformance/assertions.py,sha256=sT90qNusDYxN5K1GMv-lN7aVbaWYqNiHjcV-CAORneU,2975
+meds_algorithm/conformance/end_to_end.py,sha256=odQ--nDDPLjrmgzAdseBkfmxzUHq0mtIiJ-IC13ilt4,7207
+meds_algorithm/conformance/meds_dev.py,sha256=ap1vpHiA_4ONZWhB2m0_U6VSVg-lip0syKa4j8T9dTE,5649
+meds_algorithm/conformance/reports.py,sha256=DfY90OZiVsh9EmhglGXKKKnD6wKD5aIu3hyKlKaEyd4,1907
+meds_algorithm/conformance/signal.py,sha256=l8Q0dbGTuKLvLU9sHB6FogH-61cdCoBa9ccspya4NL0,5919
+meds_algorithm/conformance/types.py,sha256=LpZp4R2nQSDa3EHjzkHOK_-HTuOIQBTNhmQjhG3JcEs,1017
+meds_algorithm/contracts/__init__.py,sha256=MIWkD45lGJ4LpQ9TAaY3hQkyRVuE3kFTPipof8dik8M,61
+meds_algorithm/contracts/commands.py,sha256=h4UPFAF_R1ac7NTxXZvSeUEhUNDj-AKgLpL2sXuBSpc,7390
+meds_algorithm/contracts/enums.py,sha256=Ln7qqjTeiuPVO6oPh-7SL8Do9wWOB_i8T3V2s64JS7o,948
+meds_algorithm/data/__init__.py,sha256=Ln7Tf2l5OX_pOFUOo84ZAHmaNCBqaeeWyRNitsRk7k0,84
+meds_algorithm/data/index.py,sha256=EXuJDsiir0UWSyz7WQEPhs_pkELa-OSFghww-mQRJ7I,2580
+meds_algorithm/data/labels.py,sha256=G2131UJL-g2XEVm6i4iMrQ-hzDudtagc1ig0l_x_FmE,2316
+meds_algorithm/data/predicates.py,sha256=n7Gx3nofly8Nbx7GKDvm21rpHRkDlUNrGiEZhKk9TYw,2623
+meds_algorithm/data/validation.py,sha256=qTbhiaiT-cIaqPsoDuksajRakz561IZx3WpIv3i_RoQ,1002
+meds_algorithm/evaluation/__init__.py,sha256=m40EM0hLh7S7jFydZ1QpPU7L_gUjLbCqg4nclO_xV48,67
+meds_algorithm/evaluation/predictions.py,sha256=LIyu_VUMG_k00FacKS_ahMlqQjFMraotKye2iU06ZWk,2437
+meds_algorithm/integrations/__init__.py,sha256=P0aiVlwgV1CC1EdgW_TXOw652yZL62Xly81seP9FGgE,60
+meds_algorithm/integrations/meds_dev.py,sha256=z5e7UVrg8AjOqq0GGNCJmUxbhEEvyzl2AlzmNVj8FoI,2190
+meds_algorithm/runtime/__init__.py,sha256=tbgzQJiN1yQ9TmgTwLsyUshHjkMlRsLhVdu25ilW0K0,99
+meds_algorithm/runtime/process.py,sha256=1v1PIcNyw1RJ0_lWrmKM1k2jcMLhRMwoKxZOVl69A0s,1726
+meds_algorithm/runtime/provenance.py,sha256=uDaA9xMfpEDwf7hLuYNs9vI0LsMRGctdw_2YUk4nDWY,1019
+meds_algorithm/runtime/resources.py,sha256=K9rPREOL2x1uU0k6Sk_7_aaP72zD0QrROhO2r31JqG8,3623
+meds_algorithm/tasks/__init__.py,sha256=I8JslXTkVYHfQc19k_voL7CqxAHBliNarTQnl4brJE4,55
+meds_algorithm/tasks/spec.py,sha256=59AB902iPIcaxRGSNKdnG50UxhIBkGHZVttc1TfnRqw,5961
+meds_algorithm/ARCHITECTURE.md,sha256=X7ytGqAEdZMA2YNEMlyI7AQVdvFnQlsYk85cV7uBwwo,18026
+meds_algorithm-0.4.0a4.dist-info/METADATA,sha256=ZTIEi0SALEx93WbH8eFfFPlKujFSMGdpCb949LETjpg,13444
+meds_algorithm-0.4.0a4.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+meds_algorithm-0.4.0a4.dist-info/entry_points.txt,sha256=mmxSsbl65W6_GFEIiMYlYeH6ulSGA-iITYQP3IQRYfs,208
+meds_algorithm-0.4.0a4.dist-info/licenses/LICENSE,sha256=k0wqQurs6KfFG-mjx2fUCVlEqpUSNyiyO2sGtU8U-Ac,1119
+meds_algorithm-0.4.0a4.dist-info/RECORD,,

meds_algorithm-0.4.0a4.dist-info/WHEEL

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

meds_algorithm-0.4.0a4.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+meds-algorithm-add-to-meds-dev = meds_algorithm.integrations.meds_dev:main
+meds-algorithm-resolve-input = meds_algorithm.artifacts.inputs:main
+meds-algorithm-spec = meds_algorithm.spec:main

meds_algorithm-0.4.0a4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew McDermott and the MEDS_algorithm_template contributors
+
+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.