proxyml-core 0.1.0__py3-none-any.whl

proxyml_core/__init__.py

@@ -0,0 +1,45 @@
+from proxyml_core._version import (
+    EXPORT_SCHEMA_VERSION,
+    IncompatibleExportVersionError,
+    check_compatible,
+)
+from proxyml_core.export import (
+    ExportError,
+    FeatureExportEntry,
+    PerClassCoefficients,
+    PerClassIntercept,
+    SurrogateExport,
+    predict_from_export,
+    score_export,
+)
+from proxyml_core.schema import (
+    CategoricalFeature,
+    CategoricalOrdinalFeature,
+    ContinuousFeature,
+    CountFeature,
+    Feature,
+    FeatureSchema,
+    FeatureValidationError,
+    NumericOrdinalFeature,
+)
+
+__all__ = [
+    "Feature",
+    "FeatureSchema",
+    "FeatureValidationError",
+    "ContinuousFeature",
+    "CategoricalFeature",
+    "CategoricalOrdinalFeature",
+    "NumericOrdinalFeature",
+    "CountFeature",
+    "SurrogateExport",
+    "FeatureExportEntry",
+    "PerClassCoefficients",
+    "PerClassIntercept",
+    "ExportError",
+    "score_export",
+    "predict_from_export",
+    "EXPORT_SCHEMA_VERSION",
+    "IncompatibleExportVersionError",
+    "check_compatible",
+]

proxyml_core/_version.py

@@ -0,0 +1,21 @@
+"""Export-format versioning.
+
+The export JSON is a versioned contract: every artifact produced by
+``extract_export_data``/``SurrogateExport.to_dict`` is stamped with
+``EXPORT_SCHEMA_VERSION``, and loaders check compatibility before trusting
+the payload shape. This is what lets a client and server built against
+different versions of this library still register/diff/score models: as
+long as a loader's version is >= the payload's stamped version, it knows
+how to read that (older) shape.
+"""
+
+EXPORT_SCHEMA_VERSION = 1
+
+
+class IncompatibleExportVersionError(ValueError):
+    """Raised when an export payload is newer than this library understands."""
+
+
+def check_compatible(payload_version: int) -> bool:
+    """Return True if this library can read a payload stamped with ``payload_version``."""
+    return payload_version <= EXPORT_SCHEMA_VERSION

proxyml_core/export.py

@@ -0,0 +1,238 @@
+"""The export JSON contract and its arithmetic scorer.
+
+Pure: stdlib + numpy only. ``extract_export_data`` (in
+``proxyml_core.modeling.extract``, which requires sklearn) *produces* a
+``SurrogateExport``; everything in this module — reading, serializing, and
+scoring one — needs nothing beyond arithmetic. That's deliberate: it's the
+"your model is yours" scorer — a user can reconstruct predictions with zero
+sklearn, the same arithmetic on the same JSON, whether the artifact came
+from a server-trained surrogate or a locally-trained challenger.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import asdict, dataclass
+from typing import Any, Mapping
+
+from proxyml_core._version import (
+    EXPORT_SCHEMA_VERSION,
+    IncompatibleExportVersionError,
+    check_compatible,
+)
+
+SCORING_NOTE = (
+    "Coefficients are in the preprocessed feature space. "
+    "Continuous: x_scaled = (x - scaler_mean) / scaler_scale. "
+    "Count: x_scaled = (log1p(x) - scaler_mean) / scaler_scale. "
+    "Categorical: one-hot encoded — ohe_categories[i] is the category for coefficient[i]. "
+    "Ordinal: encoded as rank (0-based) per ordinal_categories order. "
+    "score = dot(preprocessed_x, coefficients) + intercept. "
+    "For binary classification score is a logit (sigmoid for probability). "
+    "For multiclass, compute one score per class and take the argmax."
+)
+
+
+class ExportError(ValueError):
+    """Raised for malformed export payloads or scoring inputs."""
+
+
+@dataclass(kw_only=True)
+class PerClassCoefficients:
+    class_label: str
+    coefficient: float | None = None
+    category_coefficients: list[float] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "PerClassCoefficients":
+        return cls(**d)
+
+
+@dataclass(kw_only=True)
+class FeatureExportEntry:
+    name: str
+    type: str
+    scaler_mean: float | None = None
+    scaler_scale: float | None = None
+    ohe_categories: list[str] | None = None
+    ordinal_categories: list[str] | None = None
+    coefficient: float | None = None
+    category_coefficients: list[float] | None = None
+    per_class_coefficients: list[PerClassCoefficients] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        d = asdict(self)
+        if self.per_class_coefficients is not None:
+            d["per_class_coefficients"] = [c.to_dict() for c in self.per_class_coefficients]
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "FeatureExportEntry":
+        d = dict(d)
+        per_class = d.get("per_class_coefficients")
+        if per_class is not None:
+            d["per_class_coefficients"] = [PerClassCoefficients.from_dict(c) for c in per_class]
+        return cls(**d)
+
+
+@dataclass(kw_only=True)
+class PerClassIntercept:
+    class_label: str
+    intercept: float
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "PerClassIntercept":
+        return cls(**d)
+
+
+@dataclass(kw_only=True)
+class SurrogateExport:
+    """The full export contract.
+
+    ``extract_export_data`` populates only the scoring-relevant fields
+    (``task``, ``classes``, ``intercept``, ``per_class_intercepts``,
+    ``features``) — a caller with run metadata (version, trained_at, etc.,
+    e.g. a backend endpoint) fills in the rest via ``dataclasses.replace``.
+    """
+
+    task: str
+    features: list[FeatureExportEntry]
+    classes: list[str] | None = None
+    intercept: float | None = None
+    per_class_intercepts: list[PerClassIntercept] | None = None
+
+    version: str | None = None
+    trained_at: str | None = None
+    schema_name: str | None = None
+    name: str | None = None
+    comments: str | None = None
+    metrics: dict[str, float] | None = None
+    hyperparameters: dict | None = None
+    run_id: str | None = None
+    schema_definition: list[dict] | None = None
+    schema_warning: str | None = None
+    note: str = SCORING_NOTE
+    export_schema_version: int = EXPORT_SCHEMA_VERSION
+
+    def to_dict(self) -> dict[str, Any]:
+        d = asdict(self)
+        d["features"] = [f.to_dict() for f in self.features]
+        if self.per_class_intercepts is not None:
+            d["per_class_intercepts"] = [p.to_dict() for p in self.per_class_intercepts]
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "SurrogateExport":
+        payload_version = d.get("export_schema_version", 1)
+        if not check_compatible(payload_version):
+            raise IncompatibleExportVersionError(
+                f"Export payload is at version {payload_version}, but this copy of "
+                f"proxyml-core only understands up to version {EXPORT_SCHEMA_VERSION}. "
+                "Upgrade proxyml-core to read it."
+            )
+        d = dict(d)
+        d["features"] = [FeatureExportEntry.from_dict(f) for f in d["features"]]
+        per_class_intercepts = d.get("per_class_intercepts")
+        if per_class_intercepts is not None:
+            d["per_class_intercepts"] = [PerClassIntercept.from_dict(p) for p in per_class_intercepts]
+        return cls(**d)
+
+
+def _feature_value(sample: Mapping[str, Any], name: str, strict: bool) -> Any:
+    if name not in sample:
+        if strict:
+            raise ExportError(f"Missing value for feature {name!r}")
+        return None
+    return sample[name]
+
+
+def _contribution(entry: FeatureExportEntry, value: Any, class_index: int | None) -> float:
+    if entry.type in ("continuous", "count"):
+        x = float(value)
+        if entry.type == "count":
+            x = math.log1p(x)
+        x_scaled = (x - entry.scaler_mean) / entry.scaler_scale
+        coef = (
+            entry.per_class_coefficients[class_index].coefficient
+            if class_index is not None
+            else entry.coefficient
+        )
+        return coef * x_scaled
+    if entry.type == "categorical":
+        categories = entry.ohe_categories or []
+        try:
+            idx = categories.index(str(value))
+        except ValueError:
+            return 0.0  # unknown category -> all-zero OHE row, matches handle_unknown="ignore"
+        coefs = (
+            entry.per_class_coefficients[class_index].category_coefficients
+            if class_index is not None
+            else entry.category_coefficients
+        )
+        return coefs[idx]
+    if entry.type in ("categorical_ordinal", "numeric_ordinal"):
+        categories = entry.ordinal_categories or []
+        try:
+            rank = categories.index(str(value))
+        except ValueError:
+            rank = -1  # unknown -> OrdinalEncoder(unknown_value=-1)
+        coef = (
+            entry.per_class_coefficients[class_index].coefficient
+            if class_index is not None
+            else entry.coefficient
+        )
+        return coef * rank
+    raise ExportError(f"Unknown feature type: {entry.type!r}")
+
+
+def score_export(
+    export: SurrogateExport, sample: Mapping[str, Any], *, strict: bool = True
+) -> float | dict[str, float]:
+    """Compute the raw linear score(s) for ``sample`` against ``export``.
+
+    Regression / binary classification return a single float (a logit, in
+    the binary case). Multiclass returns a ``{class_label: score}`` dict.
+    Missing feature values raise by default (``strict=True``); pass
+    ``strict=False`` to silently skip them (their contribution is treated
+    as 0), e.g. when intentionally scoring on a reduced feature subset.
+    """
+    is_multiclass = export.per_class_intercepts is not None
+    if is_multiclass:
+        scores: dict[str, float] = {}
+        for i, pci in enumerate(export.per_class_intercepts):
+            total = pci.intercept
+            for entry in export.features:
+                value = _feature_value(sample, entry.name, strict)
+                if value is None:
+                    continue
+                total += _contribution(entry, value, i)
+            scores[pci.class_label] = total
+        return scores
+
+    total = export.intercept or 0.0
+    for entry in export.features:
+        value = _feature_value(sample, entry.name, strict)
+        if value is None:
+            continue
+        total += _contribution(entry, value, None)
+    return total
+
+
+def predict_from_export(
+    export: SurrogateExport, sample: Mapping[str, Any], *, strict: bool = True
+) -> float | str:
+    """Reconstruct the prediction ``/surrogate/predict`` would return, purely from the export."""
+    score = score_export(export, sample, strict=strict)
+    if export.task == "regression":
+        return score
+    if isinstance(score, dict):
+        return max(score, key=score.get)
+    prob = 1.0 / (1.0 + math.exp(-score))
+    classes = export.classes or ["0", "1"]
+    return classes[1] if prob >= 0.5 else classes[0]

proxyml_core/modeling/__init__.py

@@ -0,0 +1,21 @@
+from proxyml_core.modeling.estimators import (
+    binarize_if_probabilities,
+    extract_hyperparameters,
+    get_default_classifier,
+    get_default_regressor,
+    is_classification,
+    to_json_safe,
+)
+from proxyml_core.modeling.extract import extract_export_data
+from proxyml_core.modeling.preprocess import build_preprocessor
+
+__all__ = [
+    "build_preprocessor",
+    "get_default_classifier",
+    "get_default_regressor",
+    "is_classification",
+    "binarize_if_probabilities",
+    "extract_hyperparameters",
+    "to_json_safe",
+    "extract_export_data",
+]

proxyml_core/modeling/estimators.py

@@ -0,0 +1,68 @@
+"""Default estimators and task-type inference. Requires ``proxyml-core[modeling]``."""
+
+from __future__ import annotations
+
+import numpy as np
+from sklearn.base import BaseEstimator
+from sklearn.linear_model import LogisticRegressionCV, RidgeCV
+
+
+def to_json_safe(v):
+    if isinstance(v, np.ndarray):
+        return v.tolist()
+    if isinstance(v, np.generic):
+        return v.item()
+    if isinstance(v, (list, tuple)):
+        return [to_json_safe(x) for x in v]
+    return v
+
+
+def extract_hyperparameters(estimator: BaseEstimator) -> dict:
+    """Return configured and CV-selected hyperparameters from a fitted estimator."""
+    params = {k: to_json_safe(v) for k, v in estimator.get_params().items()}
+    for attr in ("alpha_", "C_", "l1_ratio_"):
+        if hasattr(estimator, attr):
+            params[attr] = to_json_safe(getattr(estimator, attr))
+    return params
+
+
+def is_classification(predictions: np.ndarray) -> bool:
+    """Infer task type from predictions.
+
+    Cardinality is the only signal available — there's no way to distinguish a
+    classifier's probability outputs from a genuine continuous regression target
+    by value inspection alone, so callers should let users override this guess.
+    """
+    return predictions.dtype == object or len(np.unique(predictions)) <= 20
+
+
+def binarize_if_probabilities(predictions: np.ndarray) -> np.ndarray:
+    """Threshold probability outputs into hard 0/1 labels for classification.
+
+    A classifier needs discrete labels — if a caller submits raw probabilities
+    (e.g. predict_proba output) for a binary task, every unique probability would
+    otherwise be treated as its own class. Treat >=0.5 as the positive class.
+    Already-discrete labels (ints, or non-numeric class names) pass through unchanged.
+    """
+    if predictions.dtype.kind not in "iuf":  # not int/uint/float — already discrete labels
+        return predictions
+    as_float = predictions.astype(float)
+    if np.all(as_float == as_float.astype(int)):
+        return predictions
+    return (as_float >= 0.5).astype(int)
+
+
+def get_default_classifier() -> BaseEstimator:
+    return LogisticRegressionCV(
+        solver="lbfgs",
+        l1_ratios=(0,),
+        class_weight="balanced",
+        max_iter=500,
+        cv=5,
+        n_jobs=-1,
+        use_legacy_attributes=False,
+    )
+
+
+def get_default_regressor() -> BaseEstimator:
+    return RidgeCV(alphas=np.logspace(-3, 4, 15), cv=5)

proxyml_core/modeling/extract.py

@@ -0,0 +1,120 @@
+"""Extract the export contract from a fitted pipeline. Requires ``proxyml-core[modeling]``."""
+
+from __future__ import annotations
+
+import numpy as np
+from sklearn.pipeline import Pipeline
+
+from proxyml_core.export import FeatureExportEntry, PerClassCoefficients, PerClassIntercept, SurrogateExport
+from proxyml_core.schema import Feature
+
+
+def extract_export_data(pipeline: Pipeline, features: list[Feature], task: str) -> SurrogateExport:
+    """Extract everything needed to reconstruct scoring outside the API.
+
+    Returns a ``SurrogateExport`` with only the scoring-relevant fields
+    populated (``task``, ``classes``, ``intercept``, ``per_class_intercepts``,
+    ``features``); a caller with run metadata (version, trained_at, etc.)
+    should fill in the rest via ``dataclasses.replace``.
+    """
+    preprocessor = pipeline.named_steps["preprocessor"]
+    estimator = pipeline.named_steps["estimator"]
+
+    coef = np.atleast_2d(np.asarray(estimator.coef_))
+    intercepts = np.atleast_1d(estimator.intercept_)
+
+    is_multiclass = task == "classification" and coef.shape[0] > 1
+    classes = [str(c) for c in estimator.classes_] if task == "classification" else None
+
+    # Walk the ColumnTransformer in output order to build per-feature segments.
+    segments: list[dict] = []
+    for t_name, t_obj, col_indices in preprocessor.transformers_:
+        if t_name == "remainder":
+            continue
+        if t_name == "cat":
+            encoder = t_obj.named_steps["encoder"]
+            for local_i, global_i in enumerate(col_indices):
+                segments.append({
+                    "feature": features[global_i],
+                    "n_cols": len(encoder.categories_[local_i]),
+                    "ohe_categories": [str(c) for c in encoder.categories_[local_i]],
+                    "scaler_mean": None,
+                    "scaler_scale": None,
+                    "ordinal_categories": None,
+                })
+        elif t_name in ("num", "count"):
+            scaler = t_obj.named_steps["scaler"]
+            for local_i, global_i in enumerate(col_indices):
+                segments.append({
+                    "feature": features[global_i],
+                    "n_cols": 1,
+                    "ohe_categories": None,
+                    "scaler_mean": float(scaler.mean_[local_i]),
+                    "scaler_scale": float(scaler.scale_[local_i]),
+                    "ordinal_categories": None,
+                })
+        elif t_name == "ord":
+            encoder = t_obj.named_steps["encoder"]
+            for local_i, global_i in enumerate(col_indices):
+                segments.append({
+                    "feature": features[global_i],
+                    "n_cols": 1,
+                    "ohe_categories": None,
+                    "scaler_mean": None,
+                    "scaler_scale": None,
+                    "ordinal_categories": [str(c) for c in encoder.categories_[local_i]],
+                })
+
+    feature_entries: list[FeatureExportEntry] = []
+    pos = 0
+    for seg in segments:
+        n_cols = seg["n_cols"]
+        feat = seg["feature"]
+        entry_kwargs: dict = {
+            "name": feat.name,
+            "type": feat.type,
+            "scaler_mean": seg["scaler_mean"],
+            "scaler_scale": seg["scaler_scale"],
+            "ohe_categories": seg["ohe_categories"],
+            "ordinal_categories": seg["ordinal_categories"],
+        }
+        if is_multiclass:
+            entry_kwargs["coefficient"] = None
+            entry_kwargs["category_coefficients"] = None
+            entry_kwargs["per_class_coefficients"] = [
+                PerClassCoefficients(
+                    class_label=classes[i],
+                    coefficient=float(coef[i, pos]) if n_cols == 1 else None,
+                    category_coefficients=coef[i, pos:pos + n_cols].tolist() if n_cols > 1 else None,
+                )
+                for i in range(len(classes))
+            ]
+        else:
+            chunk = coef[0, pos:pos + n_cols]
+            entry_kwargs["per_class_coefficients"] = None
+            if n_cols == 1:
+                entry_kwargs["coefficient"] = float(chunk[0])
+                entry_kwargs["category_coefficients"] = None
+            else:
+                entry_kwargs["coefficient"] = None
+                entry_kwargs["category_coefficients"] = chunk.tolist()
+        feature_entries.append(FeatureExportEntry(**entry_kwargs))
+        pos += n_cols
+
+    if is_multiclass:
+        intercept = None
+        per_class_intercepts = [
+            PerClassIntercept(class_label=classes[i], intercept=float(intercepts[i]))
+            for i in range(len(classes))
+        ]
+    else:
+        intercept = float(intercepts[0])
+        per_class_intercepts = None
+
+    return SurrogateExport(
+        task=task,
+        classes=classes,
+        intercept=intercept,
+        per_class_intercepts=per_class_intercepts,
+        features=feature_entries,
+    )

proxyml_core/modeling/preprocess.py

@@ -0,0 +1,75 @@
+"""Build the sklearn ColumnTransformer for a feature schema.
+
+Requires ``proxyml-core[modeling]``.
+"""
+
+from __future__ import annotations
+
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import (
+    FunctionTransformer,
+    OneHotEncoder,
+    OrdinalEncoder,
+    StandardScaler,
+)
+import numpy as np
+
+from proxyml_core.schema import (
+    CategoricalFeature,
+    CategoricalOrdinalFeature,
+    ContinuousFeature,
+    CountFeature,
+    Feature,
+    NumericOrdinalFeature,
+)
+
+
+def build_preprocessor(features: list[Feature]) -> ColumnTransformer:
+    numeric_indices = [i for i, f in enumerate(features) if isinstance(f, ContinuousFeature)]
+    categorical_indices = [i for i, f in enumerate(features) if isinstance(f, CategoricalFeature)]
+    ordinal_indices = [
+        i for i, f in enumerate(features)
+        if isinstance(f, (CategoricalOrdinalFeature, NumericOrdinalFeature))
+    ]
+    count_indices = [i for i, f in enumerate(features) if isinstance(f, CountFeature)]
+
+    transformers = []
+
+    if numeric_indices:
+        numeric_transformer = Pipeline(steps=[
+            ("imputer", SimpleImputer(strategy="median")),
+            ("scaler", StandardScaler())
+        ])
+        transformers.append(("num", numeric_transformer, numeric_indices))
+
+    if categorical_indices:
+        categorical_transformer = Pipeline(steps=[
+            ("encoder", OneHotEncoder(handle_unknown="ignore", sparse_output=False))
+        ])
+        transformers.append(("cat", categorical_transformer, categorical_indices))
+
+    if ordinal_indices:
+        ordinal_features = [
+            f for f in features if isinstance(f, (CategoricalOrdinalFeature, NumericOrdinalFeature))
+        ]
+        categories = [f.categories for f in ordinal_features]
+        ordinal_transformer = Pipeline(steps=[
+            ("encoder", OrdinalEncoder(
+                categories=categories,
+                handle_unknown="use_encoded_value",
+                unknown_value=-1
+            ))
+        ])
+        transformers.append(("ord", ordinal_transformer, ordinal_indices))
+
+    if count_indices:
+        count_transformer = Pipeline(steps=[
+            ("imputer", SimpleImputer(strategy="median")),
+            ("log", FunctionTransformer(np.log1p)),  # log1p handles zeros safely
+            ("scaler", StandardScaler())
+        ])
+        transformers.append(("count", count_transformer, count_indices))
+
+    return ColumnTransformer(transformers=transformers)

proxyml_core/schema.py

@@ -0,0 +1,206 @@
+"""Feature schema types.
+
+Pure: stdlib + numpy only. These are plain dataclasses rather than pydantic
+models so that a REST-only ``proxyml`` install never pulls in a compiled
+validation dependency. Validation that pydantic gave for free (probabilities
+summing to 1, matching lengths, etc.) is replicated by hand in
+``__post_init__``.
+
+All dataclasses are keyword-only (``kw_only=True``) so that subclasses can
+add required fields after the base class's defaulted ``immutable`` field
+without Python's dataclass field-ordering constraint forcing spurious
+defaults onto otherwise-required fields.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from typing import Any, ClassVar
+
+import numpy as np
+
+
+class FeatureValidationError(ValueError):
+    """Raised when a Feature or FeatureSchema fails validation."""
+
+
+@dataclass(kw_only=True)
+class Feature:
+    """Base type for a single feature in a schema.
+
+    ``type`` is a class-level discriminator (not a constructor field) so
+    every instance carries its wire-format tag without it participating in
+    equality/repr/construction.
+    """
+
+    name: str
+    immutable: bool = False
+
+    type: ClassVar[str] = "feature"
+
+    def sample(self, size: int = 1) -> np.ndarray:
+        raise NotImplementedError
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {"type": self.type}
+        for f in fields(self):
+            d[f.name] = getattr(self, f.name)
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "Feature":
+        ftype = d.get("type")
+        subclass = _FEATURE_TYPES.get(ftype)
+        if subclass is None:
+            raise FeatureValidationError(f"Unknown feature type: {ftype!r}")
+        return subclass._from_dict_fields(d)
+
+    @classmethod
+    def _from_dict_fields(cls, d: dict[str, Any]) -> "Feature":
+        kwargs = {f.name: d[f.name] for f in fields(cls) if f.name in d}
+        return cls(**kwargs)
+
+
+@dataclass(kw_only=True)
+class ContinuousFeature(Feature):
+    mean: float
+    std: float
+    min: float
+    max: float
+
+    type: ClassVar[str] = "continuous"
+
+    def sample(self, size: int = 1) -> np.ndarray:
+        samples = np.random.normal(loc=self.mean, scale=self.std, size=size)
+        return np.clip(samples, self.min, self.max)
+
+
+@dataclass(kw_only=True)
+class CategoricalFeature(Feature):
+    valid_categories: dict[str, float]
+
+    type: ClassVar[str] = "categorical"
+
+    def __post_init__(self) -> None:
+        total = sum(self.valid_categories.values())
+        if not np.isclose(total, 1.0):
+            raise FeatureValidationError(
+                f"Category probabilities must sum to 1.0, got {total}"
+            )
+
+    def sample(self, size: int = 1) -> np.ndarray:
+        return np.random.choice(
+            a=list(self.valid_categories.keys()),
+            p=list(self.valid_categories.values()),
+            size=size,
+        )
+
+
+@dataclass(kw_only=True)
+class CategoricalOrdinalFeature(Feature):
+    categories: list[str | int]
+    probabilities: list[float]
+
+    type: ClassVar[str] = "categorical_ordinal"
+
+    def __post_init__(self) -> None:
+        if len(self.categories) != len(self.probabilities):
+            raise FeatureValidationError(
+                "categories and probabilities must be same length"
+            )
+        if not np.isclose(sum(self.probabilities), 1.0):
+            raise FeatureValidationError("probabilities must sum to 1.0")
+
+    def sample(self, size: int = 1) -> np.ndarray:
+        return np.random.choice(a=self.categories, p=self.probabilities, size=size)
+
+
+@dataclass(kw_only=True)
+class NumericOrdinalFeature(Feature):
+    categories: list[int]
+    mean: float
+    std: float
+
+    type: ClassVar[str] = "numeric_ordinal"
+
+    def sample(self, size: int = 1) -> np.ndarray:
+        continuous = np.random.normal(loc=self.mean, scale=self.std, size=size)
+        categories = np.array(self.categories)
+        indices = np.argmin(
+            np.abs(continuous[:, None] - categories[None, :]), axis=1
+        )
+        return categories[indices]
+
+
+@dataclass(kw_only=True)
+class CountFeature(Feature):
+    lambda_: float
+    max: int | None = None
+
+    type: ClassVar[str] = "count"
+
+    def sample(self, size: int = 1) -> np.ndarray:
+        samples = np.random.poisson(lam=self.lambda_, size=size)
+        if self.max is not None:
+            samples = np.clip(samples, 0, self.max)
+        return samples
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "type": self.type,
+            "name": self.name,
+            "immutable": self.immutable,
+            "lambda": self.lambda_,
+            "max": self.max,
+        }
+
+    @classmethod
+    def _from_dict_fields(cls, d: dict[str, Any]) -> "CountFeature":
+        return cls(
+            name=d["name"],
+            immutable=d.get("immutable", False),
+            lambda_=d["lambda"],
+            max=d.get("max"),
+        )
+
+
+_FEATURE_TYPES: dict[str, type[Feature]] = {
+    ContinuousFeature.type: ContinuousFeature,
+    CategoricalFeature.type: CategoricalFeature,
+    CategoricalOrdinalFeature.type: CategoricalOrdinalFeature,
+    NumericOrdinalFeature.type: NumericOrdinalFeature,
+    CountFeature.type: CountFeature,
+}
+
+
+@dataclass
+class FeatureSchema:
+    features: list[Feature]
+    covariance_matrix: np.ndarray | None = None
+
+    def __post_init__(self) -> None:
+        if self.covariance_matrix is not None:
+            n_continuous = sum(1 for f in self.features if isinstance(f, ContinuousFeature))
+            if self.covariance_matrix.shape != (n_continuous, n_continuous):
+                raise FeatureValidationError(
+                    f"Covariance matrix must be ({n_continuous}, {n_continuous}), "
+                    f"got {self.covariance_matrix.shape}"
+                )
+            if not np.allclose(self.covariance_matrix, self.covariance_matrix.T):
+                raise FeatureValidationError("Covariance matrix must be symmetric")
+            if not np.all(np.linalg.eigvals(self.covariance_matrix) >= 0):
+                raise FeatureValidationError("Covariance matrix must be positive semi-definite")
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {"features": [f.to_dict() for f in self.features]}
+        if self.covariance_matrix is not None:
+            d["covariance_matrix"] = self.covariance_matrix.tolist()
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "FeatureSchema":
+        features = [Feature.from_dict(f) for f in d["features"]]
+        covariance_matrix = d.get("covariance_matrix")
+        if covariance_matrix is not None:
+            covariance_matrix = np.asarray(covariance_matrix)
+        return cls(features=features, covariance_matrix=covariance_matrix)

proxyml_core-0.1.0.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: proxyml-core
+Version: 0.1.0
+Summary: Shared schema types, export contract, and modeling code for proxyml and its backend.
+Author-email: ProxyML <contact@proxyml.ai>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship made available under
+              the License, as indicated by a copyright notice that is included in
+              or attached to the work (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and Derivative Works thereof.
+        
+              "Contribution" shall mean, as submitted to the Licensor for inclusion
+              in the Work by the copyright owner or by an individual or Legal Entity
+              authorized to submit on behalf of the copyright owner. For the purposes
+              of this definition, "submitted" means any form of electronic, verbal,
+              or written communication sent to the Licensor or its representatives,
+              including but not limited to communication on electronic mailing lists,
+              source code control systems, and issue tracking systems that are managed
+              by, or on behalf of, the Licensor for the purpose of developing and
+              discussing the Work, but excluding communication that is conspicuously
+              marked or designated in writing by the copyright owner as "Not a
+              Contribution."
+        
+              "Contributor" shall mean Licensor and any Legal Entity on behalf of
+              whom a Contribution has been received by the Licensor and included
+              within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent claims licensable
+              by such Contributor that are necessarily infringed by their
+              Contribution(s) alone or by the combination of their Contribution(s)
+              with the Work to which such Contribution(s) was submitted. If You
+              institute patent litigation against any entity (including a cross-claim
+              or counterclaim in a lawsuit) alleging that the Work or any other
+              Contribution incorporated within the Work constitutes patent or
+              contributory patent infringement, then any patent licenses granted to
+              You under this License for that Work shall terminate as of the date
+              such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or Derivative
+                  Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, You must include a readable copy of the
+                  attribution notices contained within such NOTICE file, in
+                  at least one of the following places: within a NOTICE text
+                  file distributed as part of the Derivative Works; within
+                  the Source form or documentation, if provided along with the
+                  Derivative Works; or, within a display generated by the
+                  Derivative Works, if and wherever such third-party notices
+                  normally appear. The contents of the NOTICE file are for
+                  informational purposes only and do not modify the License.
+                  You may add Your own attribution notices within Derivative
+                  Works that You distribute, alongside or in addition to the
+                  NOTICE text from the Work, provided that such additional
+                  attribution notices cannot be construed as modifying the License.
+        
+              You may add Your own license statement for Your modifications and
+              may provide additional grant of rights to use, copy, modify, merge,
+              publish, distribute, sublicense, and/or sell copies of the
+              Contribution and such Derivative Works.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any conditions of TITLE,
+              NONINFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
+              PURPOSE. You are solely responsible for determining the
+              appropriateness of using or reproducing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or exemplary damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or all other
+              commercial damages or losses), even if such Contributor has been
+              advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Additional Liability. While redistributing
+              the Work or Derivative Works thereof, You may choose to offer,
+              and charge a fee for, acceptance of support, warranty, indemnity,
+              or other liability obligations and/or rights consistent with this
+              License. However, in accepting such obligations, You may charge only
+              on Your own behalf and on Your sole responsibility, not on behalf of
+              any other Contributor, and only if You agree to indemnify, defend,
+              and hold each Contributor harmless for any liability incurred by,
+              or claims asserted against, such Contributor by reason of your
+              accepting any warranty or additional liability.
+        
+           END OF TERMS AND CONDITIONS
+        
+           Copyright 2026 ProxyML
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
+Project-URL: Homepage, https://proxyml.ai
+Project-URL: Repository, https://github.com/proxyml/proxyml-core
+Project-URL: Bug Tracker, https://github.com/proxyml/proxyml-core/issues
+Keywords: machine learning,surrogate models,explainability
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: modeling
+Requires-Dist: scikit-learn>=1.4; extra == "modeling"
+Requires-Dist: scipy>=1.10; extra == "modeling"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# proxyml-core
+
+Shared library for [proxyml](https://proxyml.ai) — schema types, the export
+JSON contract, and (behind the `modeling` extra) the sklearn-based training
+and preprocessing code used by both the proxyml backend and the `proxyml`
+SDK's local challenger training.
+
+## Layout
+
+- `proxyml_core.schema` — pure. `Feature` hierarchy, `FeatureSchema`.
+- `proxyml_core.export` — pure. Export dataclasses, `EXPORT_SCHEMA_VERSION`,
+  `predict_from_export()`.
+- `proxyml_core.modeling` — requires `proxyml-core[modeling]` (scikit-learn,
+  scipy). Preprocessing, default estimators, export extraction.
+
+The pure base (`schema`, `export`, `_version`) depends only on `numpy`, so a
+REST-only `proxyml` install never needs scikit-learn.
+
+## Install
+
+```
+pip install proxyml-core            # pure: schema + export
+pip install proxyml-core[modeling]  # + scikit-learn, scipy
+```

proxyml_core-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+proxyml_core/__init__.py,sha256=x1Uw2EivHkQyDFGGl_swWytVMDvXEKcgNjCf0k5O1qo,1005
+proxyml_core/_version.py,sha256=j7bsYsaAses-dNgoBWAaOhMloIGH72uFdRTbiFRlf8Q,849
+proxyml_core/export.py,sha256=vevNi3s4WRdCh4DwlmSI2Cdb1sg-2HLLFjMRhGt3-bw,8793
+proxyml_core/schema.py,sha256=tyySFJzgl5luC3blVWp3uyrv1L3QwiTxr1rhDiLpBt8,6782
+proxyml_core/modeling/__init__.py,sha256=M1mcePMBlDzYYFkL2OA8TiIVVToHrDtgVFATwWnP7gM,567
+proxyml_core/modeling/estimators.py,sha256=qnNglhUHw5-OhkXx0cVMtyz_GLgzWDUiqNN4rhWTrfk,2432
+proxyml_core/modeling/extract.py,sha256=RwqwyWT70v-EQR_noPmRLBNgz2kd0m7c6H5u9y1pEVg,4925
+proxyml_core/modeling/preprocess.py,sha256=F_25r88yl9DZOgHw_y2NDUOpiscc_RkA2-o4XRgVtuk,2550
+proxyml_core-0.1.0.dist-info/licenses/LICENSE,sha256=g3kg6VH6Fi9-VhRB0ZYTPsVKUAMx7D9UsoZMJ_KZtko,10196
+proxyml_core-0.1.0.dist-info/METADATA,sha256=TFNefQXEYpZorcz1Lh2hSBl1WbgYCfOAziH-rlNPgwU,13888
+proxyml_core-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+proxyml_core-0.1.0.dist-info/top_level.txt,sha256=IgLPgv8fD4gWRw-mxtZ3Drsub9CRcMBU-BNvcsDlq3s,13
+proxyml_core-0.1.0.dist-info/RECORD,,

proxyml_core-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

proxyml_core-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,183 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of developing and
+      discussing the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by the combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any other
+      Contribution incorporated within the Work constitutes patent or
+      contributory patent infringement, then any patent licenses granted to
+      You under this License for that Work shall terminate as of the date
+      such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or in addition to the
+          NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Contribution and such Derivative Works.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any conditions of TITLE,
+      NONINFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR
+      PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may charge only
+      on Your own behalf and on Your sole responsibility, not on behalf of
+      any other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 ProxyML
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

proxyml_core-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+proxyml_core