strata-bridge 1.0.0__tar.gz

strata_bridge-1.0.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: strata_bridge
+Version: 1.0.0
+Summary: Strata BYOM SDK — StrataBridge and StrataModelAdapter for sponsor containers
+Author-email: Intheris Health <intheris.health@gmail.com>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://intheris.health
+Project-URL: Documentation, https://github.com/intheris-health/strata-platform/blob/main/docs/user-guides/BYOM_SPONSOR_SDK.md
+Project-URL: Bug Tracker, https://github.com/intheris-health/strata-platform/issues
+Keywords: federated-learning,healthcare,BYOM,strata
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.5
+Requires-Dist: pyarrow>=12.0
+
+# strata_bridge
+
+**Strata BYOM SDK** — the bridge between your ML model and the [Strata federated healthcare platform](https://intheris.health) by Intheris Health.
+
+## Overview
+
+`strata_bridge` is the Python package your Docker container uses when participating in federated training or inference across hospital sites. It provides:
+
+- **`StrataBridge`** — file-based I/O helpers (`/data` → `/output`)
+- **`StrataModelAdapter`** — the interface your model class must implement
+- **`run.py`** — the container entrypoint dispatcher (`python -m strata_bridge.run`)
+
+Core principle: **algorithms travel, data stays local.** Patient data never leaves the hospital; your container receives a privacy-safe DataFrame and returns only model weights or aggregate statistics.
+
+## Installation
+
+```bash
+pip install strata_bridge
+```
+
+## Quick Start
+
+```python
+from strata_bridge import StrataModelAdapter, ModelSpec, TrainingConfig, LocalTrainResult, InferenceResult
+import pandas as pd
+
+class MyModel(StrataModelAdapter):
+
+    def get_model_spec(self) -> ModelSpec:
+        return ModelSpec(
+            model_id="my-model-v1",
+            name="My Federated Model",
+            version="1.0.0",
+            input_columns=["age", "length_of_stay", "drg_weight"],
+            output_names=["risk_score"],
+            min_samples=50,
+        )
+
+    def initialize(self, config: dict) -> None:
+        # load or build your model here
+        pass
+
+    def get_weights(self) -> bytes:
+        # serialize model weights
+        return b""
+
+    def set_weights(self, weights: bytes) -> None:
+        # deserialize and apply global weights
+        pass
+
+    def local_train(self, data: pd.DataFrame, round_number: int, config: TrainingConfig) -> LocalTrainResult:
+        # train on local data, return updated weights + metrics
+        return LocalTrainResult(weights=self.get_weights(), sample_count=len(data), loss=0.0)
+
+    def local_inference(self, data: pd.DataFrame) -> InferenceResult:
+        # run inference, return aggregate distribution only
+        return InferenceResult(prediction_distribution={"low": len(data)}, sample_count=len(data))
+```
+
+Your `Dockerfile`:
+
+```dockerfile
+FROM python:3.11-slim
+WORKDIR /app
+RUN pip install strata_bridge torch --index-url https://download.pytorch.org/whl/cpu
+COPY model.py .
+CMD ["python", "-m", "strata_bridge.run"]
+```
+
+## Data Schema
+
+Your container receives local patient data at `/data/input.parquet` as a privacy-safe DataFrame. No PII is ever exposed.
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `patient_id` | str | Anonymized hash |
+| `age` | int | Computed from DOB |
+| `gender` | str | MALE / FEMALE / OTHER / UNKNOWN |
+| `admission_type` | str | EMERGENCY / ELECTIVE / TRANSFER / AMBULATORY |
+| `length_of_stay` | int | Days |
+| `primary_diagnosis` | str | ICD-10 code |
+| `drg_code` | str | SwissDRG code |
+| `drg_weight` | float | DRG cost weight |
+| `num_procedures` | int | Count |
+| `num_medications` | int | Count |
+| `num_lab_results` | int | Count |
+
+## Documentation
+
+Full sponsor guide: [BYOM_SPONSOR_SDK.md](https://github.com/intheris-health/strata-platform/blob/main/docs/user-guides/BYOM_SPONSOR_SDK.md)
+
+## License
+
+Proprietary — Intheris Health. Contact [intheris.health@gmail.com](mailto:intheris.health@gmail.com) for access.

strata_bridge-1.0.0/README.md

@@ -0,0 +1,94 @@
+# strata_bridge
+
+**Strata BYOM SDK** — the bridge between your ML model and the [Strata federated healthcare platform](https://intheris.health) by Intheris Health.
+
+## Overview
+
+`strata_bridge` is the Python package your Docker container uses when participating in federated training or inference across hospital sites. It provides:
+
+- **`StrataBridge`** — file-based I/O helpers (`/data` → `/output`)
+- **`StrataModelAdapter`** — the interface your model class must implement
+- **`run.py`** — the container entrypoint dispatcher (`python -m strata_bridge.run`)
+
+Core principle: **algorithms travel, data stays local.** Patient data never leaves the hospital; your container receives a privacy-safe DataFrame and returns only model weights or aggregate statistics.
+
+## Installation
+
+```bash
+pip install strata_bridge
+```
+
+## Quick Start
+
+```python
+from strata_bridge import StrataModelAdapter, ModelSpec, TrainingConfig, LocalTrainResult, InferenceResult
+import pandas as pd
+
+class MyModel(StrataModelAdapter):
+
+    def get_model_spec(self) -> ModelSpec:
+        return ModelSpec(
+            model_id="my-model-v1",
+            name="My Federated Model",
+            version="1.0.0",
+            input_columns=["age", "length_of_stay", "drg_weight"],
+            output_names=["risk_score"],
+            min_samples=50,
+        )
+
+    def initialize(self, config: dict) -> None:
+        # load or build your model here
+        pass
+
+    def get_weights(self) -> bytes:
+        # serialize model weights
+        return b""
+
+    def set_weights(self, weights: bytes) -> None:
+        # deserialize and apply global weights
+        pass
+
+    def local_train(self, data: pd.DataFrame, round_number: int, config: TrainingConfig) -> LocalTrainResult:
+        # train on local data, return updated weights + metrics
+        return LocalTrainResult(weights=self.get_weights(), sample_count=len(data), loss=0.0)
+
+    def local_inference(self, data: pd.DataFrame) -> InferenceResult:
+        # run inference, return aggregate distribution only
+        return InferenceResult(prediction_distribution={"low": len(data)}, sample_count=len(data))
+```
+
+Your `Dockerfile`:
+
+```dockerfile
+FROM python:3.11-slim
+WORKDIR /app
+RUN pip install strata_bridge torch --index-url https://download.pytorch.org/whl/cpu
+COPY model.py .
+CMD ["python", "-m", "strata_bridge.run"]
+```
+
+## Data Schema
+
+Your container receives local patient data at `/data/input.parquet` as a privacy-safe DataFrame. No PII is ever exposed.
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `patient_id` | str | Anonymized hash |
+| `age` | int | Computed from DOB |
+| `gender` | str | MALE / FEMALE / OTHER / UNKNOWN |
+| `admission_type` | str | EMERGENCY / ELECTIVE / TRANSFER / AMBULATORY |
+| `length_of_stay` | int | Days |
+| `primary_diagnosis` | str | ICD-10 code |
+| `drg_code` | str | SwissDRG code |
+| `drg_weight` | float | DRG cost weight |
+| `num_procedures` | int | Count |
+| `num_medications` | int | Count |
+| `num_lab_results` | int | Count |
+
+## Documentation
+
+Full sponsor guide: [BYOM_SPONSOR_SDK.md](https://github.com/intheris-health/strata-platform/blob/main/docs/user-guides/BYOM_SPONSOR_SDK.md)
+
+## License
+
+Proprietary — Intheris Health. Contact [intheris.health@gmail.com](mailto:intheris.health@gmail.com) for access.

strata_bridge-1.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "strata_bridge"
+version = "1.0.0"
+description = "Strata BYOM SDK — StrataBridge and StrataModelAdapter for sponsor containers"
+readme = "README.md"
+license = "LicenseRef-Proprietary"
+requires-python = ">=3.10"
+authors = [
+  { name = "Intheris Health", email = "intheris.health@gmail.com" },
+]
+keywords = ["federated-learning", "healthcare", "BYOM", "strata"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Topic :: Scientific/Engineering :: Medical Science Apps.",
+]
+dependencies = [
+  "pandas>=1.5",
+  "pyarrow>=12.0",
+]
+
+[project.urls]
+Homepage = "https://intheris.health"
+Documentation = "https://github.com/intheris-health/strata-platform/blob/main/docs/user-guides/BYOM_SPONSOR_SDK.md"
+"Bug Tracker" = "https://github.com/intheris-health/strata-platform/issues"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["strata_bridge*"]

strata_bridge-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

strata_bridge-1.0.0/src/strata_bridge/__init__.py

@@ -0,0 +1,28 @@
+"""
+strata_bridge — Strata BYOM SDK for sponsor containers.
+
+Quick start::
+
+    from strata_bridge import StrataBridge, StrataModelAdapter
+    from strata_bridge import ModelSpec, TrainingConfig, LocalTrainResult, InferenceResult
+"""
+
+from .adapter import (
+    ContainerResourceRequirements,
+    InferenceResult,
+    LocalTrainResult,
+    ModelSpec,
+    StrataModelAdapter,
+    TrainingConfig,
+)
+from .bridge import StrataBridge
+
+__all__ = [
+    "StrataBridge",
+    "StrataModelAdapter",
+    "ModelSpec",
+    "TrainingConfig",
+    "LocalTrainResult",
+    "InferenceResult",
+    "ContainerResourceRequirements",
+]

strata_bridge-1.0.0/src/strata_bridge/adapter.py

@@ -0,0 +1,231 @@
+# strata_bridge/adapter.py
+"""
+StrataModelAdapter — abstract base class that sponsors must implement.
+
+Strata calls these methods during federated training and inference rounds.
+All methods receive a pre-filtered, anonymised pandas DataFrame; no raw
+patient data ever leaves the hospital.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+from pydantic import BaseModel, Field
+
+
+# ---------------------------------------------------------------------------
+# Schemas passed to / returned from adapter methods
+# ---------------------------------------------------------------------------
+
+
+class ContainerResourceRequirements(BaseModel):
+    memory_mb: int = Field(default=8192, description="Memory limit in MB")
+    cpu_cores: float = Field(default=4.0, description="CPU core limit")
+    timeout_seconds: int = Field(default=3600, description="Max execution time")
+    gpu_enabled: bool = False
+
+
+class ModelSpec(BaseModel):
+    """Metadata returned by StrataModelAdapter.get_model_spec()."""
+
+    model_id: str
+    name: str
+    version: str = "1.0.0"
+    description: Optional[str] = None
+
+    # Columns your model expects in the input DataFrame
+    input_columns: List[str]
+    input_dtypes: Dict[str, str] = Field(default_factory=dict)
+
+    # Names of output tensors / prediction columns
+    output_names: List[str] = Field(default=["prediction"])
+
+    # Minimum number of local samples required to run
+    min_samples: int = 50
+
+    resource_requirements: ContainerResourceRequirements = Field(
+        default_factory=ContainerResourceRequirements
+    )
+
+
+class TrainingConfig(BaseModel):
+    """Hyperparameters for a single local training round."""
+
+    epochs: int = Field(default=1, ge=1, le=100)
+    batch_size: int = Field(default=32, ge=1, le=1024)
+    learning_rate: float = Field(default=0.001, ge=1e-6, le=1.0)
+    weight_decay: float = Field(default=0.0, ge=0.0)
+    dropout: float = Field(default=0.0, ge=0.0, le=0.9)
+
+    # Differential privacy (optional)
+    apply_differential_privacy: bool = False
+    dp_epsilon: float = Field(default=1.0, ge=0.1, le=10.0)
+    dp_delta: float = Field(default=1e-5)
+    dp_max_grad_norm: float = Field(default=1.0, ge=0.1)
+
+
+class LocalTrainResult(BaseModel):
+    """
+    Result returned by StrataModelAdapter.local_train().
+
+    Only weights and aggregate metrics leave the site — never per-patient data.
+    """
+
+    weights: bytes = Field(..., description="Serialised model weights after local training")
+    sample_count: int = Field(..., ge=1, description="Number of local samples used")
+    loss: float = Field(..., description="Final training loss")
+    metrics: Dict[str, float] = Field(default_factory=dict, description="Extra metrics")
+    epochs_completed: int = 1
+    early_stopped: bool = False
+
+
+class InferenceResult(BaseModel):
+    """
+    Result returned by StrataModelAdapter.local_inference().
+
+    Must contain only aggregated statistics — no per-patient predictions.
+    """
+
+    # Aggregate distribution of predictions (histogram, percentiles, class counts)
+    prediction_distribution: Dict[str, Any] = Field(default_factory=dict)
+
+    sample_count: int = 0
+    prediction_count: int = 0
+
+    # Optional privacy-safe binned result counts
+    binned_results: Optional[Dict[str, int]] = None
+    mean_confidence: Optional[float] = None
+
+
+# ---------------------------------------------------------------------------
+# Abstract adapter interface
+# ---------------------------------------------------------------------------
+
+
+class StrataModelAdapter(ABC):
+    """
+    Abstract interface that sponsors must implement in their Docker container.
+
+    Strata provides:
+        - Multi-site federation and round coordination
+        - Privacy protection (differential privacy, k-anonymity)
+        - Data governance and consent enforcement
+        - Regulatory compliance (LPD/GDPR)
+
+    Sponsors provide:
+        - Model architecture
+        - Training logic (local_train)
+        - Inference logic (local_inference)
+
+    Minimal implementation skeleton::
+
+        class MyModel(StrataModelAdapter):
+
+            def __init__(self):
+                self.model = None  # your model object
+
+            def get_model_spec(self) -> ModelSpec:
+                return ModelSpec(
+                    model_id="my-model-v1",
+                    name="My Federated Model",
+                    version="1.0.0",
+                    input_columns=["age", "drg_weight", "length_of_stay"],
+                    min_samples=100,
+                )
+
+            def initialize(self, config: dict) -> None:
+                # Build / reset model architecture
+                ...
+
+            def get_weights(self) -> bytes:
+                import pickle
+                return pickle.dumps(self.model.state_dict())
+
+            def set_weights(self, weights: bytes) -> None:
+                import pickle
+                self.model.load_state_dict(pickle.loads(weights))
+
+            def local_train(self, data, round_number, config) -> LocalTrainResult:
+                # Train on data, return weights + metrics
+                ...
+
+            def local_inference(self, data) -> InferenceResult:
+                # Run predictions, return aggregated distribution only
+                ...
+    """
+
+    @abstractmethod
+    def get_model_spec(self) -> ModelSpec:
+        """Return model metadata and resource requirements."""
+
+    @abstractmethod
+    def initialize(self, config: Dict[str, Any]) -> None:
+        """
+        Initialise model architecture.
+
+        Called once before any training or inference.
+
+        Args:
+            config: The full config dict from StrataBridge.get_config().
+        """
+
+    @abstractmethod
+    def get_weights(self) -> bytes:
+        """Serialise current model weights to bytes."""
+
+    @abstractmethod
+    def set_weights(self, weights: bytes) -> None:
+        """Load model weights from bytes (e.g. from the previous global round)."""
+
+    @abstractmethod
+    def local_train(
+        self,
+        data: pd.DataFrame,
+        round_number: int,
+        config: TrainingConfig,
+    ) -> LocalTrainResult:
+        """
+        Execute one local training round.
+
+        IMPORTANT: ``data`` is a read-only view of local patient records.
+        It must never be transmitted or persisted outside this function.
+        Only weights and aggregate metrics should be returned.
+
+        Args:
+            data:         Local cohort DataFrame (14 anonymised columns).
+            round_number: Current federated round (0-based).
+            config:       Training hyperparameters.
+
+        Returns:
+            LocalTrainResult with updated weights and aggregate metrics.
+        """
+
+    @abstractmethod
+    def local_inference(self, data: pd.DataFrame) -> InferenceResult:
+        """
+        Run inference on local data.
+
+        Returns aggregated prediction statistics only — no per-patient rows.
+
+        Args:
+            data: Local cohort DataFrame.
+
+        Returns:
+            InferenceResult with prediction distribution.
+        """
+
+    def local_evaluate(
+        self,
+        data: pd.DataFrame,
+        labels: pd.Series,
+    ) -> Dict[str, float]:
+        """
+        Optional: evaluate model on labelled local data.
+
+        Returns aggregate evaluation metrics (accuracy, AUC, etc.).
+        Not required for Phase 1 / Phase 2.
+        """
+        raise NotImplementedError("local_evaluate is optional and not implemented")

strata_bridge-1.0.0/src/strata_bridge/bridge.py

@@ -0,0 +1,147 @@
+# strata_bridge/bridge.py
+"""
+StrataBridge — file-based communication channel between the Strata host and
+a sponsor's container.
+
+The host mounts two directories into the container:
+  /data    (read-only)  — input.parquet, weights.bin, config.json
+  /output  (read-write) — weights.bin (required), metrics.json (optional)
+
+Sponsors use this class to read inputs and write outputs.  There is no
+network access inside the container; all I/O goes through these mounts.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict
+
+import pandas as pd
+
+
+class StrataBridge:
+    """
+    Static helpers for reading inputs from /data and writing outputs to /output.
+
+    All methods are static — import and call directly without instantiation.
+
+    Example::
+
+        from strata_bridge import StrataBridge
+
+        data = StrataBridge.get_data()
+        config = StrataBridge.get_config()
+        weights = StrataBridge.get_weights()
+
+        # ... train ...
+
+        StrataBridge.save_weights(updated_weights_bytes)
+        StrataBridge.save_metrics({"loss": 0.32, "samples": 420})
+    """
+
+    # Paths inside the container (configured by the host)
+    DATA_PATH: str = os.environ.get("STRATA_DATA_PATH", "/data/input.parquet")
+    WEIGHTS_IN_PATH: str = os.environ.get("STRATA_WEIGHTS_IN_PATH", "/data/weights.bin")
+    CONFIG_PATH: str = os.environ.get("STRATA_CONFIG_PATH", "/data/config.json")
+    WEIGHTS_OUT_PATH: str = os.environ.get("STRATA_WEIGHTS_OUT_PATH", "/output/weights.bin")
+    METRICS_PATH: str = os.environ.get("STRATA_METRICS_PATH", "/output/metrics.json")
+
+    # ---------------------------------------------------------------------------
+    # Inputs
+    # ---------------------------------------------------------------------------
+
+    @staticmethod
+    def get_data() -> pd.DataFrame:
+        """
+        Load the local patient data as a DataFrame.
+
+        The DataFrame is pre-filtered to the study cohort and contains only
+        privacy-safe, non-PII columns.  It is always read-only from the
+        container's perspective.
+
+        Returns:
+            pandas DataFrame with 14 anonymised columns (see data schema docs).
+        """
+        return pd.read_parquet(StrataBridge.DATA_PATH)
+
+    @staticmethod
+    def get_weights() -> bytes:
+        """
+        Load current global model weights sent by the Control Plane.
+
+        For round 0 the file is still present but empty (b""), so always
+        check ``len(weights) > 0`` before loading.
+
+        Returns:
+            Raw bytes of the serialised weights, or b"" for round 0.
+        """
+        path = StrataBridge.WEIGHTS_IN_PATH
+        if not os.path.exists(path):
+            return b""
+        with open(path, "rb") as fh:
+            return fh.read()
+
+    @staticmethod
+    def get_config() -> Dict[str, Any]:
+        """
+        Load the training / inference configuration dict.
+
+        Standard keys provided by Strata:
+            mode          "train" | "inference"
+            round_number  int (0-based)
+            epochs        int
+            batch_size    int
+            learning_rate float
+            adapter_class str  fully-qualified class to instantiate
+            site_id       str
+
+        Returns:
+            dict with training hyperparameters and run metadata.
+        """
+        with open(StrataBridge.CONFIG_PATH, "r") as fh:
+            return json.load(fh)
+
+    # ---------------------------------------------------------------------------
+    # Outputs
+    # ---------------------------------------------------------------------------
+
+    @staticmethod
+    def save_weights(weights: bytes) -> None:
+        """
+        Write updated model weights to /output/weights.bin.
+
+        This file **must** be written before the container exits, otherwise
+        the host will treat the round as failed.
+
+        Args:
+            weights: Serialised model weights (e.g. pickle.dumps(state_dict)).
+        """
+        os.makedirs(os.path.dirname(StrataBridge.WEIGHTS_OUT_PATH), exist_ok=True)
+        with open(StrataBridge.WEIGHTS_OUT_PATH, "wb") as fh:
+            fh.write(weights)
+
+    @staticmethod
+    def save_metrics(metrics: Dict[str, Any]) -> None:
+        """
+        Write training / inference metrics to /output/metrics.json.
+
+        Optional but strongly recommended.  Strata reads this file and
+        returns the values alongside the aggregated weights.
+
+        Recommended keys:
+            loss      float — final training loss
+            samples   int   — number of local samples used
+            accuracy  float — (optional) accuracy or other metric
+
+        Args:
+            metrics: JSON-serialisable dict.
+        """
+        os.makedirs(os.path.dirname(StrataBridge.METRICS_PATH), exist_ok=True)
+        with open(StrataBridge.METRICS_PATH, "w") as fh:
+            json.dump(metrics, fh)
+
+    @staticmethod
+    def log(message: str) -> None:
+        """Print a log message to stdout (captured by Docker and returned on error)."""
+        print(f"[strata_bridge] {message}", flush=True)

strata_bridge-1.0.0/src/strata_bridge/run.py

@@ -0,0 +1,148 @@
+# strata_bridge/run.py
+"""
+Container entrypoint dispatcher.
+
+Strata runs this module as ``python -m strata_bridge.run`` inside the
+sponsor's Docker container.  It reads config.json from /data, dynamically
+imports the sponsor's StrataModelAdapter subclass, and calls either
+local_train() or local_inference() depending on the ``mode`` field.
+
+The sponsor does NOT need to modify this file — they implement their adapter
+class and declare its fully-qualified name in their container registration
+(adapter_class field, default: "model.MyModel").
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+import traceback
+
+from .adapter import InferenceResult, LocalTrainResult, TrainingConfig
+from .bridge import StrataBridge
+
+
+def _import_adapter(adapter_class: str):
+    """Dynamically import sponsor's adapter class."""
+    module_name, class_name = adapter_class.rsplit(".", 1)
+    try:
+        module = importlib.import_module(module_name)
+    except ModuleNotFoundError as exc:
+        raise ImportError(
+            f"Could not import module '{module_name}' for adapter '{adapter_class}'. "
+            f"Make sure the module is on the Python path inside the container. "
+            f"Original error: {exc}"
+        ) from exc
+
+    try:
+        cls = getattr(module, class_name)
+    except AttributeError:
+        raise ImportError(
+            f"Module '{module_name}' has no class '{class_name}'. "
+            f"Check the adapter_class field in your model registration."
+        )
+
+    return cls
+
+
+def main() -> None:
+    StrataBridge.log("Strata Bridge starting…")
+
+    try:
+        config = StrataBridge.get_config()
+    except Exception as exc:
+        print(f"[strata_bridge] FATAL: could not read config.json: {exc}", flush=True)
+        sys.exit(1)
+
+    mode = config.get("mode", "train")
+    adapter_class = config.get("adapter_class", "model.MyModel")
+    round_number = int(config.get("round_number", 0))
+
+    StrataBridge.log(f"mode={mode}  round={round_number}  adapter={adapter_class}")
+
+    try:
+        AdapterClass = _import_adapter(adapter_class)
+        adapter = AdapterClass()
+        adapter.initialize(config)
+    except Exception as exc:
+        print(f"[strata_bridge] FATAL: failed to initialise adapter: {exc}", flush=True)
+        traceback.print_exc()
+        sys.exit(1)
+
+    # Load global weights (may be empty on round 0)
+    try:
+        weights_in = StrataBridge.get_weights()
+        if weights_in:
+            adapter.set_weights(weights_in)
+            StrataBridge.log(f"Loaded global weights ({len(weights_in):,} bytes)")
+        else:
+            StrataBridge.log("No global weights provided (round 0 — using fresh model)")
+    except Exception as exc:
+        print(f"[strata_bridge] FATAL: failed to load weights: {exc}", flush=True)
+        traceback.print_exc()
+        sys.exit(1)
+
+    try:
+        data = StrataBridge.get_data()
+        StrataBridge.log(f"Loaded data: {len(data)} rows × {len(data.columns)} columns")
+    except Exception as exc:
+        print(f"[strata_bridge] FATAL: failed to load data: {exc}", flush=True)
+        traceback.print_exc()
+        sys.exit(1)
+
+    if mode == "train":
+        try:
+            train_cfg = TrainingConfig(
+                epochs=int(config.get("epochs", 1)),
+                batch_size=int(config.get("batch_size", 32)),
+                learning_rate=float(config.get("learning_rate", 0.001)),
+            )
+            result: LocalTrainResult = adapter.local_train(data, round_number, train_cfg)
+        except Exception as exc:
+            print(f"[strata_bridge] FATAL: local_train failed: {exc}", flush=True)
+            traceback.print_exc()
+            sys.exit(1)
+
+        StrataBridge.save_weights(result.weights)
+        StrataBridge.save_metrics(
+            {
+                "loss": result.loss,
+                "samples": result.sample_count,
+                "epochs_completed": result.epochs_completed,
+                **result.metrics,
+            }
+        )
+        StrataBridge.log(
+            f"Training complete — loss={result.loss:.4f}  samples={result.sample_count}"
+        )
+
+    elif mode == "inference":
+        try:
+            result_inf: InferenceResult = adapter.local_inference(data)
+        except Exception as exc:
+            print(f"[strata_bridge] FATAL: local_inference failed: {exc}", flush=True)
+            traceback.print_exc()
+            sys.exit(1)
+
+        # Inference mode: write a placeholder weights file (required by host) and metrics
+        StrataBridge.save_weights(b"inference-mode")
+        StrataBridge.save_metrics(
+            {
+                "mode": "inference",
+                "sample_count": result_inf.sample_count,
+                **result_inf.prediction_distribution,
+            }
+        )
+        StrataBridge.log(
+            f"Inference complete — {result_inf.sample_count} samples processed"
+        )
+
+    else:
+        print(f"[strata_bridge] FATAL: unknown mode '{mode}'", flush=True)
+        sys.exit(1)
+
+    StrataBridge.log("Done.")
+
+
+if __name__ == "__main__":
+    main()

strata_bridge-1.0.0/src/strata_bridge.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: strata_bridge
+Version: 1.0.0
+Summary: Strata BYOM SDK — StrataBridge and StrataModelAdapter for sponsor containers
+Author-email: Intheris Health <intheris.health@gmail.com>
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://intheris.health
+Project-URL: Documentation, https://github.com/intheris-health/strata-platform/blob/main/docs/user-guides/BYOM_SPONSOR_SDK.md
+Project-URL: Bug Tracker, https://github.com/intheris-health/strata-platform/issues
+Keywords: federated-learning,healthcare,BYOM,strata
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.5
+Requires-Dist: pyarrow>=12.0
+
+# strata_bridge
+
+**Strata BYOM SDK** — the bridge between your ML model and the [Strata federated healthcare platform](https://intheris.health) by Intheris Health.
+
+## Overview
+
+`strata_bridge` is the Python package your Docker container uses when participating in federated training or inference across hospital sites. It provides:
+
+- **`StrataBridge`** — file-based I/O helpers (`/data` → `/output`)
+- **`StrataModelAdapter`** — the interface your model class must implement
+- **`run.py`** — the container entrypoint dispatcher (`python -m strata_bridge.run`)
+
+Core principle: **algorithms travel, data stays local.** Patient data never leaves the hospital; your container receives a privacy-safe DataFrame and returns only model weights or aggregate statistics.
+
+## Installation
+
+```bash
+pip install strata_bridge
+```
+
+## Quick Start
+
+```python
+from strata_bridge import StrataModelAdapter, ModelSpec, TrainingConfig, LocalTrainResult, InferenceResult
+import pandas as pd
+
+class MyModel(StrataModelAdapter):
+
+    def get_model_spec(self) -> ModelSpec:
+        return ModelSpec(
+            model_id="my-model-v1",
+            name="My Federated Model",
+            version="1.0.0",
+            input_columns=["age", "length_of_stay", "drg_weight"],
+            output_names=["risk_score"],
+            min_samples=50,
+        )
+
+    def initialize(self, config: dict) -> None:
+        # load or build your model here
+        pass
+
+    def get_weights(self) -> bytes:
+        # serialize model weights
+        return b""
+
+    def set_weights(self, weights: bytes) -> None:
+        # deserialize and apply global weights
+        pass
+
+    def local_train(self, data: pd.DataFrame, round_number: int, config: TrainingConfig) -> LocalTrainResult:
+        # train on local data, return updated weights + metrics
+        return LocalTrainResult(weights=self.get_weights(), sample_count=len(data), loss=0.0)
+
+    def local_inference(self, data: pd.DataFrame) -> InferenceResult:
+        # run inference, return aggregate distribution only
+        return InferenceResult(prediction_distribution={"low": len(data)}, sample_count=len(data))
+```
+
+Your `Dockerfile`:
+
+```dockerfile
+FROM python:3.11-slim
+WORKDIR /app
+RUN pip install strata_bridge torch --index-url https://download.pytorch.org/whl/cpu
+COPY model.py .
+CMD ["python", "-m", "strata_bridge.run"]
+```
+
+## Data Schema
+
+Your container receives local patient data at `/data/input.parquet` as a privacy-safe DataFrame. No PII is ever exposed.
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `patient_id` | str | Anonymized hash |
+| `age` | int | Computed from DOB |
+| `gender` | str | MALE / FEMALE / OTHER / UNKNOWN |
+| `admission_type` | str | EMERGENCY / ELECTIVE / TRANSFER / AMBULATORY |
+| `length_of_stay` | int | Days |
+| `primary_diagnosis` | str | ICD-10 code |
+| `drg_code` | str | SwissDRG code |
+| `drg_weight` | float | DRG cost weight |
+| `num_procedures` | int | Count |
+| `num_medications` | int | Count |
+| `num_lab_results` | int | Count |
+
+## Documentation
+
+Full sponsor guide: [BYOM_SPONSOR_SDK.md](https://github.com/intheris-health/strata-platform/blob/main/docs/user-guides/BYOM_SPONSOR_SDK.md)
+
+## License
+
+Proprietary — Intheris Health. Contact [intheris.health@gmail.com](mailto:intheris.health@gmail.com) for access.

strata_bridge-1.0.0/src/strata_bridge.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/strata_bridge/__init__.py
+src/strata_bridge/adapter.py
+src/strata_bridge/bridge.py
+src/strata_bridge/run.py
+src/strata_bridge.egg-info/PKG-INFO
+src/strata_bridge.egg-info/SOURCES.txt
+src/strata_bridge.egg-info/dependency_links.txt
+src/strata_bridge.egg-info/requires.txt
+src/strata_bridge.egg-info/top_level.txt

strata_bridge-1.0.0/src/strata_bridge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

strata_bridge-1.0.0/src/strata_bridge.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pandas>=1.5
+pyarrow>=12.0

strata_bridge-1.0.0/src/strata_bridge.egg-info/top_level.txt

@@ -0,0 +1 @@
+strata_bridge