tscp 0.1.0.dev0__py3-none-any.whl

tscp/testing/components.py

@@ -0,0 +1,28 @@
+"""Minimal components for exercising code paths in checks and tests."""
+
+from torch import Tensor
+
+from tscp.data import ResidualArchive
+from tscp.regions import Box
+from tscp.scores import Score
+
+
+class MaxAbsScore(Score):
+    """The largest absolute residual over the horizon: one joint box per series.
+
+    A minimal score that reduces the step dimension. Checking a method with it shows that
+    the method handles scores over the whole horizon, including their release after the
+    last step and their validity under missing targets.
+    """
+
+    reduce_dims = ("step",)
+
+    def forward(self, rows: ResidualArchive) -> Tensor:
+        return rows.residuals.abs().amax(dim=1)
+
+    def region(self, threshold: Tensor, rows: ResidualArchive) -> Box:
+        bound = threshold.unsqueeze(-1).expand(*threshold.shape, rows.horizon)
+        return Box(-bound, bound, event_dims=("step",))
+
+
+__all__ = ["MaxAbsScore"]

tscp/typing.py

@@ -0,0 +1,24 @@
+"""Type aliases shared across tscp.
+
+Shape conventions used in docstrings:
+
+* ``T``: forecast origins (rows of a residual archive);
+* ``H``: horizon steps;
+* ``N``: series;
+* ``P``: residuals in a calibration pool;
+* ``Q``: query origins, one region each;
+* ``*kept``: the dimensions of ``[H, N]`` that a score keeps (see
+  :attr:`tscp.scores.Score.reduce_dims`).
+"""
+
+from typing import TypeAlias
+
+import torch
+from torch import Tensor
+
+Alpha: TypeAlias = float | Tensor
+"""Miscoverage level: a float, or a tensor that broadcasts against the thresholds."""
+
+Device: TypeAlias = str | torch.device
+
+__all__ = ["Alpha", "Device", "Tensor"]

tscp/utils/__init__.py

@@ -0,0 +1,14 @@
+"""Shared helpers: the component base class, configs and fingerprints."""
+
+from .component import Component
+from .config import ConfigMixin, from_config, qualified_name
+from .hashing import array_fingerprint, config_hash
+
+__all__ = [
+    "Component",
+    "ConfigMixin",
+    "array_fingerprint",
+    "config_hash",
+    "from_config",
+    "qualified_name",
+]

tscp/utils/component.py

@@ -0,0 +1,76 @@
+"""The base class shared by every axis component."""
+
+from typing import TYPE_CHECKING, Self
+
+import torch
+
+from tscp.utils.config import ConfigMixin
+
+if TYPE_CHECKING:
+    from tscp.data import ResidualArchive
+
+
+class Component(ConfigMixin, torch.nn.Module):
+    """A torch module with a recorded config and an optional fit step.
+
+    Fitted tensors are registered as parameters or buffers, so they live in
+    ``state_dict()`` and move with ``.to(device)``. Settings live in the config
+    (:meth:`~tscp.utils.config.ConfigMixin.to_config`).
+    """
+
+    #: Whether loading a saved method fits this component again, on the fit split of the
+    #: archive it was fitted on, because its fitted state lives outside torch (a forest,
+    #: say) and is not in ``state_dict()``.
+    refit_on_load: bool = False
+
+    def fit(self, train: "ResidualArchive", validation: "ResidualArchive | None" = None) -> Self:
+        """Fit trainable state.
+
+        The composer calls this only for components that override it. ``train`` is the
+        component-fitting split, ``archive.split("fit")``; ``validation`` is the
+        ``validation`` split when the plan has one, for early stopping and model choice.
+        Both are row subsets whose timeline ends where the split ends: the history before
+        and within the split is there, and nothing after it.
+        """
+        return self
+
+    @property
+    def is_trainable(self) -> bool:
+        """Whether :meth:`fit` does anything for this component."""
+        return type(self).fit is not Component.fit
+
+    def _load_from_state_dict(
+        self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, errors
+    ):
+        # Fitted buffers start as None, and their shape depends on the data, so a fresh
+        # component cannot hold the saved values yet: make room for them, then load.
+        for name, buffer in list(self._buffers.items()):
+            key = prefix + name
+            if name in self._non_persistent_buffers_set or key not in state_dict:
+                continue
+            incoming = state_dict[key]
+            if buffer is None or buffer.shape != incoming.shape:
+                device = buffer.device if buffer is not None else _device_of(self, incoming)
+                self._buffers[name] = torch.empty_like(incoming, device=device)
+        super()._load_from_state_dict(
+            state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, errors
+        )
+
+    def extra_repr(self) -> str:
+        config = self.__dict__.get("_config_arguments", {})
+        # Submodules print themselves; None means "use the default", shown as a submodule.
+        return ", ".join(
+            f"{name}={value!r}"
+            for name, value in config.items()
+            if value is not None and not isinstance(value, torch.nn.Module)
+        )
+
+
+def _device_of(module: torch.nn.Module, fallback: torch.Tensor) -> torch.device:
+    """The device of a module's first tensor, or of ``fallback`` if it holds none."""
+    for tensor in (*module.parameters(recurse=False), *module.buffers(recurse=False)):
+        return tensor.device
+    return fallback.device
+
+
+__all__ = ["Component"]

tscp/utils/config.py

@@ -0,0 +1,135 @@
+"""Constructor-argument configs, so presets and components rebuild from JSON.
+
+Every subclass of :class:`ConfigMixin` records the arguments its constructor was called
+with. :meth:`ConfigMixin.to_config` turns them into a JSON-serializable dict, nesting
+components as ``{"class": ..., "args": ...}``, and :func:`from_config` rebuilds the object.
+Only classes that subclass :class:`ConfigMixin` can be rebuilt, so a config cannot import
+arbitrary code.
+"""
+
+import functools
+import importlib
+import inspect
+from collections.abc import Mapping
+from typing import Any
+
+_CLASSES: dict[str, type] = {}
+
+
+def qualified_name(cls: type) -> str:
+    """Return ``module.QualifiedName``, the key a config uses for ``cls``."""
+    return f"{cls.__module__}.{cls.__qualname__}"
+
+
+def _record_arguments(cls: type, signature: inspect.Signature, args, kwargs) -> dict[str, Any]:
+    bound = signature.bind(None, *args, **kwargs)
+    bound.apply_defaults()
+    arguments = dict(bound.arguments)
+    arguments.pop(next(iter(signature.parameters)))  # self
+    for name, parameter in signature.parameters.items():
+        if parameter.kind is inspect.Parameter.VAR_KEYWORD:
+            arguments.update(arguments.pop(name, {}))
+        elif parameter.kind is inspect.Parameter.VAR_POSITIONAL and arguments.pop(name, ()):
+            raise TypeError(f"{cls.__name__} was given *args, which a config cannot record")
+    return arguments
+
+
+class ConfigMixin:
+    """Record constructor arguments and rebuild objects from them.
+
+    The config is the constructor call, not the current state: changing an attribute after
+    construction does not change it. Fitted state belongs in ``state_dict()``.
+    """
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        _CLASSES[qualified_name(cls)] = cls
+        init = cls.__dict__.get("__init__")
+        if init is None or getattr(init, "_records_config", False):
+            return
+        signature = inspect.signature(init)
+
+        @functools.wraps(init)
+        def __init__(self, *args, **kwargs):
+            # The most derived constructor runs first; parents called through super() must
+            # not overwrite its record.
+            if "_config_arguments" not in self.__dict__:
+                arguments = _record_arguments(cls, signature, args, kwargs)
+                object.__setattr__(self, "_config_arguments", arguments)
+            init(self, *args, **kwargs)
+
+        __init__._records_config = True
+        cls.__init__ = __init__
+
+    def get_config(self) -> dict[str, Any]:
+        """Return the constructor arguments as a JSON-serializable dict."""
+        arguments = self.__dict__.get("_config_arguments", {})
+        return {name: _encode(value, name) for name, value in arguments.items()}
+
+    def to_config(self) -> dict[str, Any]:
+        """Return ``{"class": ..., "args": ...}``, which :func:`from_config` rebuilds."""
+        return {"class": qualified_name(type(self)), "args": self.get_config()}
+
+
+def _encode(value: Any, name: str) -> Any:
+    if value is None or isinstance(value, bool | int | float | str):
+        return value
+    if isinstance(value, ConfigMixin):
+        return value.to_config()
+    if isinstance(value, list | tuple):
+        return [_encode(item, name) for item in value]
+    if isinstance(value, Mapping) and all(isinstance(key, str) for key in value):
+        return {key: _encode(item, f"{name}.{key}") for key, item in value.items()}
+    raise TypeError(
+        f"argument {name!r} has type {type(value).__name__}, which a config cannot record; "
+        "pass numbers, strings, lists, dicts or tscp components"
+    )
+
+
+def _decode(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        if set(value) == {"class", "args"}:
+            return from_config(value)
+        return {key: _decode(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_decode(item) for item in value]
+    return value
+
+
+def _find_class(name: str) -> type | None:
+    """Find a class that has not registered yet: import tscp's module, or load plugins."""
+    module = name.rpartition(".")[0]
+    if module == "tscp" or module.startswith("tscp."):
+        try:
+            importlib.import_module(module)
+        except ImportError:
+            return None
+    else:
+        from tscp import registry  # here, not at the top: the registry imports this module
+
+        registry.load_plugins()
+    return _CLASSES.get(name)
+
+
+def from_config(config: Mapping[str, Any]) -> ConfigMixin:
+    """Rebuild an object from :meth:`ConfigMixin.to_config` output.
+
+    tscp's own modules are imported as needed, and installed plugins (see
+    :mod:`tscp.registry`) are loaded when a class is not found otherwise. Only
+    :class:`ConfigMixin` subclasses are built, so a config cannot run arbitrary code.
+
+    Raises:
+        ValueError: If no imported module, tscp module or installed plugin defines the class.
+    """
+    if set(config) != {"class", "args"}:
+        raise ValueError("a config must have exactly the keys 'class' and 'args'")
+    name = config["class"]
+    cls = _CLASSES.get(name) or _find_class(name)
+    if cls is None:
+        raise ValueError(
+            f"unknown class {name!r}; import the module that defines it, or install its plugin"
+        )
+    return cls(**{key: _decode(value) for key, value in config["args"].items()})
+
+
+__all__ = ["ConfigMixin", "from_config", "qualified_name"]

tscp/utils/hashing.py

@@ -0,0 +1,35 @@
+"""Fingerprints of arrays and configs, for file checks and artifact IDs."""
+
+import hashlib
+import json
+from collections.abc import Mapping
+from typing import Any
+
+import numpy as np
+import torch
+
+
+def _as_numpy(value: np.ndarray | torch.Tensor) -> np.ndarray:
+    if isinstance(value, torch.Tensor):
+        value = value.detach().cpu().numpy()
+    return np.ascontiguousarray(value)
+
+
+def array_fingerprint(arrays: Mapping[str, np.ndarray | torch.Tensor]) -> str:
+    """SHA-256 over array names, dtypes, shapes and bytes, in sorted name order."""
+    digest = hashlib.sha256()
+    for name in sorted(arrays):
+        array = _as_numpy(arrays[name])
+        header = json.dumps([name, array.dtype.str, list(array.shape)])
+        digest.update(header.encode())
+        digest.update(array.tobytes())
+    return digest.hexdigest()
+
+
+def config_hash(config: Mapping[str, Any]) -> str:
+    """SHA-256 of a config's canonical JSON (sorted keys, no NaN)."""
+    text = json.dumps(config, sort_keys=True, separators=(",", ":"), allow_nan=False)
+    return hashlib.sha256(text.encode()).hexdigest()
+
+
+__all__ = ["array_fingerprint", "config_hash"]

tscp/weights/__init__.py

@@ -0,0 +1,7 @@
+"""Axis 3, calibration weights: which past errors count, and how much."""
+
+from .base import Weights
+from .exponential import ExponentialWeights
+from .uniform import UniformWeights
+
+__all__ = ["ExponentialWeights", "UniformWeights", "Weights"]

tscp/weights/base.py

@@ -0,0 +1,22 @@
+"""The calibration-weights interface (axis 3)."""
+
+from torch import Tensor
+
+from tscp.data import ResidualArchive
+from tscp.utils import Component
+
+
+class Weights(Component):
+    """Which past errors count, and how much.
+
+    :meth:`forward` returns nonnegative, unnormalized weights of shape ``[Q, P]``, or
+    ``[Q, P, *kept]`` when they differ by step or series. The composer multiplies them by
+    the availability and observed masks, so a weight class never handles either.
+    """
+
+    def forward(self, pool: ResidualArchive, query: ResidualArchive) -> Tensor:
+        """Return weights of the ``P`` pool rows for each of the ``Q`` query rows."""
+        raise NotImplementedError
+
+
+__all__ = ["Weights"]

tscp/weights/exponential.py

@@ -0,0 +1,37 @@
+"""Weights that decay with age (NexCP)."""
+
+import torch
+from torch import Tensor
+
+from tscp.data import ResidualArchive
+from tscp.registry import register
+from tscp.weights.base import Weights
+
+
+@register("weights", "exponential")
+class ExponentialWeights(Weights):
+    """``decay ** (query_origin - pool_origin)``: recent errors count more.
+
+    With contiguous origins and an expanding pool, the most recent residual gets
+    ``decay``, the one before ``decay**2``, and so on: the fixed weights of NexCP
+    (Barber, Candès, Ramdas & Tibshirani, Annals of Statistics 2023). Age counts base time
+    steps, so an archive whose origins are ``k`` steps apart decays by ``decay**k`` per row.
+
+    Args:
+        decay: Weight ratio per base time step, in (0, 1]; 1 gives equal weights.
+    """
+
+    def __init__(self, decay: float = 0.99):
+        super().__init__()
+        if not 0 < decay <= 1:
+            raise ValueError("decay must lie in (0, 1]")
+        self.decay = float(decay)
+
+    def forward(self, pool: ResidualArchive, query: ResidualArchive) -> Tensor:
+        # Rows after the query get age 0 here; the availability mask removes them anyway.
+        age = (query.origins[:, None] - pool.origins[None, :]).clamp(min=0)
+        decay = torch.tensor(self.decay, dtype=torch.float64, device=pool.device)
+        return decay.pow(age.to(torch.float64))
+
+
+__all__ = ["ExponentialWeights"]

tscp/weights/uniform.py

@@ -0,0 +1,23 @@
+"""Equal weights."""
+
+import torch
+from torch import Tensor
+
+from tscp.data import ResidualArchive
+from tscp.registry import register
+from tscp.weights.base import Weights
+
+
+@register("weights", "uniform")
+class UniformWeights(Weights):
+    """Every pool residual counts the same.
+
+    Passing ``weights=None`` to a predictor gives the same thresholds through a faster
+    path; this class exists for ablations that swap weight classes.
+    """
+
+    def forward(self, pool: ResidualArchive, query: ResidualArchive) -> Tensor:
+        return torch.ones(len(query), len(pool), dtype=torch.float64, device=pool.device)
+
+
+__all__ = ["UniformWeights"]

tscp-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.5
+Name: tscp
+Version: 0.1.0.dev0
+Summary: Conformal prediction for time series, in PyTorch
+Project-URL: Documentation, https://tscp.readthedocs.io
+Project-URL: Source, https://github.com/RobertoNeglia/tscp
+Project-URL: Issues, https://github.com/RobertoNeglia/tscp/issues
+Project-URL: Changelog, https://github.com/RobertoNeglia/tscp/blob/main/CHANGELOG.md
+Author: Roberto Neglia
+License-Expression: MIT
+License-File: LICENSE
+Keywords: conformal-prediction,forecasting,prediction-intervals,pytorch,time-series,uncertainty-quantification
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: torch>=2.2
+Provides-Extra: dev
+Requires-Dist: furo; extra == 'dev'
+Requires-Dist: myst-parser>=3; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: pyyaml>=6; extra == 'dev'
+Requires-Dist: ruff==0.17.4; extra == 'dev'
+Requires-Dist: sphinx-copybutton; extra == 'dev'
+Requires-Dist: sphinx<9,>=7; extra == 'dev'
+Provides-Extra: doc
+Requires-Dist: furo; extra == 'doc'
+Requires-Dist: myst-parser>=3; extra == 'doc'
+Requires-Dist: sphinx-copybutton; extra == 'doc'
+Requires-Dist: sphinx<9,>=7; extra == 'doc'
+Provides-Extra: examples
+Requires-Dist: pyyaml>=6; extra == 'examples'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=5; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Requires-Dist: pyyaml>=6; extra == 'test'
+Description-Content-Type: text/markdown
+
+# tscp
+
+[![CI](https://github.com/RobertoNeglia/tscp/actions/workflows/ci.yaml/badge.svg)](https://github.com/RobertoNeglia/tscp/actions/workflows/ci.yaml)
+[![Documentation](https://readthedocs.org/projects/tscp/badge/?version=latest)](https://tscp.readthedocs.io/en/latest/)
+
+Conformal prediction for time series, in PyTorch: the published methods behind one interface,
+from one-step intervals to joint regions over a forecast horizon and across series, with one
+evaluation protocol.
+
+**Status:** early development. The data contract, the component interfaces, contract
+checks for new components, a registry with plugins, feature maps, helpers for learned
+components and saved methods are in place, with split CP, NexCP and ACI and the absolute,
+signed, normalized and CQR scores; more methods will follow.
+
+## Install
+
+tscp is in early development; its pre-releases install with
+
+```bash
+pip install --pre tscp
+```
+
+For development, clone the repository and install it with `pip install -e ".[dev]"`.
+Documentation: https://tscp.readthedocs.io
+
+## Quickstart
+
+```python
+from tscp.datasets import variance_shift
+from tscp.methods import get_method
+from tscp.metrics import evaluate
+
+archive = variance_shift(horizon=1)  # a synthetic residual archive
+method = get_method("nexcp", decay=0.99, alpha=0.1)
+region = method.fit(archive).calibrate(archive).predict(archive)
+print(evaluate(region, archive.split("test"), alpha=0.1, window=200))
+```
+
+`examples/quickstart.py` compares the three methods on two synthetic archives.
+
+## Build your own method
+
+A method is one component per axis: residual source, score, calibration weights, quantile
+model, online update. `compose` builds one from short names, such as a spec read from YAML:
+
+```python
+from tscp.methods import compose
+
+method = compose(
+    {
+        "score": "signed",
+        "source": "expanding",
+        "weights": {"name": "exponential", "decay": 0.99},
+        "update": {"name": "aci", "gamma": 0.005},
+    }
+)
+```
+
+A new component subclasses its axis's base class, and `tscp.testing` checks that it keeps
+the contracts every method relies on, such as causality and split discipline:
+
+```python
+from tscp.testing import check_method
+
+check_method(lambda: compose({"score": "signed", "update": "aci"}))
+```
+
+Packages can register components under short names as plugins. The tutorials in `docs/`
+cover composing methods, writing components, learned components, plugins and batch
+production; the code they show is in `examples/` and runs in the tests.
+
+## Batch production
+
+```python
+from tscp.data import ResidualArchive
+from tscp.methods import load_method, save_method
+
+archive = ResidualArchive.from_forecasts(
+    truth, forecasts, sizes={"fit": 0.2, "calibration": 0.3, "test": None}
+)
+save_method(method.fit(archive), "method.npz")  # one file, no pickle
+region = load_method("method.npz").calibrate(archive).predict(archive)
+intervals = region.to_target(archive.split("test").forecasts)
+```

tscp-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,72 @@
+tscp/__init__.py,sha256=XyXcv9ftZ7p3pNbCm07ICK1IsYfeCAckjVMod2xg4Pc,906
+tscp/imports.py,sha256=5LlxLGqOIq0xGL0WYiN0qwpessZpOJ-Ow34vbxDNM14,1064
+tscp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tscp/registry.py,sha256=G0SA8iHR0Ql8S8NQSm4-fp830aTOhwBi2nWAryfjO64,5923
+tscp/typing.py,sha256=z8ks7eXoGialkTKwMVUmHGwTQLL7Gs2Gigj5mF_8BFA,639
+tscp/data/__init__.py,sha256=HVOThntO8YCU-o_Aqea3OYstMF55yO6IHlv0eqyB198,526
+tscp/data/archive.py,sha256=NlAX0S5_drV3WlYBGOCYJXNCnJK6mZZOIFOXcPQgHgY,22439
+tscp/data/availability.py,sha256=lxS3BjIjZxyNBZ-KpuYhreAGvkJsA3aMEDN1ufhqHt0,2394
+tscp/data/io.py,sha256=OmGcXd4TlrFQZrs57urq2NP2Svdv1aBE8czN3fqm_w0,4531
+tscp/data/splits.py,sha256=V42Vz4dDKkQVKHB4eDV931X6aiRVB-OUB3DVM7jIVkE,7243
+tscp/datasets/__init__.py,sha256=Lv000yDMT30NNYabLMZmPfmeHAQph_flm5BpgA8rxh0,213
+tscp/datasets/synthetic.py,sha256=zRosExAOBsIP0W5oSE1-j1Znt-Y91O3d6mrk4xJ7DnE,6349
+tscp/features/__init__.py,sha256=rDOYjFANK8GkwwfB8ijjwsJ3eb4E6a2KglUCVoJkNtk,531
+tscp/features/base.py,sha256=Zqk7dQv9vQihH2guIt-XNm7PObX6kz5h67jmr-FGOp0,2582
+tscp/features/calendar.py,sha256=ChxOv4Eisa5wFYD1BK9DZ4vPD8vwIV0tqX2KoyV4S18,4477
+tscp/features/combine.py,sha256=lluRzcCIyuhzcTVz3NiXiZzzhf4qssrAVbz1bLUYCjo,2476
+tscp/features/context.py,sha256=6pWMkM4gfx420od7GWmumc-Gja1E4CjsnhImt_XdL6Y,1528
+tscp/features/history.py,sha256=c8xB0KWDfHz42V0WIZDUlxcviROQof0jLB419p4Jol8,2364
+tscp/features/phase.py,sha256=4Dh73pz-PtTU0AdGkUtSpCHq5OLVcCvlBZfX7elBY0w,1563
+tscp/methods/__init__.py,sha256=uVb3FDrpNxPeidQflbG0n7-iwWgTc2H4_g8IPicnuYQ,1557
+tscp/methods/aci.py,sha256=0frJVOgcNjzDueoGfkKo1vqnFZRVt6hhsaiUT31jLqE,1564
+tscp/methods/base.py,sha256=SJmBipb9ewoCxbQ1hoGeQGpJLZ9SKJ4kBeJ8gmGFr90,10599
+tscp/methods/compose.py,sha256=305tJ5QstMDqhhfIQS8jytHYrlW3C6Vm409vVEyqajw,3385
+tscp/methods/engine.py,sha256=CT1Dv8lzz-kz6N3UmToTN8KK2fj4Xfg5WK272dr5SWs,5082
+tscp/methods/io.py,sha256=5HXcLf4c0W0MH2s_drGf1ZEBzjOvYiWYIcKK9BQ4wCM,4564
+tscp/methods/nexcp.py,sha256=7_4YFxvBw6d2BskyEOKyzHnYjBOAbh3U55XvVmddxZw,1521
+tscp/methods/split.py,sha256=k624L9mfRS922EsCTeYwq-hP-iFjYKsnVO5PbSaZ2ec,982
+tscp/metrics/__init__.py,sha256=wkeSKqbWINceHTalFRtQazRXL18Nd3K6_Z6ODK5J_Wc,701
+tscp/metrics/conditional.py,sha256=5DRPwHeKjgVfZl6UwBwyDe5XG5PbyTVQKpuvj_1q5IQ,2693
+tscp/metrics/interval.py,sha256=gYWuJDQnTCOgp_VLWTpq9s8eYHrbpXm2xvP3Q_-ET0s,2522
+tscp/metrics/report.py,sha256=ibw2_TjA-TjpKfhQivmxqmEPuIKIYmIWmvXYvNMs5O8,5711
+tscp/nn/__init__.py,sha256=FOzUoA7c5jT5fHFBJvI0aJBcdEMB4wwZyOCfzcFJ-AQ,650
+tscp/nn/data.py,sha256=eoHypy5sXhiVAb8TOYF_QlHITxzNOtmM0xMsR-8OWNw,3072
+tscp/nn/losses.py,sha256=Hgssr1yGa8XHLvrCexCzGVUKh22s7qbhvtB3nfOzuyk,2200
+tscp/nn/training.py,sha256=1J6RKxzeYRk90ZZHPuJBs-9WjmaiWfiEs5Cog3S4AGA,4953
+tscp/online/__init__.py,sha256=fVXtkisUIYuBxqL6n-WGnELZ6re1KN-xGBYl6FpEKYM,173
+tscp/online/aci.py,sha256=gff6JBWUPi5wXG-2Yw4HBc0prAYualgpF5nO5BLM88Q,1850
+tscp/online/base.py,sha256=8UfGOuzzDNUdGLrUDc-3o7K-ve_Uq-hPrcvtBDx88p4,2647
+tscp/quantile/__init__.py,sha256=1IspG7zwuo1tvI2eubyRSynC6-UB9LI6xsczVRrnyfM,455
+tscp/quantile/base.py,sha256=2D0sp93uRLmDrtYG_nbXXyG7l4EuM4BQSJ11DeUbv-U,2815
+tscp/quantile/distribution.py,sha256=sJFU0x7vRRNXI1yRg0Hp91TyHGf8k0mdR653Lc7uqRs,8367
+tscp/quantile/weighted.py,sha256=1_ldRSpJCHriodqVuqH9eaKmyqmCtr4frm1QUbKN38M,4404
+tscp/regions/__init__.py,sha256=7zQ9W4IjjLQ_wZUQZy1CyC9OUsnXRDqrUBkXJBYIG9c,375
+tscp/regions/base.py,sha256=9hRKmvPmZiGdUd8fRCb2oZPJHptDESBoRNENBXhKT6w,5852
+tscp/regions/box.py,sha256=8yvP5qp7GKCRux3Oov_UU59z8NfhPqcijX-G3JCEMVo,3506
+tscp/regions/interval.py,sha256=glRjtY_Q0quNC-HtDkWmXL3-7J00aLNctZPyciiQoOc,1943
+tscp/scores/__init__.py,sha256=WcVz-kwxmoQSTNLI4upUNzr7OL-oBlqrquvnDOA0cWo,295
+tscp/scores/absolute.py,sha256=fk9SS5-Dsm_32HOBtJ3TS_oZnF94oMZUxd-jBwS_CEo,598
+tscp/scores/base.py,sha256=lBdpgi-mBojLEeseYETymiZ9St4dbPkjUYjEVDj_HHo,4058
+tscp/scores/cqr.py,sha256=SOmviVYXkF0m15N6lbJimgEwOCXa6eZwx8DNjs8bOM8,3100
+tscp/scores/normalized.py,sha256=bReBPmz-pGmMbuf3ZkcdfoQ_WVP3yrPWgk3VNQPQJRA,2907
+tscp/scores/signed.py,sha256=Cco8jSA4p3cNWmz_T0BjM9SCd5QkkOZfRTKOD1zrHus,1678
+tscp/sources/__init__.py,sha256=Ku2E2GLeCQhnh677gz9mjJ9fmwIec27a4EANU5Udm2Q,256
+tscp/sources/base.py,sha256=laZ6GSgFD8dKcWj06wUdUBqrC6XTIaDadXHNg7jcwd0,1101
+tscp/sources/expanding.py,sha256=G7QDukpHZLtrtfsZogeW7rrjjgA6lXOzME_1X9jr-5o,759
+tscp/sources/holdout.py,sha256=6Ud_TG_D32y8MWj832srGRwou8zpAkqMc3Qc55fpS9Y,474
+tscp/testing/__init__.py,sha256=39-Vjf8hQA-hQ51z22SOxmQjW5r5S4Y-xCVENK8wOrg,1070
+tscp/testing/archives.py,sha256=M7CFYQwWfK0JxKNCWI3V6_gvixPwEsfqPCD_RbZEIfw,2963
+tscp/testing/checks.py,sha256=-SOrjnUH5FbW0LpW_zb_OvjANNe4fThP65QQY1FwVew,34227
+tscp/testing/components.py,sha256=31sCJy0Tt9vR6fKUZ-ntfO5jJsOE9f57X8VBu1N6CAQ,917
+tscp/utils/__init__.py,sha256=MYndMPUN70j9WWCkNWsjNJYvjyALj1rIdYeKsgO2bNo,357
+tscp/utils/component.py,sha256=TYQlrumoYmQGu9oOxMzPvFMLt5yAgCxFXkBh05tSzHE,3186
+tscp/utils/config.py,sha256=RkxqNWZZ08rbOSnvrKh5hfx-gK7AWJC6vwCF6stYT8Q,5444
+tscp/utils/hashing.py,sha256=DNoaHizzqnIlMiD5XprYcquBN0yCCUPP2WjN4QUBhF0,1143
+tscp/weights/__init__.py,sha256=hnIQLCLsYMwXB09led7UTfLDin253VW8XzT8SBu8y2M,244
+tscp/weights/base.py,sha256=XTWc9-Z5JP7PhU9IND1c8molYo-K4pO6JM6OGFYCJ4Q,713
+tscp/weights/exponential.py,sha256=8heV7qvCsOtIV_CueSIgixu3EklOUielJua3wJCLb9g,1400
+tscp/weights/uniform.py,sha256=peFO2WQTe8NyscVUjdjJjz3uELi7eKqYA8ZurYcZKdA,647
+tscp-0.1.0.dev0.dist-info/METADATA,sha256=EaGb08mubAR8XhL8wPW2EcRVZXpvjzlWG18S-YntD18,4889
+tscp-0.1.0.dev0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+tscp-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=eBmYQftEbuPRgifQ78YlvwS6ypE0zMfZoUdjBbUCAPk,1071
+tscp-0.1.0.dev0.dist-info/RECORD,,

tscp-0.1.0.dev0.dist-info/WHEEL

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

tscp-0.1.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roberto Neglia
+
+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.