tscp 0.1.0.dev0__tar.gz

tscp-0.1.0.dev0/.gitignore

@@ -0,0 +1,51 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+.pytest_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+coverage.xml
+htmlcov/
+
+# Extra packages installed with pip --target on remote hosts
+.pydeps/
+
+# Private, local-only files: notes, AI-assistant instructions and settings, editor settings
+/ignore/
+AGENTS.md
+CLAUDE.md
+CLAUDE.local.md
+GEMINI.md
+.claude/
+.cursor/
+.cursorrules
+.windsurfrules
+.aider*
+.continue/
+.codex/
+.mcp.json
+.github/copilot-instructions.md
+.vscode/
+.idea/
+*.code-workspace
+
+# Sphinx build output and autosummary pages
+docs/build/
+docs/source/generated/
+
+# Notebooks
+.ipynb_checkpoints/
+
+# Data and run outputs stay out of git. Anchored to the repo root: the package has its own
+# data/ subpackage (src/tscp/data, tests/data), which must stay tracked.
+/data/
+/artifacts/
+/logs/
+
+# macOS
+.DS_Store

tscp-0.1.0.dev0/CHANGELOG.md

@@ -0,0 +1,72 @@
+# Changelog
+
+All notable changes to tscp are listed here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
+[Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+### Added
+
+- Package layout under `src/tscp/`: one subpackage per design axis (`sources`, `scores`,
+  `weights`, `quantile`, `online`, `regions`), plus `data`, `methods`, `metrics`,
+  `features`, `datasets` and `utils`.
+- `ResidualArchive`, `SplitPlan` with `chronological_split`, the availability rule, and
+  self-contained `.npz` archives with fingerprints.
+- Row subsets that keep the archive they came from as their `timeline`, with
+  `known_counts` for reading the history before a row causally. `split()` cuts the
+  timeline after the split's last row; `head()` returns the first rows.
+- The `ConformalPredictor` composer, and the presets `SplitCP`, `NexCP` and `ACI`,
+  registered in `method_map` and built with `get_method`. Trainable components are fitted
+  on the `fit` split, with the `validation` split when there is one.
+- Scores that read whole rows (forecasts, outputs, context), with channels and
+  per-element miscoverage levels: `AbsoluteScore`, `SignedScore`, `NormalizedScore`
+  (forecaster scale or fitted scale) and `CQRScore` (symmetric or per side). Scores over
+  the horizon or across series are calibrated on rows whose targets are all observed.
+- Quantile models return a `ScoreDistribution`: thresholds at any number of levels from
+  one sort, and the conformal p-value of any score. `WeightedQuantile` returns an
+  `EmpiricalDistribution`.
+- Online updates answer queries keyed by their position and observe outcomes as their
+  targets arrive, with the realized levels on request: `ACIUpdate`, run by the online
+  engine in `tscp.methods.engine`.
+- Other components: `HoldoutSource`, `ExpandingSource`, `UniformWeights`,
+  `ExponentialWeights`.
+- Regions: `Interval`, and `Box` over steps, series or both. Every region exposes its
+  tensors, so indexing and device moves work for every type.
+- Metrics: coverage, log-width, Winkler score, rolling, worst-window and grouped coverage,
+  and `evaluate`, which returns a `Report` with per-step and joint coverage for any
+  region type.
+- Synthetic archives: a Gaussian control and a variance shift.
+- Feature maps, computed causally from a row's timeline: `ResidualHistory` (the last
+  residuals known at each origin, per step), `Phase` (position in a cycle of base
+  steps), `Calendar` (minute to day of year, from timestamps), `ContextColumns` and
+  `Concat`.
+- Optional archive `timestamps` (int64 nanoseconds, hashed). Archive files are schema
+  version 2; version 1 files still load.
+- `tscp.nn` for learned components: `pinball_loss`, `interval_score`, `RowBatches` of
+  archive rows with their features, `train` (seeded, with early stopping on the
+  validation split) and `seeded`. `examples/learned_score.py` fits a score whose scale is
+  a small network on the context.
+- `context_scale`: a synthetic control whose error scale follows a known covariate.
+- Batch production: `ResidualArchive.from_forecasts` builds an archive from a backtest's
+  arrays (NaN truth means unobserved; timestamps as int64 nanoseconds or `datetime64`),
+  and `targets()` gives the truth back. `save_method` and `load_method` keep a fitted
+  method in one `.npz` file, without pickle; components whose fitted state lives outside
+  torch set `refit_on_load`. Fresh components load fitted state whose shape depends on
+  the data. `examples/production.py` runs the whole workflow.
+- A `py.typed` marker, for type checkers.
+- A release workflow that publishes to PyPI through trusted publishing when a version
+  tag is pushed.
+- `tscp.testing`: checks that a method or component keeps tscp's contracts
+  (`check_method`, `check_score`, `check_weights`, `check_quantile_model`,
+  `check_online_update`, `check_region`), with `synthetic_archive` and `MaxAbsScore`.
+  tscp checks its own presets and components with them.
+- `tscp.registry`: components and presets registered by kind and short name. `register`
+  adds new ones; a taken name raises unless `replace=True`. Plugins register through
+  the `tscp.plugins` entry-point group and are loaded when a name or a config's class is
+  not found. `compose` builds a method from a spec of short names, such as one read from
+  YAML; `examples/plugin` is an installable example plugin.
+- Recorded constructor configs (`to_config`, `from_config`) and config hashes.
+- Sphinx docs with a concepts page and tutorials (composing a method, writing a component,
+  a learned component and a plugin, batch production) whose code lives in `examples/`
+  and runs in the tests; CI that builds them with warnings as errors; pre-commit.

tscp-0.1.0.dev0/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.

tscp-0.1.0.dev0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,84 @@
+# 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/docs/source/api.md

@@ -0,0 +1,91 @@
+# API reference
+
+## Data contract
+
+```{eval-rst}
+.. automodule:: tscp.data
+```
+
+## Axis 1: residual sources
+
+```{eval-rst}
+.. automodule:: tscp.sources
+```
+
+## Axis 2: scores
+
+```{eval-rst}
+.. automodule:: tscp.scores
+```
+
+## Axis 3: calibration weights
+
+```{eval-rst}
+.. automodule:: tscp.weights
+```
+
+## Axis 4: quantile models
+
+```{eval-rst}
+.. automodule:: tscp.quantile
+```
+
+## Axis 5: online updates
+
+```{eval-rst}
+.. automodule:: tscp.online
+```
+
+## Axis 6: regions
+
+```{eval-rst}
+.. automodule:: tscp.regions
+```
+
+## Methods
+
+```{eval-rst}
+.. automodule:: tscp.methods
+```
+
+## Metrics
+
+```{eval-rst}
+.. automodule:: tscp.metrics
+```
+
+## Features
+
+```{eval-rst}
+.. automodule:: tscp.features
+```
+
+## Registry and plugins
+
+```{eval-rst}
+.. automodule:: tscp.registry
+```
+
+## Learned components
+
+```{eval-rst}
+.. automodule:: tscp.nn
+```
+
+## Checks
+
+```{eval-rst}
+.. automodule:: tscp.testing
+```
+
+## Datasets
+
+```{eval-rst}
+.. automodule:: tscp.datasets.synthetic
+```
+
+## Utilities
+
+```{eval-rst}
+.. automodule:: tscp.utils
+```

tscp-0.1.0.dev0/docs/source/concepts.md

@@ -0,0 +1,81 @@
+# Concepts
+
+tscp is post-hoc: it starts from the forecasts of a model that is already trained, and it
+never trains the forecaster. A conformal method in tscp is one choice per *axis*, run
+through a fixed lifecycle on a *residual archive*.
+
+## The residual archive
+
+A {class}`~tscp.data.ResidualArchive` holds the residuals of one forecaster on one
+dataset, with what methods need beside them.
+
+- **Residuals** are truth minus forecast, in the target's original units, with shape
+  `[T, H, N]`: forecast origins, horizon steps and series. tscp never standardizes them.
+- **Origins and steps** count base time steps. The target of origin `s` at step `h` is at
+  time `s + h`.
+- **Splits** are named row sets in time order: `fit` and an optional `validation` for
+  components that are trained, `calibration` for conformal scores, and `test`. No two
+  splits share a target time.
+- **Optional fields:** point forecasts, other forecaster outputs (such as predicted
+  quantiles, in target units), context known at each origin, an observed mask for missing
+  targets, timestamps, series names and a graph over the series.
+
+{meth}`~tscp.data.ResidualArchive.from_forecasts` builds an archive from a backtest's
+arrays, and {func}`~tscp.data.save_archive` writes it to a self-contained `.npz` file,
+checked against a fingerprint when it is read back.
+
+## Knowing only the past
+
+The residual of origin `s` at step `h` is known once its target time has passed: at origin
+`t` it is usable only if `s + h <= t`. Everything that grows or adapts during the test
+period follows this rule: expanding calibration pools, online updates and features.
+
+A row subset, made by `select` or `split`, keeps the archive it came from as its
+`timeline`. Components read the history before a row from there, through
+{meth}`~tscp.data.ResidualArchive.known_counts`. `split` cuts the timeline after the
+split's last row, so a component fitted on the fit split cannot reach anything later.
+{func}`tscp.testing.check_method` checks both properties for any method.
+
+## One choice per axis
+
+| Axis | Base class | What it decides |
+|---|---|---|
+| Residual source | {class}`~tscp.sources.Source` | which rows calibrate, and whether test residuals join them once known |
+| Score | {class}`~tscp.scores.Score` | how an error becomes a number, and the region a threshold on it defines |
+| Weights | {class}`~tscp.weights.Weights` | which past errors count, and how much |
+| Quantile model | {class}`~tscp.quantile.QuantileModel` | the conformal distribution of the score, read at any level |
+| Online update | {class}`~tscp.online.OnlineUpdate` | how the threshold reacts to its own misses |
+| Region | {class}`~tscp.regions.Region` | what the user gets: a membership test and a size |
+
+A score keeps the dimensions of `[H, N]` it does not reduce: an interval per step and
+series, or one joint region over the horizon. A score may also split an element into
+channels, such as the two sides of an interval, and share the miscoverage among them.
+Feature maps ({class}`~tscp.features.FeatureMap`) turn what is known at each origin
+into vectors for weights and quantile models.
+
+## The lifecycle
+
+```python
+method.fit(archive)  # trainable components see the fit and validation splits only
+method.calibrate(archive)  # scores of the calibration pool
+region = method.predict(archive)  # one region per test origin
+report = evaluate(region, archive.split("test"), alpha)
+```
+
+Without an online update, `predict` reads every threshold at once. With one, it answers the
+test origins in time order and hands the update each outcome once its target time has
+passed. {func}`~tscp.metrics.evaluate` returns a {class}`~tscp.metrics.Report`: coverage,
+coverage per step and over the horizon, region size as log-volume per dimension, and
+conditional coverage on request.
+
+A fitted method is saved with {func}`~tscp.methods.save_method` and loaded with
+{func}`~tscp.methods.load_method`; calibration is cheap, so a loaded method is
+calibrated again before it predicts.
+
+## Regions
+
+Regions live in residual coordinates: a target `y` with forecast `f` is covered when
+`y - f` lies in the region. Coverage and volume do not change under this shift, so
+evaluation never needs the forecasts, and `region.to_target(forecasts)` maps regions back
+to target units. Region size is reported as log-volume per dimension, never as the mean of
+raw volumes, which the widest regions would dominate.

tscp-0.1.0.dev0/docs/source/conf.py

@@ -0,0 +1,46 @@
+"""Sphinx configuration for the tscp documentation."""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("../../src"))
+
+import tscp  # noqa: E402
+
+project = "tscp"
+author = "Roberto Neglia"
+copyright = "2026, Roberto Neglia"
+release = tscp.__version__
+version = release
+
+extensions = [
+    "myst_parser",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.napoleon",
+    "sphinx.ext.viewcode",
+    "sphinx_copybutton",
+]
+
+source_suffix = {".md": "markdown", ".rst": "restructuredtext"}
+exclude_patterns = ["build", "generated"]
+
+autodoc_default_options = {"members": True, "imported-members": True, "member-order": "bysource"}
+autodoc_typehints = "description"
+napoleon_google_docstring = True
+napoleon_numpy_docstring = False
+myst_heading_anchors = 3
+
+# Set TSCP_DOCS_OFFLINE=1 to build without fetching the inventories of other projects.
+intersphinx_mapping = (
+    {}
+    if os.environ.get("TSCP_DOCS_OFFLINE")
+    else {
+        "python": ("https://docs.python.org/3", None),
+        "numpy": ("https://numpy.org/doc/stable", None),
+        "torch": ("https://docs.pytorch.org/docs/stable", None),
+    }
+)
+
+html_theme = "furo"
+html_title = f"tscp {release}"

tscp-0.1.0.dev0/docs/source/index.md

@@ -0,0 +1,28 @@
+# tscp
+
+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.
+
+```python
+from tscp.datasets import variance_shift
+from tscp.methods import get_method
+from tscp.metrics import evaluate
+
+archive = variance_shift(horizon=1)
+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))
+```
+
+```{toctree}
+:maxdepth: 2
+
+concepts
+tutorials/compose
+tutorials/component
+tutorials/learned
+tutorials/plugin
+tutorials/production
+api
+```

tscp-0.1.0.dev0/docs/source/tutorials/component.md

@@ -0,0 +1,46 @@
+# Write a component
+
+A component is one choice on one axis. Writing one means subclassing the axis's base
+class and implementing a method or two; everything else (fitting, masks for unavailable
+and missing data, online release, devices, configs) is the composer's job.
+
+This weight scheme counts only the past errors at the same point of a cycle, such as the
+same hour of the day, and lets older cycles count less:
+
+```{literalinclude} ../../../examples/custom_component.py
+:language: python
+:pyobject: PeriodicWeights
+```
+
+Its constructor takes only JSON-friendly arguments, so its config records and rebuilds
+it. `forward` returns nonnegative, unnormalized weights of each pool row for each query;
+the composer multiplies them by the availability and observed masks, so the component
+never handles either.
+
+## Check it
+
+{mod}`tscp.testing` checks that a component keeps its axis's contract, and that a method
+keeps tscp's: causality, split discipline, config round trips, saving and loading, and
+devices. A check raises an `AssertionError` that names the first property that fails.
+
+```{literalinclude} ../../../examples/custom_component.py
+:language: python
+:pyobject: main
+:start-at: def periodic_method
+:end-at: print("PeriodicWeights
+```
+
+There is a check per axis: {func}`~tscp.testing.check_score`,
+{func}`~tscp.testing.check_weights`, {func}`~tscp.testing.check_quantile_model`,
+{func}`~tscp.testing.check_online_update`, {func}`~tscp.testing.check_region` and
+{func}`~tscp.testing.check_feature_map`.
+
+## Use it
+
+```bash
+python examples/custom_component.py --config examples/configs/custom_component.yaml
+```
+
+On errors whose size depends on the hour, split conformal over-covers some hours and
+under-covers others; the periodic weights keep every hour near the target. To make the
+component buildable by name in specs, register it ({doc}`plugin`).