crca 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

crca_core/models/__init__.py

@@ -0,0 +1,67 @@
+"""Pydantic models and schema contracts for CRCA core."""
+
+from crca_core.models.provenance import ProvenanceManifest
+from crca_core.models.refusal import RefusalChecklistItem, RefusalReasonCode, RefusalResult
+from crca_core.models.result import (
+    AnyResult,
+    BaseResult,
+    CounterfactualResult,
+    DiscoveryHypothesisResult,
+    EstimateResult,
+    IdentificationResult,
+    InterventionDesignResult,
+    ValidationIssue,
+    ValidationReport,
+)
+from crca_core.models.spec import (
+    AssumptionItem,
+    AssumptionSpec,
+    CausalGraphSpec,
+    DataColumnSpec,
+    DataSpec,
+    DraftSpec,
+    EdgeSpec,
+    EntityIndexSpec,
+    LockedSpec,
+    NoiseSpec,
+    NodeSpec,
+    RoleSpec,
+    SCMSpec,
+    SpecStatus,
+    StructuralEquationSpec,
+    TimeIndexSpec,
+)
+from crca_core.models.validation import validate_spec
+
+__all__ = [
+    "ProvenanceManifest",
+    "RefusalChecklistItem",
+    "RefusalReasonCode",
+    "RefusalResult",
+    "AnyResult",
+    "BaseResult",
+    "CounterfactualResult",
+    "DiscoveryHypothesisResult",
+    "EstimateResult",
+    "IdentificationResult",
+    "InterventionDesignResult",
+    "ValidationIssue",
+    "ValidationReport",
+    "AssumptionItem",
+    "AssumptionSpec",
+    "CausalGraphSpec",
+    "DataColumnSpec",
+    "DataSpec",
+    "DraftSpec",
+    "EdgeSpec",
+    "EntityIndexSpec",
+    "LockedSpec",
+    "NoiseSpec",
+    "NodeSpec",
+    "RoleSpec",
+    "SCMSpec",
+    "SpecStatus",
+    "StructuralEquationSpec",
+    "TimeIndexSpec",
+    "validate_spec",
+]

crca_core/models/provenance.py

@@ -0,0 +1,56 @@
+"""Provenance manifest for reproducible causal R&D runs.
+
+The manifest must not contain raw data; only hashes and schema summaries.
+"""
+
+from __future__ import annotations
+
+import platform
+import sys
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class ProvenanceManifest(BaseModel):
+    """Required provenance for every `crca_core` result."""
+
+    run_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    timestamp_utc: str = Field(default_factory=utc_now_iso)
+    spec_hash: str
+    data_hash: Optional[str] = None
+
+    library_versions: Dict[str, str] = Field(default_factory=dict)
+    random_seeds: Dict[str, Any] = Field(default_factory=dict)
+    algorithm_config: Dict[str, Any] = Field(default_factory=dict)
+    hardware_notes: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def minimal(
+        cls,
+        *,
+        spec_hash: str,
+        data_hash: Optional[str] = None,
+        random_seeds: Optional[Dict[str, Any]] = None,
+        algorithm_config: Optional[Dict[str, Any]] = None,
+    ) -> "ProvenanceManifest":
+        """Create a minimal manifest with environment versions populated."""
+
+        versions = {
+            "python": sys.version.split()[0],
+            "platform": platform.platform(),
+        }
+        return cls(
+            spec_hash=spec_hash,
+            data_hash=data_hash,
+            library_versions=versions,
+            random_seeds=random_seeds or {},
+            algorithm_config=algorithm_config or {},
+        )
+

crca_core/models/refusal.py

@@ -0,0 +1,39 @@
+"""Hard-refusal types for H1 enforcement."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class RefusalReasonCode(str, Enum):
+    """Stable reason codes for refusal-first behavior."""
+
+    SPEC_NOT_LOCKED = "SPEC_NOT_LOCKED"
+    NO_SCM_FOR_COUNTERFACTUAL = "NO_SCM_FOR_COUNTERFACTUAL"
+    NOT_IDENTIFIABLE = "NOT_IDENTIFIABLE"
+    TIME_INDEX_INVALID = "TIME_INDEX_INVALID"
+    ASSUMPTIONS_UNDECLARED = "ASSUMPTIONS_UNDECLARED"
+    INPUT_INVALID = "INPUT_INVALID"
+    UNSUPPORTED_OPERATION = "UNSUPPORTED_OPERATION"
+
+
+class RefusalChecklistItem(BaseModel):
+    """A single required input/action needed to proceed."""
+
+    item: str = Field(..., min_length=1)
+    rationale: str = Field(..., min_length=1)
+
+
+class RefusalResult(BaseModel):
+    """Structured refusal (no numeric causal output)."""
+
+    result_type: str = Field(default="Refusal", frozen=True)
+    reason_codes: List[RefusalReasonCode] = Field(default_factory=list)
+    message: str = Field(..., min_length=1)
+    checklist: List[RefusalChecklistItem] = Field(default_factory=list)
+    suggested_next_steps: List[str] = Field(default_factory=list)
+    details: Optional[str] = None
+

crca_core/models/result.py

@@ -0,0 +1,83 @@
+"""Structured result types for crca_core.
+
+All results are structured objects. Human-readable reports must be generated
+by rendering these objects, not by mixing narrative into scientific fields.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+from crca_core.models.provenance import ProvenanceManifest
+from crca_core.models.refusal import RefusalResult
+
+
+class ValidationIssue(BaseModel):
+    code: str = Field(..., min_length=1)
+    message: str = Field(..., min_length=1)
+    path: Optional[str] = None
+
+
+class ValidationReport(BaseModel):
+    """Returned by `validate_spec`."""
+
+    ok: bool
+    errors: List[ValidationIssue] = Field(default_factory=list)
+    warnings: List[ValidationIssue] = Field(default_factory=list)
+
+
+class BaseResult(BaseModel):
+    """Base result type with mandatory provenance."""
+
+    result_type: str
+    provenance: ProvenanceManifest
+    assumptions: List[str] = Field(default_factory=list)
+    limitations: List[str] = Field(default_factory=list)
+    artifacts: Dict[str, Any] = Field(default_factory=dict)
+
+
+class DiscoveryHypothesisResult(BaseResult):
+    result_type: Literal["DiscoveryHypothesis"] = "DiscoveryHypothesis"
+    graph_hypothesis: Dict[str, Any] = Field(default_factory=dict)
+    stability_report: Dict[str, Any] = Field(default_factory=dict)
+
+
+class InterventionDesignResult(BaseResult):
+    result_type: Literal["InterventionDesign"] = "InterventionDesign"
+    designs: List[Dict[str, Any]] = Field(default_factory=list)
+
+
+class CounterfactualResult(BaseResult):
+    result_type: Literal["CounterfactualResult"] = "CounterfactualResult"
+    counterfactual: Dict[str, Any] = Field(default_factory=dict)
+
+
+class IdentificationResult(BaseResult):
+    result_type: Literal["IdentificationResult"] = "IdentificationResult"
+    method: str
+    scope: Literal["conservative", "partial", "complete"] = "conservative"
+    confidence: Literal["low", "medium", "high"] = "low"
+    estimand_expression: str
+    assumptions_used: List[str] = Field(default_factory=list)
+    witnesses: Dict[str, Any] = Field(default_factory=dict)
+    proof: Dict[str, Any] = Field(default_factory=dict)
+
+
+class EstimateResult(BaseResult):
+    result_type: Literal["EstimateResult"] = "EstimateResult"
+    estimate: Dict[str, Any] = Field(default_factory=dict)
+    refutations: Dict[str, Any] = Field(default_factory=dict)
+
+
+AnyResult = (
+    RefusalResult
+    | ValidationReport
+    | DiscoveryHypothesisResult
+    | InterventionDesignResult
+    | CounterfactualResult
+    | IdentificationResult
+    | EstimateResult
+)
+

crca_core/models/spec.py

@@ -0,0 +1,151 @@
+"""Typed causal specification objects (Draft → Locked)."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Dict, List, Literal, Optional, Tuple
+
+from pydantic import BaseModel, Field
+
+
+class SpecStatus(str, Enum):
+    draft = "draft"
+    locked = "locked"
+
+
+class AssumptionStatus(str, Enum):
+    declared = "declared"
+    contested = "contested"
+    violated = "violated"
+    unknown = "unknown"
+
+
+class DataColumnSpec(BaseModel):
+    name: str = Field(..., min_length=1)
+    dtype: str = Field(..., min_length=1)
+    allowed_range: Optional[Tuple[float, float]] = None
+    missingness_expected: Optional[float] = Field(default=None, ge=0.0, le=1.0)
+    unit: Optional[str] = None
+    description: Optional[str] = None
+
+
+class TimeIndexSpec(BaseModel):
+    column: str = Field(..., min_length=1)
+    frequency: Optional[str] = None
+    timezone: Optional[str] = None
+    irregular_sampling_policy: Optional[str] = None
+
+
+class EntityIndexSpec(BaseModel):
+    entity_id_column: str = Field(..., min_length=1)
+    time_column: str = Field(..., min_length=1)
+
+
+class DataSpec(BaseModel):
+    dataset_name: Optional[str] = None
+    dataset_hash: Optional[str] = None
+    columns: List[DataColumnSpec] = Field(default_factory=list)
+    time_index: Optional[TimeIndexSpec] = None
+    entity_index: Optional[EntityIndexSpec] = None
+    measurement_error_notes: Optional[str] = None
+    proxy_variables: Dict[str, str] = Field(default_factory=dict)
+
+
+class NodeSpec(BaseModel):
+    name: str = Field(..., min_length=1)
+    observed: bool = True
+    unit: Optional[str] = None
+    description: Optional[str] = None
+
+
+class EdgeSpec(BaseModel):
+    source: str = Field(..., min_length=1)
+    target: str = Field(..., min_length=1)
+    lag: Optional[int] = None
+    description: Optional[str] = None
+
+
+class CausalGraphSpec(BaseModel):
+    nodes: List[NodeSpec] = Field(default_factory=list)
+    edges: List[EdgeSpec] = Field(default_factory=list)
+    latent_confounders: List[str] = Field(default_factory=list)
+    notes: Optional[str] = None
+
+
+class RoleSpec(BaseModel):
+    treatments: List[str] = Field(default_factory=list)
+    outcomes: List[str] = Field(default_factory=list)
+    mediators: List[str] = Field(default_factory=list)
+    instruments: List[str] = Field(default_factory=list)
+    adjustment_candidates: List[str] = Field(default_factory=list)
+    prohibited_controls: List[str] = Field(default_factory=list)
+
+
+class AssumptionItem(BaseModel):
+    name: str = Field(..., min_length=1)
+    status: AssumptionStatus = AssumptionStatus.unknown
+    description: Optional[str] = None
+    evidence: Optional[str] = None
+
+
+class AssumptionSpec(BaseModel):
+    items: List[AssumptionItem] = Field(default_factory=list)
+    falsification_plan: List[str] = Field(default_factory=list)
+
+
+class NoiseSpec(BaseModel):
+    distribution: Literal["gaussian"] = "gaussian"
+    params: Dict[str, Any] = Field(default_factory=dict)
+
+
+class StructuralEquationSpec(BaseModel):
+    """Represents one structural equation V = f(Pa(V), U_V).
+
+    v0.1: store both a human-readable formula and an executable parameterization
+    for supported SCM families.
+    """
+
+    variable: str = Field(..., min_length=1)
+    parents: List[str] = Field(default_factory=list)
+    form: Literal["linear_gaussian"] = "linear_gaussian"
+    coefficients: Dict[str, float] = Field(default_factory=dict)  # parent -> beta
+    intercept: float = 0.0
+    noise: NoiseSpec = Field(default_factory=NoiseSpec)
+
+
+class SCMSpec(BaseModel):
+    """Explicit SCM required for counterfactuals."""
+
+    scm_type: Literal["linear_gaussian"] = "linear_gaussian"
+    equations: List[StructuralEquationSpec] = Field(default_factory=list)
+    # Optional correlated noise for linear-Gaussian SCMs (advanced; v0.1 may require diagonal)
+    noise_cov: Optional[List[List[float]]] = None
+    intervention_semantics: Dict[str, str] = Field(default_factory=dict)  # var -> set/shift/mechanism-change
+
+
+class DraftSpec(BaseModel):
+    """Draft spec (may be LLM-generated; never authorizes numeric causal outputs)."""
+
+    status: SpecStatus = Field(default=SpecStatus.draft, frozen=True)
+    data: DataSpec = Field(default_factory=DataSpec)
+    graph: CausalGraphSpec = Field(default_factory=CausalGraphSpec)
+    roles: RoleSpec = Field(default_factory=RoleSpec)
+    assumptions: AssumptionSpec = Field(default_factory=AssumptionSpec)
+    scm: Optional[SCMSpec] = None
+    draft_notes: Optional[str] = None
+
+
+class LockedSpec(BaseModel):
+    """Locked spec (authoritative for identification/estimation/simulation semantics)."""
+
+    status: SpecStatus = Field(default=SpecStatus.locked, frozen=True)
+    spec_hash: str
+    approvals: List[str] = Field(default_factory=list)
+    locked_at_utc: str
+
+    data: DataSpec
+    graph: CausalGraphSpec
+    roles: RoleSpec
+    assumptions: AssumptionSpec
+    scm: Optional[SCMSpec] = None
+

crca_core/models/validation.py

@@ -0,0 +1,68 @@
+"""Spec validation (DraftSpec or LockedSpec).
+
+Validation is intentionally conservative: it checks for obvious structural
+issues and missing required fields for different operations.
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+
+from crca_core.models.result import ValidationIssue, ValidationReport
+from crca_core.models.spec import DraftSpec, LockedSpec
+
+
+def _node_names(nodes) -> set[str]:
+    return {n.name for n in nodes}
+
+
+def validate_spec(spec: DraftSpec | LockedSpec) -> ValidationReport:
+    errors: list[ValidationIssue] = []
+    warnings: list[ValidationIssue] = []
+
+    # Basic graph consistency
+    node_names = _node_names(spec.graph.nodes)
+    for e in spec.graph.edges:
+        if e.source not in node_names:
+            errors.append(
+                ValidationIssue(
+                    code="EDGE_SOURCE_UNKNOWN",
+                    message=f"Edge source '{e.source}' not in nodes",
+                    path="graph.edges",
+                )
+            )
+        if e.target not in node_names:
+            errors.append(
+                ValidationIssue(
+                    code="EDGE_TARGET_UNKNOWN",
+                    message=f"Edge target '{e.target}' not in nodes",
+                    path="graph.edges",
+                )
+            )
+
+    # Time-series checks
+    if spec.data.time_index is not None:
+        time_col = spec.data.time_index.column
+        if time_col and time_col not in {c.name for c in spec.data.columns}:
+            errors.append(
+                ValidationIssue(
+                    code="TIME_INDEX_COLUMN_UNKNOWN",
+                    message=f"time_index.column '{time_col}' not in data columns",
+                    path="data.time_index.column",
+                )
+            )
+
+    # Roles consistency
+    for v in spec.roles.treatments + spec.roles.outcomes + spec.roles.mediators + spec.roles.instruments:
+        if v not in node_names:
+            warnings.append(
+                ValidationIssue(
+                    code="ROLE_NODE_UNKNOWN",
+                    message=f"Role variable '{v}' not present in graph nodes",
+                    path="roles",
+                )
+            )
+
+    ok = len(errors) == 0
+    return ValidationReport(ok=ok, errors=errors, warnings=warnings)
+

crca_core/scm/__init__.py

@@ -0,0 +1,9 @@
+"""SCM implementations for `crca_core`.
+
+Counterfactuals require an explicit SCM. v0.1 implements linear-Gaussian SCMs.
+"""
+
+from crca_core.scm.linear_gaussian import LinearGaussianSCM
+
+__all__ = ["LinearGaussianSCM"]
+

crca_core/scm/linear_gaussian.py

@@ -0,0 +1,198 @@
+"""Linear-Gaussian Structural Causal Model (SCM).
+
+Implements counterfactual reasoning via abduction–action–prediction:
+- Abduction: infer exogenous noise U from a factual observation of all endogenous variables.
+- Action: apply do-interventions by replacing structural equations for intervened variables.
+- Prediction: propagate values in topological order using the same inferred noise U.
+
+This implementation is intentionally conservative:
+- v0.1 assumes a fully observed system and (by default) independent noises.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Mapping, Optional, Sequence, Tuple
+
+import numpy as np
+
+try:
+    import networkx as nx  # type: ignore
+except Exception as e:  # pragma: no cover
+    raise ImportError("networkx is required for LinearGaussianSCM") from e
+
+from crca_core.models.spec import SCMSpec, StructuralEquationSpec
+
+
+@dataclass(frozen=True)
+class LinearGaussianSCM:
+    """A linear SCM with additive Gaussian noise for each endogenous variable."""
+
+    variables: Tuple[str, ...]
+    parents: Dict[str, Tuple[str, ...]]
+    coefficients: Dict[Tuple[str, str], float]  # (parent, child) -> beta
+    intercepts: Dict[str, float]
+    # Noise is represented per-variable; v0.1 assumes diagonal covariance by default.
+    noise_cov: Optional[np.ndarray] = None
+
+    @classmethod
+    def from_spec(cls, spec: SCMSpec) -> "LinearGaussianSCM":
+        if spec.scm_type != "linear_gaussian":
+            raise ValueError(f"Unsupported scm_type: {spec.scm_type}")
+
+        variables: List[str] = []
+        parents: Dict[str, Tuple[str, ...]] = {}
+        coefficients: Dict[Tuple[str, str], float] = {}
+        intercepts: Dict[str, float] = {}
+
+        for eq in spec.equations:
+            if eq.form != "linear_gaussian":
+                raise ValueError(f"Unsupported equation form: {eq.form}")
+            v = eq.variable
+            if v in variables:
+                raise ValueError(f"Duplicate equation for variable: {v}")
+            variables.append(v)
+            parents[v] = tuple(eq.parents)
+            intercepts[v] = float(eq.intercept)
+            for p, beta in eq.coefficients.items():
+                coefficients[(p, v)] = float(beta)
+
+        noise_cov = None
+        if spec.noise_cov is not None:
+            noise_cov = np.array(spec.noise_cov, dtype=float)
+            if noise_cov.shape[0] != noise_cov.shape[1]:
+                raise ValueError("noise_cov must be square")
+            if noise_cov.shape[0] != len(variables):
+                raise ValueError("noise_cov dimension must match number of equations/variables")
+
+        model = cls(
+            variables=tuple(variables),
+            parents=parents,
+            coefficients=coefficients,
+            intercepts=intercepts,
+            noise_cov=noise_cov,
+        )
+        # Validate acyclicity/topological order.
+        _ = model.topological_order()
+        return model
+
+    def topological_order(self) -> List[str]:
+        g = nx.DiGraph()
+        for v in self.variables:
+            g.add_node(v)
+        for child, ps in self.parents.items():
+            for p in ps:
+                g.add_edge(p, child)
+        if not nx.is_directed_acyclic_graph(g):
+            raise ValueError("SCM graph must be a DAG")
+        return list(nx.topological_sort(g))
+
+    def _matrix_form(self) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Return (A, b, Sigma_u) for A V = b + U."""
+        n = len(self.variables)
+        index = {v: i for i, v in enumerate(self.variables)}
+        M = np.zeros((n, n), dtype=float)
+        b = np.zeros((n,), dtype=float)
+        for v, intercept in self.intercepts.items():
+            b[index[v]] = float(intercept)
+        for (p, v), beta in self.coefficients.items():
+            i = index[v]
+            j = index[p]
+            M[i, j] = float(beta)
+        A = np.eye(n) - M
+        if self.noise_cov is None:
+            Sigma_u = np.eye(n)
+        else:
+            Sigma_u = self.noise_cov
+        return A, b, Sigma_u
+
+    def abduce_noise_conditional(self, factual: Mapping[str, float]) -> Dict[str, float]:
+        """Conditional Gaussian abduction for partial observations."""
+        A, b, Sigma_u = self._matrix_form()
+        n = len(self.variables)
+        index = {v: i for i, v in enumerate(self.variables)}
+        obs_idx = [index[v] for v in factual.keys() if v in index]
+        miss_idx = [i for i in range(n) if i not in obs_idx]
+        v_o = np.array([float(factual[self.variables[i]]) for i in obs_idx], dtype=float)
+
+        # Compute mean and covariance of V
+        A_inv = np.linalg.inv(A)
+        mu_v = A_inv @ b
+        Sigma_v = A_inv @ Sigma_u @ A_inv.T
+
+        if not miss_idx:
+            v_full = np.zeros(n, dtype=float)
+            for i in range(n):
+                v_full[i] = float(factual[self.variables[i]])
+        else:
+            Sigma_oo = Sigma_v[np.ix_(obs_idx, obs_idx)]
+            Sigma_mo = Sigma_v[np.ix_(miss_idx, obs_idx)]
+            mu_o = mu_v[obs_idx]
+            mu_m = mu_v[miss_idx]
+            # Conditional mean of V_m given V_o
+            v_m = mu_m + Sigma_mo @ np.linalg.inv(Sigma_oo) @ (v_o - mu_o)
+            v_full = np.zeros(n, dtype=float)
+            for i, idx in enumerate(obs_idx):
+                v_full[idx] = v_o[i]
+            for i, idx in enumerate(miss_idx):
+                v_full[idx] = v_m[i]
+
+        u_mean = A @ v_full - b
+        return {self.variables[i]: float(u_mean[i]) for i in range(n)}
+
+    def abduce_noise(self, factual: Mapping[str, float], *, allow_partial: bool = False) -> Dict[str, float]:
+        """Infer per-variable noise U from a factual state.
+
+        If `allow_partial` is False, all endogenous variables must be observed.
+        If True, noise is inferred only for observed variables whose parents are observed.
+        """
+        order = self.topological_order()
+        u: Dict[str, float] = {}
+        x: Dict[str, float] = {k: float(v) for k, v in factual.items()}
+
+        missing = [v for v in order if v not in x]
+        if missing and not allow_partial:
+            raise ValueError(f"Factual observation missing variables: {missing}")
+        if missing and allow_partial and self.noise_cov is not None:
+            return self.abduce_noise_conditional(factual)
+
+        for v in order:
+            if v not in x:
+                continue
+            pred = self.intercepts.get(v, 0.0)
+            for p in self.parents.get(v, ()):
+                if p not in x:
+                    if allow_partial:
+                        pred = None
+                        break
+                    raise ValueError(f"Factual observation missing parent '{p}' for '{v}'")
+                beta = self.coefficients.get((p, v), 0.0)
+                pred += beta * x[p]
+            if pred is None:
+                continue
+            u[v] = float(x[v] - pred)
+        return u
+
+    def predict(self, noise: Mapping[str, float], interventions: Optional[Mapping[str, float]] = None) -> Dict[str, float]:
+        """Forward simulate endogenous variables under interventions using fixed noise."""
+        interventions = interventions or {}
+        order = self.topological_order()
+        x: Dict[str, float] = {}
+
+        for v in order:
+            if v in interventions:
+                x[v] = float(interventions[v])
+                continue
+            pred = self.intercepts.get(v, 0.0)
+            for p in self.parents.get(v, ()):
+                beta = self.coefficients.get((p, v), 0.0)
+                pred += beta * x[p]
+            pred += float(noise.get(v, 0.0))
+            x[v] = float(pred)
+        return x
+
+    def counterfactual(self, factual: Mapping[str, float], interventions: Mapping[str, float]) -> Dict[str, float]:
+        """Compute a counterfactual state via abduction–action–prediction."""
+        u = self.abduce_noise(factual)
+        return self.predict(u, interventions=interventions)
+

crca_core/timeseries/__init__.py

@@ -0,0 +1,6 @@
+"""Time-series causal discovery (hypotheses) and predictive causality helpers."""
+
+from crca_core.timeseries.pcmci import PCMCIConfig, discover_timeseries_pcmci
+
+__all__ = ["PCMCIConfig", "discover_timeseries_pcmci"]
+