MESSY-synth 0.0.1__py3-none-any.whl

MESSY_synth/__init__.py

@@ -0,0 +1,58 @@
+"""Generate structurally-faithful synthetic raw data from any MEDS-Extract v0.7 MESSY config.
+
+A MESSY config is a complete, config-only ETL: it says where the raw data comes from, and how to
+turn each raw table into MEDS events, using the `dftly <https://github.com/mmcdermott/dftly>`_
+expression DSL. What it never says is what the raw tables *look like* — those are supposed to
+already exist, behind a credentialed download.
+
+MESSY_synth runs that reasoning backwards. It reads the config's expressions, deduces what the
+source files must have contained, and writes a directory of synthetic files matching that shape:
+right filenames, right columns, right dtypes, right string formats, right keys. The ETL then runs
+over them end to end, with no access to the real dataset.
+
+Every generated value is deliberately, visibly fake. The point is to reproduce a dataset's
+*structure* so an ETL can be demonstrated and regression-tested — never to imitate its content.
+
+Typical use::
+
+    from MESSY_synth import synthesize
+
+    result = synthesize("path/to/messy.yaml", "raw_synthetic/")
+    print(result.events)   # per-event row counts from the dry run
+"""
+
+from .constraints import ColumnConstraint, ConstraintSet, ValueKind
+from .generate import GeneratedDataset, GenerationOptions, generate
+from .inference import infer_constraints
+from .plan import ColumnPlan, DatasetPlan, TablePlan, ValuePool, build_plan
+from .smoke import SmokeResult, check_output, run_etl, smoke_test
+from .synth import SynthesisResult, synthesize
+from .validate import Finding, check_plan, dry_run, recommended_n_subjects
+from .writer import FORMATS, write_dataset
+
+__all__ = [
+    "FORMATS",
+    "ColumnConstraint",
+    "ColumnPlan",
+    "ConstraintSet",
+    "DatasetPlan",
+    "Finding",
+    "GeneratedDataset",
+    "GenerationOptions",
+    "SmokeResult",
+    "SynthesisResult",
+    "TablePlan",
+    "ValueKind",
+    "ValuePool",
+    "build_plan",
+    "check_output",
+    "check_plan",
+    "dry_run",
+    "generate",
+    "infer_constraints",
+    "recommended_n_subjects",
+    "run_etl",
+    "smoke_test",
+    "synthesize",
+    "write_dataset",
+]

MESSY_synth/__main__.py

@@ -0,0 +1,204 @@
+"""Command-line interface: ``MESSY-synth <spec> -o <dir>``.
+
+The CLI is a thin wrapper over :func:`MESSY_synth.synth.synthesize`, with one addition worth
+knowing about: it exits non-zero when validation finds an error. That makes it usable directly as a
+CI smoke test for an ETL config — regenerate, and fail the build if any event stopped producing
+rows.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+
+from .synth import synthesize
+from .writer import FORMATS
+
+logger = logging.getLogger(__name__)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the argument parser.
+
+    Returns:
+        The configured parser.
+
+    Examples:
+        >>> parser = build_parser()
+        >>> args = parser.parse_args(["messy.yaml", "-o", "out"])
+        >>> args.spec, args.output_dir, args.format, args.seed
+        ('messy.yaml', 'out', 'auto', 0)
+
+        Numeric range overrides are parsed into a mapping:
+
+        >>> parser.parse_args(["m.yaml", "-o", "o", "-R", "anchor_year=1950:2000"]).numeric_range
+        [('anchor_year', (1950.0, 2000.0))]
+    """
+    parser = argparse.ArgumentParser(
+        prog="MESSY-synth",
+        description=(
+            "Generate synthetic raw source data matching the structure a MEDS-Extract v0.7 "
+            "MESSY config expects. All generated values are fake; only the shape is real."
+        ),
+    )
+    parser.add_argument(
+        "spec",
+        help="Registered pipeline name, pkg:// reference, or path to a MESSY yaml file.",
+    )
+    parser.add_argument("-o", "--output-dir", required=True, help="Directory to write source files into.")
+    parser.add_argument(
+        "-n",
+        "--n-subjects",
+        type=int,
+        default=None,
+        help="Subject-universe size. Defaults to the smallest count that safely fills every split.",
+    )
+    parser.add_argument(
+        "-r", "--rows-per-subject", type=int, default=4, help="Rows per subject in timed event tables."
+    )
+    parser.add_argument("-v", "--vocab-size", type=int, default=8, help="Values per categorical vocabulary.")
+    parser.add_argument("-s", "--seed", type=int, default=0, help="Master seed; output is deterministic.")
+    parser.add_argument(
+        "--null-fraction",
+        type=float,
+        default=0.05,
+        help="Fraction of nullable values emitted as nulls, to exercise null-handling paths.",
+    )
+    parser.add_argument(
+        "-f", "--format", choices=FORMATS, default="auto", help="Output format for the source files."
+    )
+    parser.add_argument(
+        "-R",
+        "--numeric-range",
+        action="append",
+        type=_parse_range,
+        default=[],
+        metavar="COL=LO:HI",
+        help="Override the numeric range for a column, e.g. anchor_year=1950:2000. Repeatable.",
+    )
+    parser.add_argument("--explain", action="store_true", help="Print the inferred schema per column.")
+    parser.add_argument("--no-validate", action="store_true", help="Skip static checks and the dry run.")
+    parser.add_argument("-q", "--quiet", action="store_true", help="Only print errors.")
+    return parser
+
+
+def _parse_range(text: str) -> tuple[str, tuple[float, float]]:
+    """Parse a ``COL=LO:HI`` numeric-range override.
+
+    Args:
+        text: The raw argument text.
+
+    Returns:
+        The column name and its bounds.
+
+    Raises:
+        argparse.ArgumentTypeError: If the text is malformed.
+
+    Examples:
+        >>> _parse_range("anchor_year=1950:2000")
+        ('anchor_year', (1950.0, 2000.0))
+        >>> _parse_range("bogus")
+        Traceback (most recent call last):
+            ...
+        argparse.ArgumentTypeError: Expected COL=LO:HI, got 'bogus'
+    """
+    column, _, bounds = text.partition("=")
+    lo, _, hi = bounds.partition(":")
+    if not column or not lo or not hi:
+        raise argparse.ArgumentTypeError(f"Expected COL=LO:HI, got {text!r}")
+    try:
+        return column, (float(lo), float(hi))
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(f"Expected numeric bounds in {text!r}: {e}") from e
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the CLI.
+
+    Args:
+        argv: Argument list; defaults to ``sys.argv[1:]``.
+
+    Returns:
+        0 on success, 1 if validation found an error.
+    """
+    args = build_parser().parse_args(argv)
+    logging.basicConfig(
+        level=logging.ERROR if args.quiet else logging.INFO,
+        format="%(message)s",
+    )
+
+    try:
+        result = synthesize(
+            args.spec,
+            args.output_dir,
+            n_subjects=args.n_subjects,
+            rows_per_subject=args.rows_per_subject,
+            vocab_size=args.vocab_size,
+            seed=args.seed,
+            null_fraction=args.null_fraction,
+            fmt=args.format,
+            numeric_ranges=dict(args.numeric_range),
+            validate=not args.no_validate,
+        )
+    except Exception as e:
+        # A config MEDS-Extract itself rejects is the answer, not a crash — reporting it as one
+        # failing line is what makes this usable as a CI gate.
+        print(f"ERROR    config: {type(e).__name__}: {e}", file=sys.stderr)
+        return 1
+
+    if not args.quiet:
+        print(f"\nWrote {len(result.files)} file(s) to {result.output_dir} as {result.fmt}:")
+        print(result.dataset.summary())
+        if args.explain:
+            print("\nInferred source schema:")
+            print(explain(result))
+        if result.events is not None:
+            print("\nPer-event dry run:")
+            print(result.events)
+
+    for finding in result.findings:
+        print(finding, file=sys.stderr)
+
+    if not result.ok:
+        print(
+            "\nValidation failed. The generated data will not produce a complete MEDS dataset.",
+            file=sys.stderr,
+        )
+        return 1
+    return 0
+
+
+def explain(result) -> str:
+    """Render the inferred per-column schema as a readable table.
+
+    Args:
+        result: A :class:`~MESSY_synth.synth.SynthesisResult`.
+
+    Returns:
+        The rendered text.
+    """
+    lines: list[str] = []
+    for table in result.dataset.plan.tables:
+        lines.append(f"\n  {table.prefix}  ({table.n_rows} rows, {table.kind})")
+        for column in table.columns:
+            c = column.constraint
+            extras = []
+            if c.datetime_formats:
+                extras.append("fmt=" + ",".join(c.datetime_formats))
+            if c.effective_temporal_role:
+                extras.append(f"role={c.effective_temporal_role}")
+            if column.pool_id:
+                extras.append("shared-pool" + (" (covering)" if column.covers_pool else ""))
+            if not c.effective_nullable:
+                extras.append("not-null")
+            lines.append(f"      {column.name:<32} {c.kind.name:<13} {' '.join(extras)}")
+            # The notes are the actual derivation — which expression, in which event, imposed each
+            # constraint. Without them "why is this column a string?" has no answer.
+            for note in c.notes:
+                lines.append(f"          <- {note}")
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":  # pragma: no cover - entry point
+    raise SystemExit(main())

MESSY_synth/constraints.py

@@ -0,0 +1,351 @@
+"""The value-kind lattice used to describe what a synthetic source column must contain.
+
+A MESSY config never states the schema of its own inputs. It states *expressions over* those
+inputs, in the `dftly <https://github.com/mmcdermott/dftly>`_ DSL. This module defines the
+vocabulary that :mod:`MESSY_synth.inference` uses to write down what it learns by walking those
+expressions, plus the rules for combining two independent observations about the same column.
+
+The central type is :class:`ColumnConstraint`. It is a *lattice element*: constraints combine with
+:meth:`ColumnConstraint.merge`, which is associative and commutative, so the order in which a
+config's expressions happen to be visited never changes the inferred schema.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from enum import IntEnum
+
+
+class ValueKind(IntEnum):
+    """What a column must hold, ordered by how tightly it pins the on-disk bytes.
+
+    The integer values *are* the merge precedence: when one column is observed twice with two
+    different kinds, the numerically larger kind wins. The ordering runs from "we learned nothing"
+    up to "the exact characters are determined".
+
+    The ordering is deliberate, not incidental:
+
+    - :attr:`DATETIME_STR` outranks everything because a ``strptime`` format determines the literal
+      characters in the file. A column read as ``$x::"%Y-%m-%d"`` *and* interpolated into an
+      f-string is still a ``%Y-%m-%d`` string; the f-string merely stringifies it.
+    - :attr:`DATETIME` and :attr:`DATE` outrank the numeric kinds, since a column used directly
+      where a timestamp is expected must carry a real temporal dtype.
+    - :attr:`NUMERIC` outranks :attr:`CATEGORICAL`: rendering a number into an f-string is fine,
+      but feeding a category name into arithmetic is not.
+    - :attr:`SUBJECT_ID` sits above the plain numeric kinds because MEDS-Extract casts subject ids
+      to ``Int64`` with ``strict=True``; that is a stronger promise than "some number".
+
+    Examples:
+        >>> ValueKind.DATETIME_STR > ValueKind.NUMERIC > ValueKind.CATEGORICAL
+        True
+        >>> max(ValueKind.CATEGORICAL, ValueKind.STRING)
+        <ValueKind.CATEGORICAL: 20>
+    """
+
+    UNKNOWN = 0
+    STRING = 10
+    CATEGORICAL = 20
+    BOOLEAN = 30
+    IDENTIFIER = 40
+    NUMERIC = 50
+    INTEGER = 60
+    SUBJECT_ID = 70
+    DATE = 80
+    DATETIME = 90
+    DATETIME_STR = 100
+
+
+#: Kinds whose synthetic values are drawn from a small, reusable vocabulary rather than sampled
+#: independently per row. Categorical columns are what event ``code`` expressions interpolate, and
+#: what ``_metadata`` dictionaries join against, so their value pool has to be finite and shared.
+VOCABULARY_KINDS = frozenset({ValueKind.CATEGORICAL, ValueKind.IDENTIFIER})
+
+#: Kinds that must be written as a temporal dtype (or a string parsed into one).
+TEMPORAL_KINDS = frozenset({ValueKind.DATE, ValueKind.DATETIME, ValueKind.DATETIME_STR})
+
+#: Kinds that must be written as a number.
+NUMERIC_KINDS = frozenset({ValueKind.NUMERIC, ValueKind.INTEGER, ValueKind.SUBJECT_ID})
+
+
+@dataclass(frozen=True)
+class ColumnConstraint:
+    """Everything inference has learned about one source column.
+
+    Attributes:
+        kind: The strongest :class:`ValueKind` observed for this column.
+        datetime_formats: ``strptime`` format strings this column is parsed with, in first-seen
+            order. More than one is normal and meaningful: the 0.7 idiom for a column with mixed
+            formats is ``coalesce($x::?"%Y-%m-%d %H:%M:%S", $x::?"%Y-%m-%d")``, and a generator
+            that emits only the first format would leave the second branch of that coalesce
+            untested. Generation distributes rows across every recorded format.
+        required_values: Literal values this column is compared against somewhere in the config
+            (e.g. the ``"9"`` in ``$icd_version == "9"``). Seeding these into the value pool is
+            what makes a config's conditional branches actually branch, instead of every row
+            taking the same path.
+        match_patterns: Regexes the column is *tested* against with ``/re/ in $col``. Generation
+            emits a mix of matching and non-matching values, so both sides of the resulting
+            conditional are exercised.
+        extract_patterns: Regexes the column has a value *pulled out of* with
+            ``extract group N of /re/ from $col``. Unlike a test, a failed extract yields null and
+            usually poisons everything downstream, so every generated value must match these.
+        numeric_range: Inferred bounds for a numeric column, where the surrounding arithmetic
+            implies a magnitude the value kind alone cannot express — the ``$anchor_year -
+            $anchor_age`` idiom, whose difference has to render as a four-digit year.
+        observed_kinds: Every kind ever recorded for this column, not just the winning one. Kept
+            so contradictory usage (a column read both as a formatted string *and* as a native
+            timestamp) can be reported rather than silently resolved.
+        min_chars: Minimum character length, accumulated from substring slices (``$col[0:3]``
+            needs at least 3 characters) and from ``len_chars($col) > n`` comparisons.
+        nullable: Whether the column may contain nulls. Set False for columns whose nullity would
+            break the run outright — subject ids and join keys.
+        plain_time: True when this column supplies the timestamp of an *ordinary* (non-birth,
+            non-death) event. It suppresses :attr:`temporal_role`: a column doing double duty
+            cannot be placed on the timeline as a death date, because a death date is null for
+            every subject who does not die, which would empty the ordinary event too.
+        subject_key: True when this column is the *input* to a ``hash()``/``signed_hash()`` that
+            produces the subject id. Such a column is not itself a subject id — it can be any text
+            — but it stands in one-to-one for a subject, so its pool must be sized by the requested
+            subject count and shared across every table that hashes it.
+        temporal_role: ``"birth"`` or ``"death"`` when this column supplies the timestamp of a
+            ``MEDS_BIRTH`` / ``MEDS_DEATH`` event. MEDS treats those two as the bounds of a
+            subject's timeline, and many downstream tools assume birth precedes every other event,
+            so generation places them deliberately rather than sampling them like any other date.
+        strict_parse: True when at least one ``strptime`` over this column is strict (``::
+            rather than ``::?``). A strict parse drops nothing silently; an unparsable value is a
+            hard error, so strictly-parsed columns never receive nulls or off-format values.
+        notes: Human-readable provenance, one line per observation. Surfaced by the CLI's
+            ``--explain`` output so a user can see *why* a column was typed the way it was.
+
+    Examples:
+        >>> ColumnConstraint(kind=ValueKind.CATEGORICAL).kind.name
+        'CATEGORICAL'
+
+        Merging keeps the stronger kind and unions the evidence:
+
+        >>> a = ColumnConstraint(kind=ValueKind.CATEGORICAL, required_values=("9",))
+        >>> b = ColumnConstraint(kind=ValueKind.DATETIME_STR, datetime_formats=("%Y-%m-%d",))
+        >>> merged = a.merge(b)
+        >>> merged.kind.name, merged.datetime_formats, merged.required_values
+        ('DATETIME_STR', ('%Y-%m-%d',), ('9',))
+
+        Merging is commutative, so visit order cannot change the result:
+
+        >>> a.merge(b) == b.merge(a)
+        True
+
+        Nullability is conjunctive — one usage that forbids nulls forbids them everywhere:
+
+        >>> ColumnConstraint(nullable=True).merge(ColumnConstraint(nullable=False)).nullable
+        False
+
+        A temporal role survives being merged with a role-less observation of the same column:
+
+        >>> ColumnConstraint().merge(ColumnConstraint(temporal_role="birth")).temporal_role
+        'birth'
+
+        Merging remembers every kind it saw, not only the winner, so contradictory usage stays
+        visible:
+
+        >>> a = ColumnConstraint(kind=ValueKind.DATETIME)
+        >>> b = ColumnConstraint(kind=ValueKind.DATETIME_STR)
+        >>> sorted(k.name for k in a.merge(b).observed_kinds)
+        ['DATETIME', 'DATETIME_STR']
+    """
+
+    kind: ValueKind = ValueKind.UNKNOWN
+    datetime_formats: tuple[str, ...] = ()
+    required_values: tuple[str, ...] = ()
+    match_patterns: tuple[str, ...] = ()
+    extract_patterns: tuple[str, ...] = ()
+    numeric_range: tuple[float, float] | None = None
+    observed_kinds: frozenset[ValueKind] = frozenset()
+    min_chars: int = 0
+    nullable: bool = True
+    strict_parse: bool = False
+    plain_time: bool = False
+    subject_key: bool = False
+    temporal_role: str | None = None
+    notes: tuple[str, ...] = ()
+
+    def merge(self, other: ColumnConstraint) -> ColumnConstraint:
+        """Combine two independent observations of the same column.
+
+        Args:
+            other: The constraint to fold in.
+
+        Returns:
+            A new constraint holding the stronger kind and the union of all evidence.
+
+        Examples:
+            >>> x = ColumnConstraint(kind=ValueKind.NUMERIC, min_chars=2)
+            >>> y = ColumnConstraint(kind=ValueKind.STRING, min_chars=5, strict_parse=True)
+            >>> z = x.merge(y)
+            >>> z.kind.name, z.min_chars, z.strict_parse
+            ('NUMERIC', 5, True)
+
+            Duplicate evidence is de-duplicated while preserving first-seen order:
+
+            >>> p = ColumnConstraint(datetime_formats=("%Y", "%Y-%m"))
+            >>> q = ColumnConstraint(datetime_formats=("%Y-%m", "%Y-%m-%d"))
+            >>> p.merge(q).datetime_formats
+            ('%Y', '%Y-%m', '%Y-%m-%d')
+        """
+        return ColumnConstraint(
+            kind=max(self.kind, other.kind),
+            datetime_formats=_ordered_union(self.datetime_formats, other.datetime_formats),
+            required_values=_ordered_union(self.required_values, other.required_values),
+            match_patterns=_ordered_union(self.match_patterns, other.match_patterns),
+            extract_patterns=_ordered_union(self.extract_patterns, other.extract_patterns),
+            numeric_range=self.numeric_range or other.numeric_range,
+            observed_kinds=(self.observed_kinds | other.observed_kinds | {self.kind, other.kind})
+            - {ValueKind.UNKNOWN},
+            min_chars=max(self.min_chars, other.min_chars),
+            nullable=self.nullable and other.nullable,
+            strict_parse=self.strict_parse or other.strict_parse,
+            plain_time=self.plain_time or other.plain_time,
+            subject_key=self.subject_key or other.subject_key,
+            temporal_role=self.temporal_role or other.temporal_role,
+            notes=_ordered_union(self.notes, other.notes),
+        )
+
+    @property
+    def effective_temporal_role(self) -> str | None:
+        """The birth/death role to actually generate by, or None.
+
+        A role is dropped when the same column also supplies an ordinary event's timestamp. HiRID
+        does exactly this: ``date_of_death: '$datetime if $_died'`` bottoms out in the same
+        ``datetime`` column that its main observation table reads. Honouring the role there would
+        fill that column from each subject's death date — null for everyone who survives — and
+        silently delete most of the largest table in the dataset.
+
+        Returns:
+            ``"birth"``, ``"death"``, or None.
+
+        Examples:
+            >>> ColumnConstraint(temporal_role="death").effective_temporal_role
+            'death'
+            >>> ColumnConstraint(temporal_role="death", plain_time=True).effective_temporal_role is None
+            True
+        """
+        return None if self.plain_time else self.temporal_role
+
+    @property
+    def effective_nullable(self) -> bool:
+        """Whether generation may emit nulls for this column.
+
+        A death timestamp is nullable whatever the parse strictness says: most subjects do not die
+        inside the record, and polars' ``strptime`` passes nulls straight through rather than
+        failing on them. Treating a strict parse as forbidding nulls would force every synthetic
+        subject to have a death date.
+
+        Returns:
+            True if nulls are permitted.
+
+        Examples:
+            >>> ColumnConstraint(nullable=False).effective_nullable
+            False
+            >>> ColumnConstraint(nullable=False, temporal_role="death").effective_nullable
+            True
+
+            Unless the role was suppressed because the column also times an ordinary event:
+
+            >>> ColumnConstraint(nullable=False, temporal_role="death", plain_time=True).effective_nullable
+            False
+        """
+        return self.nullable or self.effective_temporal_role == "death"
+
+    def with_note(self, note: str) -> ColumnConstraint:
+        """Return a copy carrying one more provenance line.
+
+        Args:
+            note: The line to append.
+
+        Returns:
+            The updated constraint.
+
+        Examples:
+            >>> ColumnConstraint().with_note("used as time").notes
+            ('used as time',)
+        """
+        return replace(self, notes=_ordered_union(self.notes, (note,)))
+
+
+def _ordered_union(*groups: tuple[str, ...]) -> tuple[str, ...]:
+    """Concatenate tuples, dropping duplicates and preserving first-seen order.
+
+    ``dict.fromkeys`` is the idiomatic order-preserving de-duplication in Python 3.7+.
+
+    Args:
+        *groups: The tuples to combine.
+
+    Returns:
+        The de-duplicated concatenation.
+
+    Examples:
+        >>> _ordered_union(("a", "b"), ("b", "c"), ())
+        ('a', 'b', 'c')
+        >>> _ordered_union()
+        ()
+    """
+    return tuple(dict.fromkeys(item for group in groups for item in group))
+
+
+@dataclass
+class ConstraintSet:
+    """A mutable accumulator mapping ``(table_prefix, column)`` to its merged constraint.
+
+    Inference walks every expression in a MESSY config and calls :meth:`observe` each time it
+    reaches a column reference. Because :meth:`ColumnConstraint.merge` is commutative, the walk may
+    visit expressions in any order.
+
+    Examples:
+        >>> cs = ConstraintSet()
+        >>> cs.observe("labs", "value", ColumnConstraint(kind=ValueKind.NUMERIC))
+        >>> cs.observe("labs", "value", ColumnConstraint(kind=ValueKind.CATEGORICAL))
+        >>> cs.get("labs", "value").kind.name
+        'NUMERIC'
+
+        Unobserved columns come back as the bottom element rather than raising:
+
+        >>> cs.get("labs", "never_seen").kind.name
+        'UNKNOWN'
+        >>> sorted(cs.columns_for("labs"))
+        ['value']
+    """
+
+    constraints: dict[tuple[str, str], ColumnConstraint] = field(default_factory=dict)
+
+    def observe(self, prefix: str, column: str, constraint: ColumnConstraint) -> None:
+        """Record one observation about ``prefix``/``column``.
+
+        Args:
+            prefix: The source-table prefix the column belongs to.
+            column: The column name.
+            constraint: What was learned.
+        """
+        key = (prefix, column)
+        existing = self.constraints.get(key)
+        self.constraints[key] = constraint if existing is None else existing.merge(constraint)
+
+    def get(self, prefix: str, column: str) -> ColumnConstraint:
+        """Look up the merged constraint for a column.
+
+        Args:
+            prefix: The source-table prefix.
+            column: The column name.
+
+        Returns:
+            The merged constraint, or an empty one if the column was never observed.
+        """
+        return self.constraints.get((prefix, column), ColumnConstraint())
+
+    def columns_for(self, prefix: str) -> set[str]:
+        """Return every column observed for one table prefix.
+
+        Args:
+            prefix: The source-table prefix.
+
+        Returns:
+            The set of observed column names.
+        """
+        return {col for (p, col) in self.constraints if p == prefix}