csiphon 0.2.0__tar.gz → 0.3.0__tar.gz

{csiphon-0.2.0/src/csiphon.egg-info → csiphon-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csiphon
-Version: 0.2.0
+Version: 0.3.0
 Summary: An online-first, schema-validated CSI preprocessing pipeline library.
 Author: Fabian Portner
 License-Expression: MIT
@@ -49,16 +49,17 @@ Dynamic: license-file
 
 # csiphon
 
-`csiphon` is an online-first processing library for WiFi Channel State
-Information. Compose reusable DSP steps, compile them against your capture
-setup, then pour a complete recording or stream live chunks through the same
-validated pipeline.
+`csiphon` is a Python library for preprocessing WiFi Channel State Information.
+You plug DSP steps together into a pipeline, csiphon checks that the pieces fit
+before you run anything, and the finished pipeline handles recordings and live
+streams alike. Every signal carries its axes by name, so you never have to
+wonder which one was the subcarrier again.
 
 ```python
 from csiphon import AcquisitionProfile, Pipeline
 from csiphon.steps import GainNormalize, Magnitude, WindowedVariance
 
-# Define the hardware setup
+# Describe the capture setup
 profile = AcquisitionProfile(
     n_rx_antennas=3,
     subcarrier_indices=tuple(range(52)),
@@ -81,6 +82,10 @@ print(siphon.describe())
 features = siphon.pour(profile.raw_signal(csi, timestamps)).single()
 ```
 
+A compiled pipeline is a `Siphon`. You `pour()` a recording through it or
+`stream()` live data, and collect results from named `Outlets`, which you can tap
+anywhere along the pipeline.
+
 ## What it does
 
 - **Catches structural mistakes before execution.** Compilation checks axes,
@@ -91,29 +96,38 @@ features = siphon.pour(profile.raw_signal(csi, timestamps)).single()
   complete recording.
 - **Supports branching pipelines.** Split into parallel feature paths, merge
   them again, and expose named intermediate outlets.
+- **Merges receivers.** Feed several receivers through their own inlets and line
+  them up on timestamps or on packet sequence numbers, which survive clock drift.
 - **Keeps real timestamps.** Non-uniform CSI sampling is expected; resampling is
-  explicit rather than silently assumed.
-- **Describes itself.** Steps and compiled siphons expose their contracts,
-  layouts, parameters, and streaming behavior, and can save that information
-  alongside results for reproducibility.
+  explicit rather than silently assumed. You can also drop packets on purpose,
+  with independent or bursty loss, to test how a pipeline copes.
+- **Describes itself.** `describe()` draws a compiled siphon as a data-flow graph
+  in the terminal. Steps and siphons expose their contracts, layouts, parameters,
+  and streaming behavior, and can save that information alongside results for
+  reproducibility.
 - **Measures itself.** `siphon.measure(signal)` pours once and reports each
   step's time and output shape (memory on request), per step or for a named
   group of consecutive steps.
 
-The built-in steps cover calibration, cleaning, filtering, delay and
-time-frequency transforms, temporal features, pooling, statistics, reduction,
-and restructuring. Custom steps use the same contracts and inspection tools.
+The built-in steps cover components, scaling, cleaning, calibration,
+normalization, baseline removal, filtering, temporal features, delay and
+time-frequency transforms, pooling, statistics, reduction, restructuring, and
+resampling. The
+[steps README](https://github.com/nzqo/csiphon/blob/main/src/csiphon/steps/README.md)
+lists the categories. Custom steps use the same contracts and inspection tools.
 
 ## Install
 
 ```bash
-pip install -e .
+pip install csiphon
 ```
 
-The core only depends on NumPy. Install every optional transform with:
+The core only depends on NumPy. A few steps (filters, STFT, multitaper,
+cubic-spline resampling) need the `[filters]` extra (SciPy), and the
+synchrosqueezed transform needs `[sst]`. Install everything with:
 
 ```bash
-pip install -e ".[all]"
+pip install "csiphon[all]"
 ```
 
-Runnable recipes live in [`examples/`](examples/).
+Runnable recipes live in [`examples/`](https://github.com/nzqo/csiphon/tree/main/examples).

csiphon-0.3.0/README.md

@@ -0,0 +1,92 @@
+<p align="center">
+  <img
+    src="https://raw.githubusercontent.com/nzqo/csiphon/main/assets/ai_slop_mascot.png"
+    alt="slop Kanna doing Wi-Fi plumbing"
+    width="400"
+  >
+</p>
+
+# csiphon
+
+`csiphon` is a Python library for preprocessing WiFi Channel State Information.
+You plug DSP steps together into a pipeline, csiphon checks that the pieces fit
+before you run anything, and the finished pipeline handles recordings and live
+streams alike. Every signal carries its axes by name, so you never have to
+wonder which one was the subcarrier again.
+
+```python
+from csiphon import AcquisitionProfile, Pipeline
+from csiphon.steps import GainNormalize, Magnitude, WindowedVariance
+
+# Describe the capture setup
+profile = AcquisitionProfile(
+    n_rx_antennas=3,
+    subcarrier_indices=tuple(range(52)),
+    sampling_rate_hz=1000.0,
+)
+
+# Define the pipeline steps
+siphon = (
+    Pipeline()
+    .then(Magnitude())
+    .then(GainNormalize())
+    .then(WindowedVariance(win_size_s=0.1))
+    .compile(profile)
+)
+
+# Generate a summary of the pipeline
+print(siphon.describe())
+
+# Push some data through it to run
+features = siphon.pour(profile.raw_signal(csi, timestamps)).single()
+```
+
+A compiled pipeline is a `Siphon`. You `pour()` a recording through it or
+`stream()` live data, and collect results from named `Outlets`, which you can tap
+anywhere along the pipeline.
+
+## What it does
+
+- **Catches structural mistakes before execution.** Compilation checks axes,
+  shapes, value semantics, and physical representations before data starts
+  flowing.
+- **Runs the same recipe in batch or live.** Every step states whether its
+  streaming computation matches batch, differs intentionally, or requires the
+  complete recording.
+- **Supports branching pipelines.** Split into parallel feature paths, merge
+  them again, and expose named intermediate outlets.
+- **Merges receivers.** Feed several receivers through their own inlets and line
+  them up on timestamps or on packet sequence numbers, which survive clock drift.
+- **Keeps real timestamps.** Non-uniform CSI sampling is expected; resampling is
+  explicit rather than silently assumed. You can also drop packets on purpose,
+  with independent or bursty loss, to test how a pipeline copes.
+- **Describes itself.** `describe()` draws a compiled siphon as a data-flow graph
+  in the terminal. Steps and siphons expose their contracts, layouts, parameters,
+  and streaming behavior, and can save that information alongside results for
+  reproducibility.
+- **Measures itself.** `siphon.measure(signal)` pours once and reports each
+  step's time and output shape (memory on request), per step or for a named
+  group of consecutive steps.
+
+The built-in steps cover components, scaling, cleaning, calibration,
+normalization, baseline removal, filtering, temporal features, delay and
+time-frequency transforms, pooling, statistics, reduction, restructuring, and
+resampling. The
+[steps README](https://github.com/nzqo/csiphon/blob/main/src/csiphon/steps/README.md)
+lists the categories. Custom steps use the same contracts and inspection tools.
+
+## Install
+
+```bash
+pip install csiphon
+```
+
+The core only depends on NumPy. A few steps (filters, STFT, multitaper,
+cubic-spline resampling) need the `[filters]` extra (SciPy), and the
+synchrosqueezed transform needs `[sst]`. Install everything with:
+
+```bash
+pip install "csiphon[all]"
+```
+
+Runnable recipes live in [`examples/`](https://github.com/nzqo/csiphon/tree/main/examples).

{csiphon-0.2.0 → csiphon-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csiphon"
-version = "0.2.0"
+version = "0.3.0"
 description = "An online-first, schema-validated CSI preprocessing pipeline library."
 readme = "README.md"
 requires-python = ">=3.12"

{csiphon-0.2.0 → csiphon-0.3.0}/src/csiphon/__init__.py

@@ -19,6 +19,7 @@ from csiphon.core import (
 from csiphon.inspection import describe
 from csiphon.pipeline import (
     Alignment,
+    ComplexFromParts,
     Concatenate,
     Exact,
     Fuse,
@@ -50,6 +51,7 @@ __all__ = [
     "Axis",
     "AxisName",
     "Category",
+    "ComplexFromParts",
     "Concatenate",
     "Description",
     "Exact",

{csiphon-0.2.0 → csiphon-0.3.0}/src/csiphon/pipeline/__init__.py

@@ -6,6 +6,7 @@ from csiphon.pipeline._align_ops import align_on_time
 from csiphon.pipeline.measure import GroupCost, MeasuredRun, StepCost
 from csiphon.pipeline.merges import (
     Alignment,
+    ComplexFromParts,
     Concatenate,
     Exact,
     Fuse,
@@ -24,6 +25,7 @@ from csiphon.pipeline.step import PointwiseStep, Step, StreamOperator
 
 __all__ = [
     "Alignment",
+    "ComplexFromParts",
     "Concatenate",
     "Exact",
     "Fuse",

{csiphon-0.2.0 → csiphon-0.3.0}/src/csiphon/pipeline/measure.py

@@ -16,7 +16,13 @@ from typing import TYPE_CHECKING
 
 from csiphon.core.signal import Signal
 from csiphon.pipeline.merges import Junction
-from csiphon.pipeline.runners import Outlets, _run_node, _seed_inlets
+from csiphon.pipeline.runners import (
+    Outlets,
+    _run_node,
+    _seed_inlets,
+    last_readers,
+    release_spent_lines,
+)
 
 if TYPE_CHECKING:
     from csiphon.pipeline.pipeline import Node, Siphon
@@ -188,11 +194,14 @@ def measure(
         tracemalloc.start()
     try:
         env = _seed_inlets(siphon, signals, allow_partial=False)
+        last_reader = last_readers(siphon)
         steps: list[StepCost] = []
         for number, node in enumerate(siphon.nodes, start=1):
             inputs = [env[line] for line in node.inputs]
             env[node.output], cost = _measure_node(number, node, inputs, memory)
             steps.append(cost)
+            del inputs
+            release_spent_lines(env, siphon, node, number - 1, last_reader)
     finally:
         if tracing:
             tracemalloc.stop()

{csiphon-0.2.0 → csiphon-0.3.0}/src/csiphon/pipeline/merges.py

@@ -211,6 +211,41 @@ class Sum(MergeStrategy):
         return as_signal_array(np.sum(np.stack(arrays, axis=0), axis=0))
 
 
+@dataclass(frozen=True, slots=True)
+class ComplexFromParts(MergeStrategy):
+    """Join a real-part branch and an imaginary-part branch into complex values.
+
+    The first branch is the real part, the second the imaginary part. Name them at
+    the merge so the order is explicit:
+    `.merge(["re", "im"], using=ComplexFromParts())`.
+    """
+
+    def output_layout(self, inputs: SequenceABC[Layout]) -> Layout:
+        """Require two matching real-valued branches; the result is complex."""
+
+        if len(inputs) != 2:
+            raise LayoutError(
+                "ComplexFromParts needs exactly two branches (real part, imaginary "
+                f"part), got {len(inputs)}."
+            )
+        _require_matching(inputs)
+        if inputs[0].values != ValueKind.REAL:
+            raise LayoutError(
+                "ComplexFromParts needs real-valued branches, got "
+                f"{inputs[0].values.value}."
+            )
+        return inputs[0].with_values(ValueKind.COMPLEX)
+
+    def combine(
+        self, arrays: SequenceABC[SignalArray], inputs: SequenceABC[Layout]
+    ) -> SignalArray:
+        """Return `real + 1j * imaginary`."""
+
+        del inputs
+        real, imaginary = arrays
+        return as_signal_array(real + 1j * imaginary)
+
+
 def _unify_values(kinds: SequenceABC[ValueKind]) -> ValueKind:
     """The value kind of fused branches: keep it if shared, else a common numeric kind.
 

{csiphon-0.2.0 → csiphon-0.3.0}/src/csiphon/pipeline/runners.py

@@ -150,12 +150,42 @@ def pour(siphon: Siphon, signals: Signal | Mapping[str, Signal]) -> Outlets:
     """Run a whole recording through a siphon and return every outlet."""
 
     env = _seed_inlets(siphon, signals, allow_partial=False)
-    for node in siphon.nodes:
+    last_reader = last_readers(siphon)
+    for index, node in enumerate(siphon.nodes):
         inputs = [env[line] for line in node.inputs]
         env[node.output] = _run_node(node, inputs)
+        del inputs
+        release_spent_lines(env, siphon, node, index, last_reader)
     return Outlets({display: env[line] for display, line in siphon.outlets.items()})
 
 
+def last_readers(siphon: Siphon) -> dict[str, int]:
+    """For every line, the index of the last node that reads it."""
+
+    return {
+        line: index for index, node in enumerate(siphon.nodes) for line in node.inputs
+    }
+
+
+def release_spent_lines(
+    env: dict[str, Signal],
+    siphon: Siphon,
+    node: Node,
+    index: int,
+    last_reader: Mapping[str, int],
+) -> None:
+    """Drop this node's input lines that no later node reads and no outlet shows.
+
+    A whole-recording run would otherwise hold every intermediate signal until the
+    end; for wide signals (many channels, spectrograms) that multiplies the memory.
+    """
+
+    outlet_lines = set(siphon.outlets.values())
+    for line in node.inputs:
+        if last_reader[line] == index and line not in outlet_lines:
+            env.pop(line, None)
+
+
 def _run_node(node: Node, inputs: list[Signal]) -> Signal:
     """Run one node in batch: a junction takes all inputs, a step takes the one."""
 

{csiphon-0.2.0 → csiphon-0.3.0}/src/csiphon/steps/__init__.py

@@ -15,7 +15,14 @@ numpy-only.
 from csiphon.steps.baseline import RunningMeanSubtract, TemporalMeanSubtract
 from csiphon.steps.calibration import AxisReference, LinearPhaseCorrection
 from csiphon.steps.cleaning import NanScrub, NoiseFloorClip
-from csiphon.steps.components import Magnitude, Phase, Power, UnitPhase
+from csiphon.steps.components import (
+    ImagPart,
+    Magnitude,
+    Phase,
+    Power,
+    RealPart,
+    UnitPhase,
+)
 from csiphon.steps.delay import (
     ChannelImpulseResponse,
     DelayAutocorrelation,
@@ -89,6 +96,7 @@ __all__ = [
     "GainNormalize",
     "GlobalMaxNormalize",
     "Hold",
+    "ImagPart",
     "Independent",
     "Linear",
     "LinearPhaseCorrection",
@@ -107,6 +115,7 @@ __all__ = [
     "PolarLinear",
     "Power",
     "PrincipalComponents",
+    "RealPart",
     "Resample",
     "RobustPca",
     "RunningMeanSubtract",

{csiphon-0.2.0 → csiphon-0.3.0}/src/csiphon/steps/components/__init__.py

@@ -1,8 +1,10 @@
-"""Component steps: a direct per-value component (magnitude, phase, power)."""
+"""Component steps: a direct per-value component (magnitude, phase, power, parts)."""
 
+from csiphon.steps.components.imag_part import ImagPart
 from csiphon.steps.components.magnitude import Magnitude
 from csiphon.steps.components.phase import Phase
 from csiphon.steps.components.power import Power
+from csiphon.steps.components.real_part import RealPart
 from csiphon.steps.components.unit_phase import UnitPhase
 
-__all__ = ["Magnitude", "Phase", "Power", "UnitPhase"]
+__all__ = ["ImagPart", "Magnitude", "Phase", "Power", "RealPart", "UnitPhase"]

csiphon-0.3.0/src/csiphon/steps/components/imag_part.py

@@ -0,0 +1,53 @@
+"""Element-wise imaginary part."""
+
+# Same spec and method skeleton as RealPart and the other one-component steps by
+# design; only the part taken differs.
+# pylint: disable=duplicate-code
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+from csiphon.core.arrays import SignalArray, as_real_array
+from csiphon.core.layout import Layout
+from csiphon.core.profile import AcquisitionProfile
+from csiphon.core.semantics import ValueKind
+from csiphon.core.signal import Signal
+from csiphon.pipeline.step import PointwiseStep
+from csiphon.spec import Category, LayoutEffect, StepSpec, Streaming
+
+
+@dataclass(frozen=True, slots=True)
+class ImagPart(PointwiseStep):
+    """Take the element-wise imaginary part.
+
+    With `RealPart` and the `ComplexFromParts` merge, this runs a real-only step
+    on complex CSI part by part.
+    """
+
+    spec: ClassVar[StepSpec] = StepSpec(
+        name="imag-part",
+        summary="take the imaginary part",
+        category=Category.COMPONENTS,
+        admissible_values=(ValueKind.COMPLEX,),
+        admissible_reprs=None,
+        requires_axes=(),
+        layout_effect=LayoutEffect(value_kind=ValueKind.REAL),
+        streaming=Streaming.BATCH_EQUIVALENT,
+    )
+
+    def output_layout(self, layout: Layout, profile: AcquisitionProfile) -> Layout:
+        """Complex input becomes real-valued."""
+
+        self.require_inputs(layout)
+        return layout.with_values(ValueKind.REAL)
+
+    def transform_values(
+        self,
+        values: SignalArray,
+        signal: Signal,
+        out_layout: Layout,
+        profile: AcquisitionProfile,
+    ) -> SignalArray:
+        """Return `values.imag`."""
+
+        return as_real_array(values.imag)

csiphon-0.3.0/src/csiphon/steps/components/real_part.py

@@ -0,0 +1,53 @@
+"""Element-wise real part."""
+
+# Same spec and method skeleton as ImagPart and the other one-component steps by
+# design; only the part taken differs.
+# pylint: disable=duplicate-code
+
+from dataclasses import dataclass
+from typing import ClassVar
+
+from csiphon.core.arrays import SignalArray, as_real_array
+from csiphon.core.layout import Layout
+from csiphon.core.profile import AcquisitionProfile
+from csiphon.core.semantics import ValueKind
+from csiphon.core.signal import Signal
+from csiphon.pipeline.step import PointwiseStep
+from csiphon.spec import Category, LayoutEffect, StepSpec, Streaming
+
+
+@dataclass(frozen=True, slots=True)
+class RealPart(PointwiseStep):
+    """Take the element-wise real part.
+
+    With `ImagPart` and the `ComplexFromParts` merge, this runs a real-only step
+    on complex CSI part by part.
+    """
+
+    spec: ClassVar[StepSpec] = StepSpec(
+        name="real-part",
+        summary="take the real part",
+        category=Category.COMPONENTS,
+        admissible_values=(ValueKind.COMPLEX,),
+        admissible_reprs=None,
+        requires_axes=(),
+        layout_effect=LayoutEffect(value_kind=ValueKind.REAL),
+        streaming=Streaming.BATCH_EQUIVALENT,
+    )
+
+    def output_layout(self, layout: Layout, profile: AcquisitionProfile) -> Layout:
+        """Complex input becomes real-valued."""
+
+        self.require_inputs(layout)
+        return layout.with_values(ValueKind.REAL)
+
+    def transform_values(
+        self,
+        values: SignalArray,
+        signal: Signal,
+        out_layout: Layout,
+        profile: AcquisitionProfile,
+    ) -> SignalArray:
+        """Return `values.real`."""
+
+        return as_real_array(values.real)

{csiphon-0.2.0 → csiphon-0.3.0}/src/csiphon/steps/filtering/butterworth_filter.py

@@ -15,7 +15,7 @@ from typing import ClassVar, cast
 
 import numpy as np
 
-from csiphon.core.arrays import RealArray, as_real_array
+from csiphon.core.arrays import RealArray, SignalArray, as_signal_array
 from csiphon.core.axes import AxisName
 from csiphon.core.errors import LayoutError, MissingDependencyError
 from csiphon.core.layout import Layout
@@ -71,7 +71,9 @@ class ButterworthFilter(Step):
     """Butterworth filter along the time axis.
 
     `cutoff_hz` is a scalar for `low` / `high` and a `(low, high)` pair
-    for `band`. Batch is zero-phase; streaming is causal.
+    for `band`. Batch is zero-phase; streaming is causal. Complex input is filtered
+    on its real and imaginary parts, the same filter on each. The explicit form is
+    `RealPart` / `ImagPart` branches merged with `ComplexFromParts`.
     """
 
     cutoff_hz: float | tuple[float, float] = field(
@@ -87,7 +89,12 @@ class ButterworthFilter(Step):
         name="butterworth-filter",
         summary="apply a Butterworth filter along time (zero-phase batch, causal stream)",  # noqa: E501
         category=Category.FILTERING,
-        admissible_values=(ValueKind.REAL, ValueKind.MAGNITUDE, ValueKind.POWER),
+        admissible_values=(
+            ValueKind.COMPLEX,
+            ValueKind.REAL,
+            ValueKind.MAGNITUDE,
+            ValueKind.POWER,
+        ),
         admissible_reprs=None,
         requires_axes=(AxisName.TIME,),
         layout_effect=LayoutEffect(),
@@ -138,7 +145,7 @@ class ButterworthFilter(Step):
             self.order, self.cutoff_hz, self.btype, rate_hz
         )
         filtered = scipy_signal.filtfilt(
-            numerator, denominator, as_real_array(signal.values), axis=time_index
+            numerator, denominator, as_signal_array(signal.values), axis=time_index
         )
         return signal.with_values(filtered, out_layout)
 
@@ -166,7 +173,7 @@ class _CausalFilter(StreamOperator):
         self._numerator = numerator
         self._denominator = denominator
         self._out_layout = out_layout
-        self._state: RealArray | None = None
+        self._state: SignalArray | None = None
 
     def push(self, chunk: Signal) -> Signal:
         """Filter this chunk causally, updating the filter state."""
@@ -176,7 +183,7 @@ class _CausalFilter(StreamOperator):
             return empty_signal(self._out_layout)
 
         scipy_signal = _scipy_signal()
-        data = np.moveaxis(as_real_array(chunk.values), time_index, 0)
+        data = np.moveaxis(as_signal_array(chunk.values), time_index, 0)
         flat = data.reshape(data.shape[0], -1)
 
         if self._state is None:

{csiphon-0.2.0 → csiphon-0.3.0/src/csiphon.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csiphon
-Version: 0.2.0
+Version: 0.3.0
 Summary: An online-first, schema-validated CSI preprocessing pipeline library.
 Author: Fabian Portner
 License-Expression: MIT
@@ -49,16 +49,17 @@ Dynamic: license-file
 
 # csiphon
 
-`csiphon` is an online-first processing library for WiFi Channel State
-Information. Compose reusable DSP steps, compile them against your capture
-setup, then pour a complete recording or stream live chunks through the same
-validated pipeline.
+`csiphon` is a Python library for preprocessing WiFi Channel State Information.
+You plug DSP steps together into a pipeline, csiphon checks that the pieces fit
+before you run anything, and the finished pipeline handles recordings and live
+streams alike. Every signal carries its axes by name, so you never have to
+wonder which one was the subcarrier again.
 
 ```python
 from csiphon import AcquisitionProfile, Pipeline
 from csiphon.steps import GainNormalize, Magnitude, WindowedVariance
 
-# Define the hardware setup
+# Describe the capture setup
 profile = AcquisitionProfile(
     n_rx_antennas=3,
     subcarrier_indices=tuple(range(52)),
@@ -81,6 +82,10 @@ print(siphon.describe())
 features = siphon.pour(profile.raw_signal(csi, timestamps)).single()
 ```
 
+A compiled pipeline is a `Siphon`. You `pour()` a recording through it or
+`stream()` live data, and collect results from named `Outlets`, which you can tap
+anywhere along the pipeline.
+
 ## What it does
 
 - **Catches structural mistakes before execution.** Compilation checks axes,
@@ -91,29 +96,38 @@ features = siphon.pour(profile.raw_signal(csi, timestamps)).single()
   complete recording.
 - **Supports branching pipelines.** Split into parallel feature paths, merge
   them again, and expose named intermediate outlets.
+- **Merges receivers.** Feed several receivers through their own inlets and line
+  them up on timestamps or on packet sequence numbers, which survive clock drift.
 - **Keeps real timestamps.** Non-uniform CSI sampling is expected; resampling is
-  explicit rather than silently assumed.
-- **Describes itself.** Steps and compiled siphons expose their contracts,
-  layouts, parameters, and streaming behavior, and can save that information
-  alongside results for reproducibility.
+  explicit rather than silently assumed. You can also drop packets on purpose,
+  with independent or bursty loss, to test how a pipeline copes.
+- **Describes itself.** `describe()` draws a compiled siphon as a data-flow graph
+  in the terminal. Steps and siphons expose their contracts, layouts, parameters,
+  and streaming behavior, and can save that information alongside results for
+  reproducibility.
 - **Measures itself.** `siphon.measure(signal)` pours once and reports each
   step's time and output shape (memory on request), per step or for a named
   group of consecutive steps.
 
-The built-in steps cover calibration, cleaning, filtering, delay and
-time-frequency transforms, temporal features, pooling, statistics, reduction,
-and restructuring. Custom steps use the same contracts and inspection tools.
+The built-in steps cover components, scaling, cleaning, calibration,
+normalization, baseline removal, filtering, temporal features, delay and
+time-frequency transforms, pooling, statistics, reduction, restructuring, and
+resampling. The
+[steps README](https://github.com/nzqo/csiphon/blob/main/src/csiphon/steps/README.md)
+lists the categories. Custom steps use the same contracts and inspection tools.
 
 ## Install
 
 ```bash
-pip install -e .
+pip install csiphon
 ```
 
-The core only depends on NumPy. Install every optional transform with:
+The core only depends on NumPy. A few steps (filters, STFT, multitaper,
+cubic-spline resampling) need the `[filters]` extra (SciPy), and the
+synchrosqueezed transform needs `[sst]`. Install everything with:
 
 ```bash
-pip install -e ".[all]"
+pip install "csiphon[all]"
 ```
 
-Runnable recipes live in [`examples/`](examples/).
+Runnable recipes live in [`examples/`](https://github.com/nzqo/csiphon/tree/main/examples).