Python API

The root package exposes the prospective supported and experimental public surface. Consult the API stability policy before depending on experimental method families.

fiberphotometry

Composable fiber photometry analysis.

AcquisitionField dataclass

One discoverable field in an acquisition source.

AcquisitionInspection dataclass

Dependency-light inventory returned before scientific channel mapping.

ArchiveCreator dataclass

One archive creator, optionally identified by ORCID.

ArchiveMetadata dataclass

Repository-neutral metadata used to derive deposit-specific records.

ArchivePackage dataclass

Description of a completed deterministic deposit archive.

ArchiveRelatedIdentifier dataclass

A typed relationship from the archive to another resource.

AssociationAnimalEstimate dataclass

One animal-condition value after equal-session aggregation.

AssociationAnimalInferenceResult dataclass

Animal-level contrast, interval, randomization test, and complete ledger.

AssociationAnimalInferenceSpec dataclass

Declare a condition contrast without treating sites or sessions as animals.

AssociationPopulationMaterialization dataclass

Animal-condition association cells ready for common population inference.

contrast(spec)

Apply the common population contrast to association cells.

interaction(assignments, spec)

Compare within-animal association contrasts across disjoint groups.

to_json()

Serialize association cells and their actual lower-level support.

AssociationSessionEstimate dataclass

One session-level scalar with its support and source method.

AutocorrelationResult dataclass

Energy-normalized autocorrelation that never pairs samples across gaps.

to_json()

Serialize values and continuity evidence.

AutocorrelationSpec dataclass

Explicit lag, detrending, and continuity choices.

BaselineDFFOperation dataclass

Signal-only baseline correction with explicit normalization semantics.

BehaviorAnnotations dataclass

Point events and intervals discovered by an external behavior tool.

event_times(*, edge='onset', include_points=True)

Return event-kernel-ready times without discarding interval identity.

interval_encoding_inputs(*, edge='onset')

Return aligned interval edges, duration values and physical bounds.

normalized_progress(time_s, *, label)

Map samples inside non-overlapping bouts to progress in [0, 1].

BehaviorCovariate dataclass

One timestamped external covariate with an explicit validity mask.

align_to(target_time_s, *, target_clock_id, max_gap_s)

Return aligned values; use :meth:aligned_to to retain the mask.

aligned_to(target_time_s, *, target_clock_id, max_gap_s)

Interpolate within valid runs and retain the aligned validity mask.

BehaviorInterval dataclass

One externally identified behavioral state or bout.

BlockPermutationResult dataclass

Blocked null evidence for zero-lag and maximum-lag association.

BlockPermutationSpec dataclass

Within-session null that re-pairs complete temporal blocks.

BundleComparison dataclass

Byte, project, and scientific agreement for two evidence bundles.

ChannelFrozenTransientThreshold dataclass

One channel-specific threshold and its calibration denominator.

ChannelIdentity dataclass

Declared biological and optical identity of one analyzed signal.

ChannelValidityMetrics dataclass

Observable validity metrics for one optical channel.

ClockPulseMatches dataclass

Explicit one-to-one synchronization pulses observed on two clocks.

from_arrays(*, source_clock_id, target_clock_id, source_time_s, target_time_s, match_labels=None) classmethod

Create declared pulse pairs without attempting automatic matching.

ClockSynchronization dataclass

Accepted affine mapping and complete pulse-level diagnostic evidence.

synchronize_annotations(annotations, *, maximum_extrapolation_s=0.0)

Transform point and interval times while retaining their semantics.

synchronize_covariate(covariate, *, maximum_extrapolation_s=0.0)

Transform covariate timestamps and append synchronization provenance.

synchronize_pose(pose, *, maximum_extrapolation_s=0.0)

Transform pose timestamps without changing coordinates or confidence.

to_json()

Serialize the accepted mapping and all matched-pulse evidence.

transform_time(source_time_s, *, maximum_extrapolation_s=0.0)

Map source times, refusing extrapolation beyond a declared allowance.

ClockSynchronizationSpec dataclass

Prospective acceptance thresholds for an affine clock mapping.

CoherenceBandSummary dataclass

One declared frequency-band summary from a pooled cross-spectrum.

CoherencePhaseResult dataclass

Pooled cross-spectrum, magnitude-squared coherence, and relative phase.

to_json()

Serialize cross-spectral values and joint continuity evidence.

CompatibilityRule dataclass

Reject a universe when every named choice in when is selected.

ContextualizeIntervals dataclass

Relabel target intervals from overlap with a named external context source.

ContinuityEvidence dataclass

Sampling and missing-data evidence shared by spectral results.

ContinuityRun dataclass

Evidence for one uninterrupted, regular run used by an analysis.

ContinuousCoefficient dataclass

Coefficient for a one-standard-deviation continuous-covariate change.

CrosstalkDiagnosticResult dataclass

Metadata and association diagnostics without automatic correction.

to_json()

Serialize flags and the evidence used to compute them.

CrosstalkDiagnosticSpec dataclass

Operational flags that prompt review but do not prove contamination.

CrosstalkFlag dataclass

One reason to review optical or shared-driver contamination.

CurvePopulationMaterialization dataclass

Aligned animal-level curves ready for common population inference.

contrast(spec)

Apply pointwise and simultaneous inference to animal-level curves.

interaction(assignments, spec)

Compare within-animal curves across two disjoint groups.

to_json()

Serialize axes, session curves, animal cells, and support.

DifferenceOfExponentialsModel dataclass

Causal unit-area rise/decay response with a declared steady-state gain.

DoricChannel dataclass

Explicit Doric series mapping for one anatomical signal channel.

DoricDigitalEvents dataclass

Convert threshold crossings in one Doric series to named events.

DoricSchema dataclass

Versioned scientific mapping independent of mutable HDF5 hierarchy names.

DoricSeries dataclass

One numeric Doric dataset and its associated time dataset.

EncodingAlphaResult dataclass

Cross-validated performance for one ridge penalty.

EncodingFoldResult dataclass

Held-out group identities and prediction score for one fold.

EncodingGroupDiagnostic dataclass

Out-of-fold prediction and residual diagnostics for one complete group.

EncodingModelAlternative dataclass

One named, scientifically justified event-kernel model specification.

EncodingModelComparison dataclass

Predictive comparison to the reference with denominator safeguards.

EncodingModelResult dataclass

Fitted kernels plus group-held-out predictive validation evidence.

EncodingModelSpec dataclass

Declared predictors and grouped validation policy for one encoding model.

EncodingMultiverseResult dataclass

Complete event-kernel model ledger without automatic winner selection.

EncodingMultiverseSpec dataclass

Named model alternatives sharing one predictive-validation policy.

EncodingMultiverseSummary dataclass

Failure-aware counts and directly comparable held-out score range.

EncodingResidualDiagnostics dataclass

Group-held-out diagnostics with lag calculations reset by session.

EncodingSession dataclass

One continuous response with aligned events and continuous covariates.

from_arrays(*, subject, session, time, response, events, continuous_covariates=None, response_valid=None, continuous_covariate_validity=None, event_values=None, intervals=None) classmethod

Create a validated session without joining signals across recordings.

EncodingSessionCoverage dataclass

Complete-case exclusions for one session before model fitting.

EncodingUniverseResult dataclass

One successful or failed model fit retained in the execution ledger.

EncodingValidityReport dataclass

Declared mask policy and retained denominators for an encoding model.

EventAnalysis dataclass

High-level workflow for a paired or independent animal event contrast.

pipeline_spec(*, acknowledged_assumptions=())

Build the complete typed pipeline without accessing outcome values.

plan(*, acknowledged_assumptions=())

Create the inference plan without reading fluorescence outcome values.

run(*, acknowledged_assumptions)

Execute only after the caller explicitly acknowledges plan assumptions.

EventAnalysisConfig dataclass

Validated, serializable choices that can be applied to loaded sessions.

fingerprint property

Return a stable SHA-256 over normalized configuration choices.

build(sessions)

Apply configuration choices to already-loaded labelled sessions.

from_mapping(payload) classmethod

Build a strict configuration from an already parsed TOML table.

from_toml(source) classmethod

Load a strict configuration from TOML text, bytes, or a path.

run(sessions)

Build and execute using assumptions explicitly recorded in the file.

to_json()

Return the normalized configuration and its fingerprint.

EventAnalysisResult dataclass

Completed pipeline plus enough declared context to render or serialize it.

to_html()

Render a self-contained evidence report without external assets.

write_html(path)

Write the self-contained report and return its resolved path.

write_json(path)

Write the machine-readable result and return its resolved path.

EventCoverageCounts dataclass

Candidate, gated, and complete event counts with explicit denominators.

EventCoverageRecord dataclass

One candidate event's path through eligibility and preprocessing.

EventCoverageReport dataclass

Auditable event denominators at study, animal, and session levels.

to_json()

Serialize the complete coverage audit.

EventCoverageStratum dataclass

Coverage totals and condition-specific counts for one named stratum.

EventKernelBasisResult dataclass

Basis weights and sampled functions used to reconstruct one kernel.

EventKernelInterval dataclass

Pointwise and optional simultaneous uncertainty for one event kernel.

EventKernelResult dataclass

Estimated response-unit change at each lag for one event type.

EventKernelSpec dataclass

One named event train, lag window and typed kernel basis.

EventModulationSpec dataclass

Multiply an event kernel by a declared current or lagged event value.

EventSession dataclass

One recording and the categorical labels attached to its events.

from_arrays(recording, event_times, conditions, *, event_ids=None, eligible=None, exclusion_reasons=None) classmethod

Create a session with stable generated event IDs when none are supplied.

EventSummarySpec dataclass

Acquired-sample event summary to expose as an observation-table column.

EvidenceDifference dataclass

One typed semantic difference between evidence records.

EvidenceFile dataclass

One evidence artifact and its manifest-verification state.

FIRBasisSpec dataclass

One unconstrained coefficient per sampled event lag.

Factor dataclass

An inferential factor and the unit at which its labels are assigned.

FilterIntervals dataclass

Keep intervals that satisfy declared label, duration, and confidence rules.

FrozenTransientThresholds dataclass

Immutable control/baseline thresholds bound to one detector contract.

for_channel(channel)

Resolve one channel, refusing absent or duplicate calibration.

to_json()

Serialize threshold values, source identity, and denominators.

GapHandlingSpec dataclass

Declare how missing samples, acquisition gaps, and clock jitter are handled.

GroupedKernelUncertainty dataclass

Delete-one-group sensitivity intervals conditional on one ridge penalty.

GuppyTransientDetectorSpec dataclass

GuPPY-compatible two-threshold MAD detector within fixed chunks.

IntervalEncodingInputs dataclass

Aligned interval edges, durations and physical bounds for encoding models.

IntervalPolicy dataclass

An ordered, reproducible sequence of interval transformations.

IntervalPolicyContext dataclass

A named external annotation source bound into policy evidence.

IntervalPolicyLedgerEntry dataclass

Inputs and outputs for one auditable policy decision.

IntervalPolicyResult dataclass

Transformed annotations and complete provenance for every policy operation.

to_dict()

Return a JSON-serializable evidence artifact.

IntervalSnapshot dataclass

One immutable interval identity recorded in the transformation ledger.

IsosbesticValidityMetrics dataclass

Pairwise timing and event diagnostics for a declared reference channel.

JointContinuityEvidence dataclass

Joint validity and continuity evidence for two aligned signals.

KernelUncertaintySpec dataclass

Default grouped pointwise sensitivity policy.

KineticDeconvolutionResult dataclass

Conditional latent-input estimate with reconstruction and refusal evidence.

to_json()

Serialize estimates, diagnostics, model assumptions, and provenance.

KineticDeconvolutionRun dataclass

One solved run's reconstruction and optimization diagnostics.

KineticDeconvolutionSpec dataclass

Declare regularization and pre-outcome identifiability gates.

KineticForwardResult dataclass

Predicted sensor output plus model, continuity, and boundary evidence.

to_json()

Serialize output, model identity, continuity, and provenance.

KineticForwardRun dataclass

One continuity run predicted without carrying state across its boundary.

KineticForwardSpec dataclass

Declare gap and initial-state policy for forward prediction.

KineticIdentifiabilityAssessment dataclass

Outcome-blind model, sampling, transfer, and regularization assessment.

require_ready(*, allow_warnings=True)

Raise when the assessment cannot support the requested inversion.

to_json()

Serialize the complete prospective identifiability assessment.

KineticIdentifiabilityIssue dataclass

One actionable reason to warn about or refuse sensor inversion.

KineticKernel dataclass

Executable discrete kernel and its continuous-time interpretation.

KineticModelIdentity dataclass

Versioned scientific identity and unit contract for one response model.

KineticRunIdentifiability dataclass

Pre-outcome sampling and duration evidence for one continuity run.

LaggedAssociationResult dataclass

Gap-separated, optionally residualized association across physical lags.

to_json()

Serialize association values, metadata, and support evidence.

LaggedAssociationSpec dataclass

Declare lag, detrending, missingness, and optional blocked-null choices.

LinearProgressBasisSpec dataclass

Piecewise-linear basis over normalized interval progress in [0, 1].

LowpassFilterOperation dataclass

Zero-phase Butterworth low-pass operation.

MaterializedEncodingUniverse dataclass

Stable pre-execution identity for one declared model alternative.

MergeIntervals dataclass

Merge same-label intervals separated by at most maximum_gap_s.

MultiplierSimultaneousBandSpec dataclass

Explicit opt-in to the incompletely calibrated multiplier max-t band.

MultiscaleAnimalEstimate dataclass

One animal-condition estimate after window and session aggregation.

MultiscaleAnimalInferenceResult dataclass

Animal-level effect, interval, randomization test, and ledger.

MultiscaleAnimalInferenceSpec dataclass

Declare a session-to-animal contrast for one scale and metric.

MultiscaleContinuityRun dataclass

One valid run bounded by missingness, a gap, or a state epoch.

MultiscaleContinuitySpec dataclass

Declare when adjacent observations cease to be continuous evidence.

MultiscaleEstimate dataclass

One observable metric tied to an accepted source window.

MultiscaleRunExclusion dataclass

A valid segment that cannot support physical-time integration.

MultiscaleStudySession dataclass

Attach subject, session, and experimental condition identity.

MultiscaleSummaryResult dataclass

Multiscale estimates plus complete continuity and window evidence.

to_json()

Serialize estimates and every acceptance denominator.

MultiscaleSummarySpec dataclass

Declare scales, observable metrics, and continuity policy.

MultiscaleWindowRecord dataclass

Acceptance ledger for one candidate physical-time window.

MultiscaleWindowSpec dataclass

One named physical-time window and its acceptance denominator.

resolved_step_s property

Return the explicit step, or a non-overlapping duration-sized step.

MultiverseLaneSummary dataclass

Machine-readable robustness summary for one compatible measurement scale.

MultiverseReportGroup dataclass

A unit-compatible set of universes that may share a visual evidence lane.

from_choice(result, *, name, units, node, alternatives, smallest_effect=None, direction='either') classmethod

Select every compatible universe matching alternatives at one node.

MultiverseResult dataclass

grouped_summary(groups)

Summarize each complete unit-compatible evidence lane independently.

grouped_summary_json(groups)

Serialize unit-local robustness summaries without pooled magnitudes.

to_grouped_html(groups, *, title='Fiber photometry robustness report')

Render unit-compatible universes in explicitly separate evidence lanes.

write_grouped_html(path, groups, *, title='Fiber photometry robustness report')

Write a self-contained grouped report and return its resolved path.

NWBExportConfig dataclass

Metadata required to create valid per-session NWB files.

NdxPoseEstimationInspection dataclass

Discoverable structure and provenance for one PoseEstimation container.

NdxPoseFileInspection dataclass

Dependency-backed inventory of ndx-pose containers in one NWB file.

NdxPoseImportResult dataclass

Copied pose trajectories plus retained container and source evidence.

NdxPoseMetadata dataclass

Container-level ndx-pose metadata retained independently of arrays.

NdxPoseSeriesInspection dataclass

Bounded structural evidence for one ndx-pose keypoint series.

NdxPoseWriteResult dataclass

Created extension objects and any links not supplied for the destination.

NeurophotometricsChannel dataclass

Map one ROI column and excitation wavelengths to an anatomical channel.

NeurophotometricsDigitalEvents dataclass

Decode an acquisition flag bit into named transition events.

NeurophotometricsSchema dataclass

Explicit ROI/wavelength meaning with conservative column-name discovery.

ObservationTable dataclass

Open metadata columns with equal length and no imposed scientific ontology.

OpticalAvailabilityPattern dataclass

Identifiability evidence for one observed channel subset.

OpticalCalibrationChannelDiagnostic dataclass

In-sample fit evidence for one independently calibrated channel row.

OpticalChannelHoldoutDiagnostic dataclass

Reconstruction of one channel from all other simultaneously observed rows.

OpticalComponent dataclass

One declared latent contribution and its interpretation boundary.

OpticalMixingCalibrationResult dataclass

Fitted external calibration matrix and descriptive fit diagnostics.

to_json()

Serialize calibration coefficients, diagnostics, and provenance.

OpticalMixingCalibrationSpec dataclass

Declare fitting gates for an independent known-component calibration.

OpticalMixingChannel dataclass

One measured channel, calibrated component loadings, and offset.

OpticalMixingDesign dataclass

Externally identified linear map from components to measurements.

OpticalMixingDesignAssessment dataclass

Rank, conditioning, metadata, and holdout-identifiability evidence.

to_json()

Serialize design evidence before any signal outcome is accessed.

OpticalMixingIssue dataclass

One machine-readable design or validation concern.

OpticalUnmixingResult dataclass

Unmixed sources, channel reconstructions, residuals, and complete evidence.

component(component_id)

Return one component series by declared identity.

to_json()

Serialize sources, predictions, residuals, and evidence.

OpticalUnmixingSpec dataclass

Declare identifiability, wavelength, missingness, and QC gates.

OptogeneticArtifactAssessment dataclass

Pulse-level recovery evidence that remains separate from mask construction.

to_json()

Serialize pulse-level recovery and control evidence.

OptogeneticArtifactMask dataclass

A reusable boolean validity mask with complete pulse-time provenance.

artifact_array property

Return a copy marking stimulation-artifact samples.

valid_array property

Return a copy suitable for downstream valid arguments.

to_json()

Serialize the mask, pulse ledger, and effective denominator.

OptogeneticMaskSpec dataclass

Prospective time-only exclusion policy around stimulation intervals.

OptogeneticMaskedInterval dataclass

One merged exclusion interval and the pulses that generated it.

OptogeneticRecoverySpec dataclass

Observed artifact and recovery measurements that never alter the mask.

PastaTransientDetectorSpec dataclass

PASTa-compatible local-baseline amplitude detector.

PeriEventInferenceResult dataclass

A contrast curve plus its complete session-to-population evidence chain.

to_json()

Serialize arrays, unit ledgers, and inferential semantics.

PeriEventInferenceSpec dataclass

Declared alignment, population design, and uncertainty choices.

PeriEventInteractionResult dataclass

A peri-event group-by-condition interaction with complete unit evidence.

estimate property

Return the group difference between within-animal condition curves.

to_json()

Serialize the complete event-to-interaction evidence chain.

PeriEventSessionEstimate dataclass

One session-condition curve before equal-session animal aggregation.

PipelineResult dataclass

All intermediate products, including a useful result when QC blocks inference.

PipelineSpec dataclass

Versioned scientific choices; open event metadata stays outside the schema.

PopulationContrastResult dataclass

A paired or independent contrast over population-unit estimates.

to_json()

Serialize the estimand, unit ledger, and uncertainty choices.

PopulationContrastSpec dataclass

Versioned choices for a two-level population contrast.

PopulationCurveSession dataclass

One session-level curve with an explicit axis and pointwise support.

PopulationGroupAssignment dataclass

One independent population unit's explicitly declared group.

PopulationInfluence dataclass

Change in the population estimate after omitting one unit.

PopulationInteractionResult dataclass

A group contrast over complete within-unit condition contrasts.

to_json()

Serialize cells, unit contrasts, exclusions, and population evidence.

PopulationInteractionSpec dataclass

Versioned group-by-condition difference-in-differences estimand.

PopulationUnitEstimate dataclass

One condition estimate for one independent population unit.

source_units and observation_count retain how the estimate was formed; a zero observation count is valid for an exposure-supported count outcome. support records the number of finite source-unit estimates at each point, while optional observation_support retains pointwise lower-level counts. Scalar outcomes use one-element tuples, so the same contract can serve curves, spectra, transient summaries, and other derived outcomes.

PoseTrajectory dataclass

One tracked 2D or 3D keypoint from an external pose tool.

speed(*, minimum_confidence, coordinate_scale=1.0, output_unit=None, name=None)

Calculate pairwise speed while retaining confidence-derived missingness.

PredictorFamilyContribution dataclass

One full-versus-reduced predictive comparison with safeguards.

PredictorFamilyContributionResult dataclass

Complete leave-family-out ledger without causal attribution.

PredictorFamilyContributionSpec dataclass

Full model and prespecified leave-family-out comparisons.

PredictorFamilyDeltaInterval dataclass

Non-simultaneous paired-group sensitivity interval.

PredictorFamilyDropSpec dataclass

One explicitly declared family and its literal reduced model.

PredictorFamilyGroupDelta dataclass

Paired out-of-fold score difference for one independent group.

Preprocessing dataclass

A named preprocessing recipe with an explicit output variable and units.

reference(*, method='irls') classmethod

Fit an explicitly supplied reference channel.

signal_only(*, method, normalization='divide', rolling_window_s=60.0, resample_rate_hz=None, resample_max_gap_factor=None) classmethod

Apply a declared signal-only baseline without claiming artefact removal.

PreprocessingOutcomeSpec dataclass

Coupled preprocessing and event-summary output for one workflow family.

PreprocessingSpec dataclass

Legacy schema-v1 reference-correction specification.

ProgressKernelBasisResult dataclass

Basis weights and functions used to reconstruct normalized progress.

ProgressKernelInterval dataclass

Pointwise and optional simultaneous uncertainty over progress.

ProgressKernelResult dataclass

Estimated response trajectory over normalized interval progress.

ProgressKernelSpec dataclass

One normalized-progress trajectory for a named interval family.

ProjectEvidenceBundle dataclass

Normalized records recovered from a project directory or one NWB file.

ProminenceTransientDetectorSpec dataclass

Height-plus-prominence detection on a gap-local z-scored stream.

PublicationAttestation dataclass

Canonical claim binding one project manifest to a signer identity.

PublicationVerification dataclass

Successful verification of a detached publication attestation.

PulseRecoveryDiagnostic dataclass

Observed signal and optional negative-control behavior around one pulse.

PyPhotometryChannel dataclass

Explicit analog-input mapping for one anatomical signal channel.

PyPhotometryDigitalEvents dataclass

Expose rising edges on one pyPhotometry digital input as events.

PyPhotometrySchema dataclass

Scientific mapping kept separate from the binary acquisition header.

QualityGateSpec dataclass

QC warning codes that block inference without deleting observations.

QuantifiedTransient dataclass

Kinetics on the quantification scale, linked to detector evidence.

RaisedCosineBasisSpec dataclass

A lower-dimensional linear raised-cosine basis over the lag window.

RecordingInput dataclass

One recording plus event identifiers and arbitrary per-event metadata.

ReferenceDFFOperation dataclass

Robust or OLS reference correction in an ordered operation sequence.

ResampleOperation dataclass

Prospective linear regularization with an explicit gap policy.

ResidualizationEvidence dataclass

Complete evidence for optional paired-signal residualization.

ResidualizationSpec dataclass

Declare within-run regression of shared event or behavior covariates.

ResolveIntervalOverlaps dataclass

Reject overlaps or retain higher-priority interval portions explicitly.

RunExclusion dataclass

An uninterrupted run excluded before analysis.

RunResidualization dataclass

One run's shared-covariate regression evidence.

SampledImpulseResponseModel dataclass

Causal sampled response density for empirical or external model families.

ScalarMixedModelResult dataclass

to_html()

Render a compact standalone sensitivity report.

SensorChannelAssignment dataclass

Attach session identity and optional reference pairing to a sensor channel.

SensorKinetics dataclass

Context-specific kinetic evidence retained for interpretation constraints.

SensorProfile dataclass

Versioned, user-extensible optical and interpretation contract for a sensor.

SensorRegistry dataclass

Immutable collection of versioned profiles without a closed sensor enum.

resolve(profile_id, profile_version=None)

Resolve one profile, refusing an ambiguous version.

to_json()

Serialize registry content without requiring package-owned profiles.

with_profile(profile)

Return a new registry containing one additional profile.

SensorValidityAssessment dataclass

Versioned sensor profile, metrics, issues, and interpretation boundary.

require_ready(*, allow_warnings=True)

Refuse failed evidence and optionally warning-bearing evidence.

to_json()

Serialize profile, diagnostics, and explicit interpretation limits.

SensorValidityIssue dataclass

One actionable metadata or observed-signal validity concern.

SensorValiditySpec dataclass

Operational thresholds for metadata, channel, and reference review.

SessionComparabilityGroup dataclass

Computed across-session diagnostics for one subject and logical series.

SessionComparabilityIssue dataclass

One actionable reason a longitudinal series warns or fails.

SessionComparabilityRecord dataclass

Declared identity and outcome-blind QC summaries for one session series.

SessionComparabilityReport dataclass

Fingerprintable preflight evidence for an Unspool handoff.

session_keys property

Return subject/session pairs covered by the preflight.

require_ready(*, allow_warnings=True)

Refuse failed reports and optionally warning-bearing reports.

to_json()

Serialize complete comparability evidence deterministically.

SessionComparabilitySpec dataclass

Prospective operational thresholds for a longitudinal preflight.

SignalPairMetadata dataclass

Identity and alignment provenance for one ordered signal pair.

SpatialAnimalEstimate dataclass

One mouse-condition value after equal-session aggregation.

SpatialAnimalInferenceResult dataclass

Mouse-level contrast, interval, randomization test, and full ledger.

SpatialAnimalInferenceSpec dataclass

Declare a session-to-mouse contrast for one network estimand.

SpatialArrayMetadata dataclass

Mouse, session, clock, processing, and coordinate identity for one array.

coordinate_space property

Return the validated shared coordinate space.

coordinate_unit property

Return the validated shared coordinate unit.

SpatialCoordinate dataclass

Optional physical or atlas coordinate for one optical site.

SpatialDistanceBin dataclass

One named half-open physical-distance interval.

contains(distance)

Return membership under the half-open [minimum, maximum) policy.

SpatialDistanceSummary dataclass

Association summary for one declared physical-distance bin.

SpatialNetworkEdge dataclass

One retained within-session edge and its physical/evidence denominator.

SpatialNetworkEdgeExclusion dataclass

One candidate edge excluded before spatial summarization.

SpatialNetworkResult dataclass

One session network, distance summaries, null, and complete edge ledger.

to_json()

Serialize geometry, edges, summaries, null evidence, and provenance.

SpatialNetworkSpec dataclass

Declare pairwise, distance, aggregation, and spatial-null choices.

SpatialNodePermutationResult dataclass

Within-session node-label null for distance-edge association.

SpatialNodePermutationSpec dataclass

Node-label randomization for distance-edge structure within a session.

SpatialSessionEstimate dataclass

One session scalar after dependent edges have been summarized.

SpatialSessionExclusion dataclass

One requested session that could not provide the declared estimand.

SpatialStudySession dataclass

Attach an experimental condition to one session network.

SpectralAnalysisSpec dataclass

Explicit window, overlap, detrending, and continuity choices.

SpectrogramResult dataclass

A PSD spectrogram containing only complete within-run windows.

to_json()

Serialize the time-frequency matrix and window-level evidence.

SplitIntervals dataclass

Split intervals at declared timestamps and/or a maximum segment duration.

StateAutocorrelation dataclass

One state label and its gap-aware autocorrelation result.

StateBandPowerEstimate dataclass

One animal-state estimate after equal-session aggregation.

StateBandPowerInferenceResult dataclass

Paired state contrast with animal-level bootstrap and sign flips.

StateBandPowerInferenceSpec dataclass

Declare a paired animal-level contrast between two supplied states.

StateBandPowerPopulationMaterialization dataclass

Animal-state band-power cells ready for common population inference.

contrast(spec)

Apply the common population contrast to animal-state band power.

interaction(assignments, spec)

Compare within-animal state contrasts across disjoint groups.

to_json()

Serialize state-band cells and their source-session support.

StateCoherencePhase dataclass

One supplied state and its cross-spectral result.

StateConditionedAutocorrelationResult dataclass

Autocorrelation results grouped by user-supplied state.

StateConditionedCoherenceResult dataclass

Cross-spectral results separated by user-supplied state epochs.

to_json()

Serialize state-conditioned cross-spectral evidence.

StateConditionedPSDResult dataclass

PSD results grouped by user-supplied state without inferred labels.

to_json()

Serialize state spectra and their source evidence.

StateConditionedSpectrogramResult dataclass

Spectrogram results grouped by user-supplied state.

StateEpoch dataclass

One user-supplied, half-open state interval in signal-clock seconds.

StatePSD dataclass

One state label and its gap-aware Welch result.

StatePSDSession dataclass

Attach subject and session identity to state-conditioned spectra.

StateSpectrogram dataclass

One state label and its complete-window spectrogram.

StimulationPulse dataclass

One declared stimulation interval in the photometry signal clock.

StudyDesign dataclass

Versioned declaration of units and factors, separate from observations.

TDTBlockSchema dataclass

Versioned scientific mapping for a TDT block.

TDTEpocEvents dataclass

Map one TDT epoc store to the categorical analysis factor.

TDTEpocValue dataclass

Assign scientific meaning to one numeric TDT epoc code.

TDTProjectConfig dataclass

Complete project contract for explicitly mapped TDT blocks.

TDTStreamChannel dataclass

Map TDT stream stores and one-indexed SDK channels to one location.

TabularChannel dataclass

Explicit mapping from source columns to one anatomical signal channel.

TabularEventColumn dataclass

Map and type one event metadata column.

TabularEventSchema dataclass

Versioned mapping for an event table associated with one recording.

TabularInputInspection dataclass

Preflight diagnostics spanning the acquisition and event clocks.

TabularInspection dataclass

Machine-readable metadata and acquisition diagnostics for one source file.

TabularProjectConfig dataclass

Complete, fingerprinted input and analysis contract for the CLI.

build_analysis(sessions)

Build an analysis carrying the full project-file fingerprint.

from_toml(path) classmethod

Load a project file and resolve data paths relative to that file.

load()

Load every source and retain its preflight diagnostics.

normalized_json()

Describe resolved project choices without serializing private paths.

TabularRecordingSchema dataclass

Versioned mapping for one wide recording table.

TransientAnimalEstimate dataclass

One animal-condition estimate after session/event aggregation.

TransientAnimalInferenceResult dataclass

Contrast, interval, randomization evidence, and complete animal ledger.

TransientAnimalInferenceSpec dataclass

Declare an animal-level contrast for event rate or kinetics.

TransientCandidate dataclass

One accepted location with detector-scale evidence only.

TransientCandidateExclusion dataclass

A local maximum rejected during candidate detection.

TransientCandidateResult dataclass

Candidate locations and detector-scale evidence, before quantification.

TransientChannelSummary dataclass

Session-level summary that uses acquired, finite duration as denominator.

TransientDetectionResult dataclass

Accepted events, rejected candidates, summaries, and long-window bins.

TransientDetectionSpec dataclass

Declare one reproducible spontaneous-transient detection universe.

TransientEvent dataclass

Measurements for one accepted candidate, relative to its local baseline.

TransientExclusion dataclass

A local maximum that was considered but not accepted.

TransientPopulationMaterialization dataclass

Transient animal-condition cells ready for common population inference.

contrast(spec)

Apply the common population contrast to materialized animal cells.

interaction(assignments, spec)

Compare within-animal transient contrasts across disjoint groups.

to_json()

Serialize domain denominators and common population cells.

TransientQuantificationExclusion dataclass

A detected candidate that cannot be quantified as requested.

TransientQuantificationResult dataclass

Quantified candidates, explicit failures, summaries, and time bins.

TransientQuantificationSpec dataclass

Measurements applied to candidates on an explicitly chosen variable.

TransientQuantificationSummary dataclass

Exposure-adjusted descriptive summary for one session and channel.

TransientStudySession dataclass

Attach experimental identity to one quantified session.

TransientThresholdCalibrationSpec dataclass

How candidate-scale scores are converted into frozen thresholds.

TransientWaveform dataclass

One non-resampled, gap-bounded cutout with explicit QC evidence.

TransientWaveformIssue dataclass

One actionable concern attached to a retained candidate waveform.

TransientWaveformResult dataclass

All candidate cutouts, QC outcomes, and a stable evidence fingerprint.

for_candidate(candidate_id)

Resolve exactly one retained candidate cutout.

to_json()

Serialize cutout values, QC evidence, and identity.

to_xarray()

Return padded values and native relative times without interpolation.

TransientWaveformSpec dataclass

Prospective cutout window and observable waveform-QC thresholds.

Unit dataclass

An identified sampling unit, optionally nested within another unit.

UnmixedOpticalComponentSeries dataclass

One extracted source series with identity and provenance attached.

UnspoolStudyExport dataclass

Validated trial columns ready for unspool.Study.from_columns.

to_study()

Construct an Unspool Study when the separate package is installed.

WavelengthRange dataclass

Inclusive wavelength range in nanometres.

contains(wavelength_nm)

Return whether a wavelength lies inside the inclusive range.

WelchPSDResult dataclass

Welch PSD averaged across within-run windows only.

to_json()

Serialize the spectrum, declared choices, and continuity evidence.

ZenodoDraftReceipt dataclass

Non-secret receipt for a validated, unpublished Zenodo draft.

add_poses_to_nwb(trajectories, nwbfile, *, metadata=None, reference_frame=None, devices=(), source_video=None, labeled_video=None)

Write compatible trajectories to a behavior processing module.

align_events(recording, event_times, *, window, rate, variable='dff', event_ids=None, max_gap_s=None)

Interpolate a signal onto a common peri-event time axis.

Events outside the recorded interval are retained with NaNs. No averaging is performed, preserving the event/session/animal hierarchy for later inference.

annotations_from_boris(columns, *, subject, session, behavior_column, type_column, start_column, stop_column, clock_id='video', source_version=None, source_artifact=None)

Convert an aggregated BORIS export after explicit column selection.

annotations_from_boris_aggregated_file(path, *, subject, session, source_subject=None, source_observation=None, clock_id='video', source_version=None)

Read a BORIS aggregated-event CSV or TSV without collapsing event type.

BORIS aggregated exports already contain one row per complete POINT or STATE event. Selection of an observation and focal subject is explicit whenever a file contains more than one of either.

annotations_from_boris_tabular_file(path, *, subject, session, source_subject=None, clock_id='video', source_version=None)

Read BORIS tabular CSV, pairing START/STOP state-event rows.

annotations_from_moseq(syllable, *, subject, session, fps, labels=None, clock_id='video', source_version=None, source_artifact=None)

Run-length encode a Keypoint-MoSeq syllable sequence as bouts.

annotations_from_moseq_results_h5(path, *, recording, subject, session, fps, labels=None, clock_id='video', source_version=None)

Read a recording's syllable sequence from Keypoint-MoSeq results HDF5.

apply_interval_policy(annotations, policy, *, context_sources=None)

Apply ordered interval rules without changing point events or clock identity.

artifact_schema(artifact_type)

Load a packaged normative JSON Schema by artifact type.

assess_crosstalk(time, first, second, pair, spec=None, *, valid_first=None, valid_second=None, shared_control=None, control_name=None)

Combine optical metadata and signal diagnostics without claiming causality.

assess_event_confounds(recording, event_times, *, baseline=(-0.5, 0.0), response=(0.0, 0.5), maximum_lag_s=1.0)

Flag event-correlated reference responses and signal/reference lag.

These diagnostics require user-supplied event times and therefore complement, rather than replace, recording-level QC. Warnings are advisory; no events or samples are excluded.

assess_event_coverage(records)

Summarize candidate-to-gated-to-complete coverage without outcomes.

assess_kinetic_identifiability(time, model, spec, *, valid=None)

Assess sampling, duration, calibration, and regularized transfer pre-outcome.

assess_metadata_completeness(project, loaded)

Assess readiness without inventing scientific or administrative metadata.

assess_multiverse_compatibility(spec, inputs)

Preflight every universe without fitting or summarizing fluorescence values.

assess_optical_mixing_design(design, spec=None)

Assess identifiability without accessing recorded signal outcomes.

assess_optogenetic_artifacts(time, signal_values, pulses, spec=None, *, valid=None, negative_control=None, negative_control_name=None)

Measure pulse artifacts, recovery, saturation, and negative-control behavior.

assess_pipeline_compatibility(spec, inputs)

Check shapes, clocks, masks, and declared operations without using values.

assess_predictor_family_contributions(multiverse, spec)

Compare a full model with declared literal drop-family alternatives.

Positive deltas mean that the full model predicted held-out observations better than the reduced model. They are predictive sensitivity summaries, not causal effects, unique variance partitions, or evidence that a predictor is necessary.

assess_recording(recording)

Calculate transparent QC metrics without changing or rejecting samples.

assess_sensor_validity(time, signal_values, assignment, profile, spec=None, *, reference_values=None, signal_valid=None, reference_valid=None, event_times=None)

Assess declared sensor/reference semantics and observable validity evidence.

assess_session_comparability(records, spec=None)

Assess longitudinal comparability without inspecting neural outcomes.

assess_signal_recording(recording)

Calculate diagnostics that do not require a reference channel.

autocorrelation(time, values, spec=None, *, valid=None)

Estimate autocorrelation without constructing pairs across invalid runs.

baseline_dff(recording, *, method='double_exponential', variable='signal', min_tau_s=5.0, asls_smoothness=100000000.0, asls_asymmetry=0.01, max_iterations=20, normalization='divide', asls_reference_rate_hz=20.0, rolling_window_s=60.0, rolling_gap_factor=1.5)

Estimate a signal-only baseline and divide or subtract with provenance.

double_exponential fits a non-negative offset plus two non-negative exponential decays using robust nonlinear least squares. asls estimates a smooth lower envelope with asymmetric least squares. rolling_mean reproduces a centred, full-window sample-count rolling mean, while splitting timestamp gaps. Neither method can identify motion or event-locked artefact from a single fluorescence channel. Division creates dff; subtraction creates baseline_subtracted in acquired units.

build_optogenetic_artifact_mask(time, pulses, spec=None, *, existing_valid=None)

Build a fixed mask from pulse timing without inspecting signal outcomes.

calibrate_optical_mixing(known_component_values, measured_channel_values, components, channels, calibration_id, spec=None, *, valid_components=None, valid_channels=None, design_version='1')

Fit mixing rows only when calibration component values are already known.

calibrate_transient_thresholds(recording, *, variable, detector_spec, source_role, source_id, preprocessing_fingerprint, calibration_spec=None)

Freeze channel-specific detector-score gates from separate source evidence.

coherence_phase(time, first, second, pair, spec=None, *, valid_first=None, valid_second=None)

Estimate coherence and phase without pooling across acquisition gaps.

compare_project_evidence(left, right, *, absolute_tolerance=0.0, relative_tolerance=0.0, max_differences=200)

Compare specifications and outcomes without conflating volatile provenance.

condition_exclusion_warning(conditions, dispositions)

Warn when complete-event fractions differ across conditions.

condition_reconstruction_warning(conditions, reconstructed_fractions)

Warn when mean reconstructed coverage differs across conditions.

create_analysis_plan(table, design, estimand, *, randomized, intent, acknowledged_assumptions=(), seed=None)

Create a non-executable plan until every method assumption is acknowledged.

create_archive_package(bundle, *, metadata, output, overwrite=False)

Create a deterministic ZIP after validating evidence and deposit metadata.

create_zenodo_draft(archive, *, token_env=None, production=False)

Create, populate, and validate a Zenodo draft without publishing it.

curve_session_from_autocorrelation(result, *, subject, session, level)

Adapt one gap-aware autocorrelation curve and its pairs per lag.

curve_session_from_coherence(result, level)

Adapt magnitude-squared coherence while retaining window support.

curve_session_from_lagged(result, level)

Adapt one complete lag-association curve for a declared condition.

curve_session_from_psd(result, *, subject, session, level)

Adapt one gap-aware PSD to the common session-curve boundary.

curve_sessions_from_state_autocorrelation(result, *, subject, session)

Expand every externally supplied state into an autocorrelation curve.

curve_sessions_from_state_coherence(result)

Expand state-conditioned coherence using the pair's stored identities.

curve_sessions_from_state_psd(session)

Expand every externally supplied state into a PSD session curve.

cut_transient_waveforms(recording, candidates, *, variable, spec=None)

Retain native candidate cutouts without crossing gaps or interpolating.

deconvolve_sensor_response(time, observed_output, model, spec, *, valid=None)

Estimate conditional latent input after prospective identifiability gates.

detect_acquisition_format(path)

Conservatively detect native formats without guessing channel identity.

detect_transient_candidates(recording, *, variable, spec, frozen_thresholds=None)

Detect candidate locations without assigning quantification-scale kinetics.

detect_transients(recording, *, variable='dff', spec=None)

Detect spontaneous transients without bridging missing acquisition.

This experimental method intentionally exposes choices that differ across the literature. MAD thresholds are robust-sigma estimates (1.4826 * MAD). Shape measurements and AUC use half-height crossings relative to the local pre-peak baseline. Long-window bins are descriptive summaries, not a claim that their variation is a biological "tonic" component.

estimate_spatial_network(time, values, metadata, spec=None, *, valid=None, covariates=None, covariate_names=None)

Estimate every declared site pair without treating edges as replicates.

exact_sign_flip_test(table, design, estimand, *, exchangeability_unit)

Enumerate the exact paired sign-flip null distribution (at most 20 units).

execute_analysis_plan(plan, table, design)

Execute only acknowledged, currently supported scalar plans.

export_project_multiverse_nwb(project, loaded, result, groups, output_directory)

Archive one reference signal and the complete multiverse evidence ledger.

export_project_nwb(project, loaded, result, output_directory, *, mixed_model_json=None)

Write one validated NWB file per session and return resolved paths.

extract_unmixed_component(result, component_id)

Extract one source without discarding identity or mixing provenance.

fit_clock_synchronization(matches, spec)

Fit and validate target_time = intercept + scale * source_time.

fit_event_kernel_model(sessions, spec)

Fit an FIR Gaussian ridge model using group-held-out alpha selection.

Event kernels are constructed independently inside each session, so an event can never contribute predictors to a neighboring recording. Cross-validation holds out complete animals or sessions and applies continuous-covariate scaling learned from the training fold only.

fit_scalar_mixed_model(table, design, estimand, spec=None)

Fit a two-level fixed contrast with declared nested random intercepts.

hierarchical_bootstrap(table, design, estimand, plan, *, interval_method, draws=2000, seed=0)

Bootstrap a two-level contrast through a declared nested unit path.

infer_association_animals(sessions, spec)

Infer a condition contrast after aggregating sessions within animals.

infer_multiscale_animals(sessions, spec)

Contrast conditions without treating windows or sessions as animals.

infer_peri_event_contrast(values, relative_time, *, animals, sessions, conditions, numerator, denominator, design='paired', confidence=0.95, draws=2000, seed=0)

Infer a curve after equal-session aggregation within each animal.

values is event by relative-time. Events are never treated as independent inferential units. Paired designs contrast levels within animals; independent designs compare two disjoint groups of animal estimates.

infer_peri_event_interaction(values, relative_time, *, animals, sessions, groups, conditions, spec)

Infer a group contrast over within-animal peri-event condition contrasts.

infer_population_contrast(estimates, spec)

Contrast already-materialized unit estimates without pseudo-replication.

infer_population_interaction(estimates, assignments, spec)

Infer a group-by-condition interaction at the population-unit boundary.

infer_spatial_network_animals(sessions, spec)

Contrast network summaries after edges→sessions→mice aggregation.

infer_state_band_power(sessions, spec)

Contrast band power without treating sessions or windows as animals.

infer_transient_animals(sessions, spec)

Infer a condition contrast without treating transient events as replicates.

inspect_doric(path)

List one-dimensional numeric datasets without guessing channel identity.

inspect_loaded_tabular_input(item)

Inspect an already loaded canonical input without rereading source files.

inspect_ndx_pose_nwb(path)

Inventory all ndx-pose containers without loading full coordinate arrays.

inspect_neurophotometrics(path)

Inventory export columns and flag unsupported simultaneous-LED rows.

inspect_pyphotometry(path)

Inventory analog and digital inputs without assigning biological roles.

inspect_tabular_input(recording_path, recording_schema, event_path, event_schema, *, subject, session)

Inspect recording integrity and clock coverage before analysis.

inspect_tabular_recording(path, schema, *, subject, session)

Load and summarize a source before selecting an analysis workflow.

kinetic_kernel(model, sample_interval_s)

Materialize one causal model on a declared regular sampling interval.

lagged_association(time, first, second, pair, spec=None, *, valid_first=None, valid_second=None, covariates=None, covariate_names=None)

Estimate lagged association without crossing gaps or state boundaries.

Optional covariates are regressed from both signals separately within each continuity run. Event designs and behavior traces therefore use one explicit boundary without being interpreted as causal adjustment.

load_archive_metadata(path)

Strictly load and validate repository-neutral archive metadata.

load_doric_input(path, schema, *, subject, session)

Load explicitly mapped Doric series through the canonical recording boundary.

load_neurophotometrics_input(path, schema, *, subject, session)

Load alternating excitation rows and interpolate reference onto signal time.

load_project_config(path)

Dispatch a project file while retaining tabular v0.1 compatibility.

load_pyphotometry_input(path, schema, *, subject, session)

Load raw pyPhotometry signals and digital rising edges without filtering.

load_tabular_events(path, schema)

Load event times, identifiers, and explicitly typed metadata columns.

load_tabular_input(recording_path, recording_schema, event_path, event_schema, *, subject, session)

Load one complete pipeline input without conflating samples and events.

load_tabular_recording(path, schema, *, subject, session)

Load a wide CSV/TSV recording through explicit scientific mappings.

load_tdt_input(block_path, schema, *, subject, session, reader=None)

Read one TDT block into the canonical recording and event boundary.

lowpass_filter(recording, *, cutoff_hz, order=4, variables=('signal', 'reference'))

Zero-phase low-pass finite runs and retain every pre-filter variable.

make_recording(*, time, signal, reference=None, channel_names=None, subject, session, attrs=None)

Create a validated recording without modifying the supplied arrays.

Signals are stored as (time, channel) even for a single channel. This prevents downstream functions from treating regions or fluorophores as interchangeable observations.

materialize_association_population(sessions, *, metric, pair_id, levels, session_aggregation='mean')

Average session association summaries within animal-condition cells.

materialize_curve_population(sessions, *, levels, session_aggregation='mean')

Aggregate identical-axis session curves within animal and level.

Axis interpolation is never implicit. Sessions with different grids must be harmonized prospectively and re-adapted before entering this boundary.

materialize_encoding_multiverse(spec)

Assign stable identifiers before any response values are fitted.

materialize_multiverse(spec)

Expand and validate every choice combination without executing data analysis.

materialize_state_band_power_population(sessions, *, states, frequency_band_hz)

Integrate session spectra, then average sessions within animal-state cells.

materialize_transient_population(sessions, *, metric, channel, levels, session_aggregation='median')

Pool transient evidence into one scalar per animal and condition.

Rates pool event counts over analyzed exposure. Kinetic metrics first summarize each session and then aggregate sessions equally within an animal-condition.

permutation_test(table, design, estimand, plan, *, permutations=2000, seed=0)

Test a contrast with explicit sign-flip or blocked-label exchangeability.

pose_from_deeplabcut(frame, *, subject, session, keypoint, time_s=None, fps=None, scorer=None, individual=None, coordinate_unit='px', clock_id='video', source_version=None, source_artifact=None)

Read one keypoint from a DeepLabCut MultiIndex-like result table.

pose_from_deeplabcut_file(path, *, subject, session, keypoint, time_s=None, fps=None, scorer=None, individual=None, csv_header_rows=3, coordinate_unit='px', clock_id='video', source_version=None)

Read one keypoint from a DeepLabCut prediction HDF5 or CSV file.

pose_from_sleap(tracks, *, subject, session, node_names, node, dims, time_s=None, fps=None, track=0, point_scores=None, score_dims=None, coordinate_unit='px', clock_id='video', source_version=None, source_artifact=None)

Read one node from a SLEAP Analysis HDF5-shaped array.

pose_from_sleap_analysis_h5(path, *, subject, session, node, time_s=None, fps=None, track=0, dims=None, score_dims=None, coordinate_unit='px', clock_id='video', source_version=None)

Read one node from a SLEAP Analysis HDF5 file.

poses_from_ndx_pose(pose_estimation, *, subject, session, clock_id, processing_module_name='behavior', processing_module_description='Behavioral pose estimation', source_artifact=None, source_sha256=None)

Copy one in-memory PoseEstimation into typed physical trajectories.

poses_from_ndx_pose_nwb(path, *, subject, session, clock_id, processing_module_name=None, pose_estimation_name=None)

Read one explicitly selected PoseEstimation from an NWB file.

predict_sensor_response(time, latent_input, model, spec=None, *, valid=None)

Apply a causal sensor model separately inside every valid continuity run.

prepare_unspool_study(table, *, subject, session, trial, session_order, comparability=None, require_comparability=False, allow_comparability_warnings=True)

Map explicit photometry columns onto Unspool's longitudinal contract.

Chronology is never inferred from row order or identifiers. All source columns are retained, while the four required Unspool columns are added under canonical names. FiberPhotometry owns the neural values; Unspool owns downstream behavioral clocks, models, and forward-session validation.

quantify_transient_candidates(recording, candidates, *, variable, spec=None, waveforms=None)

Measure candidates on a possibly different, non-normalized signal stream.

read_project_evidence(path)

Read and normalize one manifest directory or standalone NWB evidence file.

recommend_inference(table, design, estimand, *, randomized)

Recommend supported scalar methods without inferring randomization.

reference_dff(recording, *, method='irls', max_iterations=50, tolerance=1e-08)

Fit the reference to each signal channel and calculate dF/F.

irls uses Huber iteratively reweighted least squares; ols is provided as an explicit comparator. Non-finite samples are excluded channel-wise. The fitted baseline is intercept + slope * reference and the corrected trace is (signal - fitted) / fitted.

This operation does not assert that a reference channel is biologically inert. Users must inspect diagnostics and controls for that assumption.

resample_recording(recording, *, rate_hz, max_gap_s=None, max_gap_factor=None)

Linearly resample time-channel variables while retaining source arrays.

Interpolation never crosses a source interval larger than max_gap_s. The original arrays remain available on the separate source_time axis.

run_encoding_multiverse(sessions, spec)

Fit every model, retain failures, and compare only common evidence.

run_multiverse(spec, inputs)

Execute all valid universes and retain every outcome class.

run_pipeline(spec, inputs)

Run a declared scalar workflow while retaining all intermediate products.

session_estimate_from_coherence(result, condition, frequency_band_hz)

Extract mean band coherence while retaining its window denominator.

session_estimate_from_lagged(result, condition, *, lag_s=0.0)

Extract a declared physical lag and its actual pair-count denominator.

sign_publication_manifest(bundle, *, key, signer_identity, overwrite=False)

Sign a verified complete directory manifest using an OpenSSH identity.

spectrogram(time, values, spec=None, *, valid=None, value_unit='a.u.')

Compute only complete time-frequency windows contained within valid runs.

state_conditioned_autocorrelation(time, values, epochs, spec=None, *, valid=None)

Compute autocorrelation separately within each supplied state label.

state_conditioned_coherence(time, first, second, pair, epochs, spec=None, *, valid_first=None, valid_second=None)

Estimate cross-spectra within, but never across, supplied state epochs.

state_conditioned_psd(time, values, epochs, spec=None, *, valid=None, value_unit='a.u.')

Compute a separate PSD for each supplied state label.

state_conditioned_spectrogram(time, values, epochs, spec=None, *, valid=None, value_unit='a.u.')

Compute complete-window spectrograms separately within supplied states.

summarize_coherence_band(result, frequency_band_hz)

Integrate a declared band without treating frequency bins as replicates.

summarize_event_windows(recording, event_times, *, baseline, response, variable='signal')

Summarize actual acquired samples without interpolating or averaging events.

Window starts are inclusive and stops exclusive. Events remain a dimension, so downstream inference retains the session and animal hierarchy.

summarize_multiscale(time, values, spec, *, valid=None, epochs=None, value_unit='a.u.')

Summarize explicit physical-time scales without bridging gaps or epochs.

summarize_multiverse_groups(result, groups)

Validate a complete partition and calculate only unit-local magnitudes.

unit_t_interval(table, design, estimand, *, mode, confidence=0.95)

Compute a Welch or paired t interval on declared aggregation-unit means.

unmix_optical_signals(time, values, design, spec=None, *, valid=None)

Apply a declared mixing matrix without estimating it from the outcomes.

validate_acquisition_input(value)

Validate guarantees every native reader must satisfy.

validate_design(table, design)

Compare a declaration with observed relationships and assignment levels.

validate_recording(recording)

Validate the minimum invariants required by processing functions.

verify_archive_package(path)

Verify safe paths, checksums, sizes, metadata, and evidence in an archive.

verify_publication_manifest(bundle, *, allowed_signers)

Verify signer authorization, signature bytes, and exact manifest binding.

welch_power_sensitivity(*, animals_per_condition, effect_range, animal_sd_range, alpha=0.05)

Bound Gaussian Welch power over user-supplied effect and SD ranges.

welch_psd(time, values, spec=None, *, valid=None, value_unit='a.u.')

Estimate a Welch PSD while treating each valid acquisition run separately.