orfdata 0.3.0__tar.gz → 0.4.0__tar.gz

{orfdata-0.3.0/orfdata.egg-info → orfdata-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orfdata
-Version: 0.3.0
+Version: 0.4.0
 Summary: Reference open reading frames and experimental translation evidence on annotated transcripts
 Author: OpenVax
 License-Expression: Apache-2.0

{orfdata-0.3.0 → orfdata-0.4.0}/docs/measurements.md

@@ -80,9 +80,9 @@ records technical replicates, runs, fractions, TMT plex/channel/bridge,
 normalization and calibration. A sample's strain/breed belongs in its attributes;
 it need not be the strain used to assemble its reference genome. `TargetMapping`
 retains all candidate assignments or an unmapped reason. A protein-group
-representative does not become a uniquely measured protein. Explicit sample
-pairing and orthology comparisons follow in
-[issue #6](https://github.com/openvax/orfdata/issues/6).
+representative does not become a uniquely measured protein. See
+[pairing and orthology comparisons](pairing.md) for explicit experimental
+relationships and derived RNA/protein ratios.
 
 ## Importing a source
 

orfdata-0.4.0/docs/pairing.md

@@ -0,0 +1,84 @@
+# Comparing RNA, ribosome and protein abundance
+
+Use declared experimental relationships to compare assays. A tissue label alone
+does not make an RNA sample and a protein sample a matched pair.
+
+```python
+for match in dataset.matched_measurements(allowed_bases=["same_material"]):
+    row = match.to_table_row()
+    print(row["rna_abundance"], row["protein_abundance"])
+```
+
+Rows include named RNA, ribosome occupancy, translation-efficiency, protein,
+peptide and spectrum-count columns, each containing original measurement
+records with units, missingness and provenance. Missing columns are empty lists.
+Multiple values remain multiple values; the API does not average them or create
+a Cartesian product of technical replicates. Each row retains its assay pairing
+and target relationship. A three-assay experiment can declare several pairwise
+comparisons; sharing an RNA measurement does not create independent replicates.
+
+Pairing bases are `same_material`, `adjacent_donor_tissue`,
+`biological_replicate`, `independent_cultures`, `tissue_aggregate` and
+`condition_aggregate`. The caller must choose the allowed bases. By default,
+only explicitly concurrent assays are returned; opt into `longitudinal` or
+`unknown` with `allowed_temporal`. Missing mates stay explicit. Technical runs,
+TMT channels and bridges remain in the assays and do not become biological
+sample counts.
+
+The CLI streams the same table rows:
+
+```sh
+orfdata datasets pairs DATASET --version RELEASE --basis same_material
+```
+
+## Which targets are being compared?
+
+`TargetRelation` links exact, reference-scoped targets with mapping evidence
+and cardinality. `same_target` compares one target across assays/samples.
+`canonical_translation` links a gene/transcript to its annotated protein.
+`parent_rna_context` links parent RNA to an ORF but keeps the RNA value attached
+to its original gene/transcript. `shared_group_member` records an ambiguous
+protein-group assignment; the group value stays a group value.
+
+Importers pass `AssayPair` and `TargetRelation` iterators as `pairings=` and
+`relations=` to `QuantitativeDataset.create`. IDs belong to the dataset release
+and reference context. Invalid assay references, contradictory known donor
+identities and conflicting one-to-one assignments fail the import. Original
+storage-version-1 datasets remain readable and have no declared relationships.
+
+## Ratios are derived measurements
+
+```python
+ratio = match.ratio(
+    selected_protein_measurement, selected_rna_measurement,
+    measurement_id="ratio-1", method="native protein/RNA ratio",
+    normalization={"protein": "source bridge normalization", "rna": "source TPM"},
+)
+```
+
+Select actual measurements from opposite sides of the match. Ratios require
+one-to-one target attribution and linear inputs. Parent-RNA/ORF and shared-group
+links cannot produce target-specific ratios. There is no implicit log conversion,
+unit conversion, replicate averaging or uncertainty propagation.
+
+An iBAQ/TPM ratio keeps `(iBAQ)/(TPM)` units. Copies-per-cell values also retain
+their native composite units and the calibration recorded on their source
+assays. Missing, censored or nonpositive denominators produce an unresolved
+`not_measured` result with its reason, never infinity or a measured zero. RPF/RNA
+ratios are source-defined translation-efficiency measures, not measured flux.
+All derived values retain their input IDs, pairing, target attribution and
+normalization assumptions.
+
+## Across species
+
+`compare_orthologs(left_dataset, right_dataset, mappings)` is separate and
+opt-in. Each `OrthologyMapping` pins its source file, release, both reference
+contexts, cardinality, confidence definition and evidence. The default accepts
+one-to-one canonical gene mappings; one-to-many relationships require explicit
+permission through `allowed_cardinalities`.
+
+The result contains each species' original observations. It neither merges
+identities nor transfers abundance or protein-existence evidence. ORF comparisons
+additionally require their own sequence, frame and positional evidence and
+`allow_orfs=True`; a gene ortholog cannot establish an orthologous ncORF.
+Human, mouse, dog, yeast and arbitrary other taxa use this same API.

{orfdata-0.3.0 → orfdata-0.4.0}/orfdata/__init__.py

@@ -17,6 +17,14 @@ from .datasets import DatasetRegistry, build_dataset
 from .initiation_context import KOZAK_PREFERENCES, InitiationContext, annotate_initiation_context
 from .measurements import Assay, DatasetManifest, Measurement, Sample, SourceAsset, TargetMapping
 from .model import ORFModel, ReferenceORF
+from .pairing import (
+    AssayPair,
+    MatchedMeasurements,
+    OrthologyComparison,
+    OrthologyMapping,
+    TargetRelation,
+    compare_orthologs,
+)
 from .reference import ReferenceContext, ScopedTarget
 from .version import __version__
 
@@ -40,6 +48,12 @@ __all__ = [
     "Assay",
     "Measurement",
     "TargetMapping",
+    "AssayPair",
+    "TargetRelation",
+    "MatchedMeasurements",
+    "OrthologyMapping",
+    "OrthologyComparison",
+    "compare_orthologs",
     "load_catalog",
     "UORFCatalog",
     "UORFRecord",

{orfdata-0.3.0 → orfdata-0.4.0}/orfdata/dataset.py

@@ -16,6 +16,14 @@ from .measurements import (
     Sample,
     TargetMapping,
 )
+from .pairing import (
+    PAIRING_BASES,
+    TEMPORAL_RELATIONS,
+    AssayPair,
+    MatchedMeasurements,
+    TargetRelation,
+    _check_one_to_one,
+)
 from .reference import ReferenceContext, ScopedTarget
 
 _SCHEMA = """
@@ -51,6 +59,18 @@ CREATE TABLE input_measurement (
 CREATE INDEX target_lookup ON target(reference_key, namespace, kind, identifier);
 CREATE INDEX observation_lookup ON measurement(reference_key, target_key, sample_id, assay_id);
 CREATE INDEX assay_lookup ON measurement(reference_key, assay_id, quantity, status);
+CREATE TABLE assay_pair (
+    reference_key TEXT NOT NULL REFERENCES reference(key), id TEXT NOT NULL,
+    left_assay_id TEXT, right_assay_id TEXT, record TEXT NOT NULL,
+    PRIMARY KEY(reference_key, id),
+    FOREIGN KEY(reference_key, left_assay_id) REFERENCES assay(reference_key, id),
+    FOREIGN KEY(reference_key, right_assay_id) REFERENCES assay(reference_key, id));
+CREATE TABLE target_relation (
+    reference_key TEXT NOT NULL, id TEXT NOT NULL,
+    left_target_key TEXT NOT NULL, right_target_key TEXT NOT NULL, record TEXT NOT NULL,
+    PRIMARY KEY(reference_key, id),
+    FOREIGN KEY(reference_key, left_target_key) REFERENCES target(reference_key, key),
+    FOREIGN KEY(reference_key, right_target_key) REFERENCES target(reference_key, key));
 """
 
 
@@ -73,7 +93,8 @@ class QuantitativeDataset:
     def __init__(self, path):
         self.path = Path(path).resolve()
         with closing(self._connect()) as connection:
-            if connection.execute("PRAGMA user_version").fetchone()[0] != 1:
+            self._storage_version = connection.execute("PRAGMA user_version").fetchone()[0]
+            if self._storage_version not in (1, 2):
                 raise ValueError("Unsupported quantitative database schema")
             row = connection.execute("SELECT value FROM metadata WHERE name='manifest'").fetchone()
             if row is None:
@@ -88,7 +109,8 @@ class QuantitativeDataset:
         return connection
 
     @classmethod
-    def create(cls, path, manifest, *, samples, assays, measurements, mappings=()):
+    def create(cls, path, manifest, *, samples, assays, measurements, mappings=(),
+               pairings=(), relations=()):
         """Write a new dataset from iterators, validating scope and foreign keys.
 
         Never overwrite an existing file. An interrupted/invalid build removes
@@ -106,7 +128,7 @@ class QuantitativeDataset:
             connection = sqlite3.connect(path)
             connection.execute("PRAGMA foreign_keys=ON")
             connection.executescript(_SCHEMA)
-            connection.execute("PRAGMA user_version=1")
+            connection.execute("PRAGMA user_version=2")
             connection.execute("INSERT INTO metadata VALUES ('manifest', ?)",
                                (_json(manifest.to_dict()),))
             for reference in manifest.references:
@@ -125,6 +147,45 @@ class QuantitativeDataset:
                 connection.execute("INSERT INTO assay VALUES (?, ?, ?, ?)",
                                    (assay.reference.key, assay.assay_id, assay.sample_id,
                                     _json(assay.to_dict())))
+            for pair in pairings:
+                if not isinstance(pair, AssayPair):
+                    raise TypeError("pairings must contain AssayPairs")
+                if (pair.dataset_id, pair.dataset_version) != (manifest.dataset_id, manifest.version):
+                    raise ValueError("Pairing belongs to a different dataset release")
+                if pair.basis in ("same_material", "adjacent_donor_tissue"):
+                    units = []
+                    for identifier in (pair.left_assay_id, pair.right_assay_id):
+                        row = connection.execute(
+                            "SELECT s.record FROM assay a JOIN sample s ON a.reference_key=s.reference_key "
+                            "AND a.sample_id=s.id WHERE a.reference_key=? AND a.id=?",
+                            (pair.reference.key, identifier)).fetchone()
+                        if row:
+                            unit = json.loads(row[0]).get("biological_unit_id")
+                            if unit is not None:
+                                units.append(unit)
+                    if len(set(units)) > 1:
+                        raise ValueError("Declared pairing contradicts biological-unit identities")
+                connection.execute("INSERT INTO assay_pair VALUES (?, ?, ?, ?, ?)",
+                                   (pair.reference.key, pair.pair_id, pair.left_assay_id,
+                                    pair.right_assay_id, _json(pair.to_dict())))
+            relation_links = ({}, {})
+            for relation in relations:
+                if not isinstance(relation, TargetRelation):
+                    raise TypeError("relations must contain TargetRelations")
+                if (relation.dataset_id, relation.dataset_version) != (manifest.dataset_id, manifest.version):
+                    raise ValueError("Target relation belongs to a different dataset release")
+                for target in (relation.left, relation.right):
+                    connection.execute("INSERT OR IGNORE INTO target VALUES (?, ?, ?, ?, ?)",
+                                       (target.reference.key, _target_key(target), target.kind,
+                                        target.namespace, target.identifier))
+                for index, (first, second) in enumerate(((relation.left, relation.right), (relation.right, relation.left))):
+                    _check_one_to_one(relation_links[index],
+                                      (relation.relation, first.key, second.kind, second.namespace), second.key,
+                                      relation.cardinality == "one_to_one")
+                connection.execute("INSERT INTO target_relation VALUES (?, ?, ?, ?, ?)",
+                                   (relation.left.reference.key, relation.relation_id,
+                                    _target_key(relation.left), _target_key(relation.right),
+                                    _json(relation.to_dict())))
             for mapping in mappings:
                 if not isinstance(mapping, TargetMapping):
                     raise TypeError("mappings must contain TargetMappings")
@@ -164,7 +225,8 @@ class QuantitativeDataset:
                                        ((reference_key, observation.measurement_id, identifier)
                                         for identifier in observation.input_measurements))
             counts = {table: connection.execute(f"SELECT count(*) FROM {table}").fetchone()[0]
-                      for table in ("sample", "assay", "mapping", "target", "measurement")}
+                      for table in ("sample", "assay", "mapping", "target", "measurement",
+                                    "assay_pair", "target_relation")}
             connection.execute("INSERT INTO metadata VALUES ('counts', ?)", (_json(counts),))
             connection.commit()
             connection.close()
@@ -205,6 +267,58 @@ class QuantitativeDataset:
     def mappings(self, *, reference=None):
         return self._records("mapping", TargetMapping, reference=reference)
 
+    def pairings(self, *, reference=None):
+        """Iterate source-declared pairings; legacy releases have none."""
+        if self._storage_version == 1:
+            self._scope(reference)
+            return iter(())
+        return self._records("assay_pair", AssayPair, reference=reference)
+
+    def relations(self, *, reference=None):
+        """Iterate source-backed within-reference target relationships."""
+        if self._storage_version == 1:
+            self._scope(reference)
+            return iter(())
+        return self._records("target_relation", TargetRelation, reference=reference)
+
+    def matched_measurements(self, *, allowed_bases, allowed_temporal=("concurrent",),
+                             reference=None, pair_ids=None, relation_ids=None):
+        """Iterate explicit assay/target matches, preserving all values and missing mates.
+
+        Defaults require concurrent assays; opting into longitudinal or unknown
+        timing is explicit. No matching by tissue names or inferred orthology.
+        Each side contains its own original observations, never a Cartesian
+        multiplication or an aggregate over technical replicates/quantities.
+        """
+        bases, temporal = set(allowed_bases), set(allowed_temporal)
+        if isinstance(pair_ids, str) or isinstance(relation_ids, str):
+            raise TypeError("Relationship ID selections must be sequences, not a single string")
+        if not bases or bases - set(PAIRING_BASES):
+            raise ValueError("Specify valid allowed pairing bases explicitly")
+        if not temporal or temporal - set(TEMPORAL_RELATIONS):
+            raise ValueError("Specify valid allowed temporal relationships")
+        if (pair_ids or relation_ids) and reference is None and len(self._references) > 1:
+            raise ValueError("Relationship ID queries across species require a reference")
+        relations = tuple(relation for relation in self.relations(reference=reference)
+                          if relation_ids is None or relation.relation_id in relation_ids)
+        for pair in self.pairings(reference=reference):
+            if pair.basis not in bases or pair.temporal_relation not in temporal:
+                continue
+            if pair_ids is not None and pair.pair_id not in pair_ids:
+                continue
+            by_target = []
+            for assay in (pair.left_assay_id, pair.right_assay_id):
+                values = {}
+                if assay is not None:
+                    for value in self.measurements(reference=pair.reference, assay_id=assay):
+                        values.setdefault(value.target.key, []).append(value)
+                by_target.append(values)
+            for relation in relations:
+                if relation.left.reference.key == pair.reference.key:
+                    yield MatchedMeasurements(pair, relation,
+                                              tuple(by_target[0].get(relation.left.key, ())),
+                                              tuple(by_target[1].get(relation.right.key, ())))
+
     def measurements(self, *, target=None, reference=None, sample_id=None,
                      assay_id=None, quantity=None, status=None):
         """Iterate native observations; a target match is exact, never orthology.

{orfdata-0.3.0 → orfdata-0.4.0}/orfdata/dataset_cli.py

@@ -18,7 +18,7 @@ def run(argv=None, prog=None):
     listing.add_argument("--species")
     listing.add_argument("--taxon-id", type=int)
     listing.add_argument("--assay")
-    for command in ("info", "download", "inspect", "query"):
+    for command in ("info", "download", "inspect", "query", "pairs"):
         subparser = commands.add_parser(command)
         subparser.add_argument("name")
         subparser.add_argument("--version")
@@ -36,6 +36,14 @@ def run(argv=None, prog=None):
             subparser.add_argument("--target")
             subparser.add_argument("--kind")
             subparser.add_argument("--namespace")
+        if command == "pairs":
+            subparser.add_argument("--basis", action="append", required=True,
+                                   help="Allowed pairing basis; repeat for multiple bases")
+            subparser.add_argument("--temporal", action="append",
+                                   help="Allowed temporal relation; default concurrent")
+            subparser.add_argument("--reference")
+            subparser.add_argument("--pair-id", action="append")
+            subparser.add_argument("--relation-id", action="append")
     args = parser.parse_args(argv)
     try:
         definitions = None
@@ -60,6 +68,14 @@ def run(argv=None, prog=None):
             sources = {"dataset.sqlite": args.source_path} if args.source_path else None
             result = registry.download(args.name, args.version, force=args.force,
                                        source_paths=sources, **options)
+        elif args.command == "pairs":
+            dataset = registry.open(args.name, args.version)
+            for match in dataset.matched_measurements(
+                allowed_bases=args.basis, allowed_temporal=args.temporal or ["concurrent"],
+                reference=args.reference, pair_ids=args.pair_id, relation_ids=args.relation_id,
+            ):
+                sys.stdout.write(json.dumps(match.to_table_row()) + "\n")
+            return
         else:
             dataset = registry.open(args.name, args.version)
             target = None

{orfdata-0.3.0 → orfdata-0.4.0}/orfdata/measurements.py

@@ -13,6 +13,7 @@ ASSAY_KINDS = ("rna_seq", "ribo_seq", "digest_ms", "mhc_ms", "targeted_ms")
 QUANTITIES = (
     "rna_abundance", "ribosome_occupancy", "translation_efficiency",
     "protein_abundance", "peptide_abundance", "spectrum_count", "turnover",
+    "protein_rna_ratio", "abundance_ratio",
 )
 MEASUREMENT_STATUSES = ("measured", "below_detection", "not_measured", "not_mapped", "missing")
 MEASUREMENT_ORIGINS = ("observed", "derived", "predicted")

orfdata-0.4.0/orfdata/pairing.py

@@ -0,0 +1,329 @@
+"""Explicit assay relationships and comparisons of original observations."""
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Optional
+
+from .measurements import Measurement, SourceAsset, _identifier, _metadata, _number, _Record
+from .reference import ReferenceContext, ScopedTarget
+
+PAIRING_BASES = (
+    "same_material", "adjacent_donor_tissue", "biological_replicate",
+    "independent_cultures", "tissue_aggregate", "condition_aggregate",
+)
+TEMPORAL_RELATIONS = ("concurrent", "longitudinal", "unknown")
+TARGET_RELATIONS = ("same_target", "canonical_translation", "parent_rna_context", "shared_group_member")
+
+
+def _target(data):
+    values = dict(data)
+    values["reference"] = ReferenceContext(**values["reference"])
+    return ScopedTarget(**values)
+
+
+def _release(record):
+    for name in ("dataset_id", "dataset_version"):
+        _identifier(getattr(record, name), name)
+
+
+def _check_one_to_one(seen, source_key, target_key, one_to_one):
+    """Check a claimed one-to-one edge against every supplied candidate edge."""
+    targets, strict = seen.setdefault(source_key, (set(), False))
+    targets.add(target_key)
+    strict = strict or one_to_one
+    if strict and len(targets) > 1:
+        raise ValueError("Conflicting one-to-one target relationships")
+    seen[source_key] = (targets, strict)
+
+
+@dataclass(frozen=True)
+class AssayPair(_Record):
+    """A source-backed assay pairing, including an explicitly missing mate.
+
+    The pairing basis and temporal relationship are independent. A shared tissue
+    label supplies neither. Replicate/aliquot identity remains in the original
+    samples and assays, rather than being counted from the number of pair rows.
+    """
+
+    pair_id: str
+    reference: ReferenceContext
+    dataset_id: str
+    dataset_version: str
+    left_assay_id: Optional[str]
+    right_assay_id: Optional[str]
+    basis: str
+    evidence: Mapping
+    temporal_relation: str = "unknown"
+    interval: Optional[float] = None
+    interval_unit: Optional[str] = None
+
+    def __post_init__(self):
+        _identifier(self.pair_id, "pair_id")
+        _release(self)
+        if not isinstance(self.reference, ReferenceContext):
+            raise TypeError("Pair requires a ReferenceContext")
+        for identifier in (self.left_assay_id, self.right_assay_id):
+            if identifier is not None:
+                _identifier(identifier, "assay ID")
+        if self.left_assay_id is None and self.right_assay_id is None:
+            raise ValueError("A pairing requires at least one declared assay")
+        if self.left_assay_id == self.right_assay_id:
+            raise ValueError("A pairing requires distinct assays")
+        if self.basis not in PAIRING_BASES:
+            raise ValueError("Unknown assay pairing basis")
+        if self.temporal_relation not in TEMPORAL_RELATIONS:
+            raise ValueError("Unknown temporal relationship")
+        if not self.evidence:
+            raise ValueError("Pairing requires source evidence")
+        if self.interval is not None:
+            _number(self.interval, "interval")
+            _identifier(self.interval_unit, "interval_unit")
+            if self.temporal_relation == "concurrent" and self.interval != 0:
+                raise ValueError("Concurrent assays cannot have a nonzero interval")
+        elif self.interval_unit is not None:
+            raise ValueError("Interval units require a value")
+        _metadata(self, "evidence")
+
+
+@dataclass(frozen=True)
+class TargetRelation(_Record):
+    """Explain why two exact targets can be compared without changing either ID."""
+
+    relation_id: str
+    dataset_id: str
+    dataset_version: str
+    left: ScopedTarget
+    right: ScopedTarget
+    relation: str
+    cardinality: str
+    evidence: Mapping
+
+    def __post_init__(self):
+        _identifier(self.relation_id, "relation_id")
+        _release(self)
+        if not isinstance(self.left, ScopedTarget) or not isinstance(self.right, ScopedTarget):
+            raise TypeError("Target relations require ScopedTargets")
+        if self.left.reference.key != self.right.reference.key:
+            raise ValueError("Within-dataset target relations cannot cross reference contexts")
+        if self.relation not in TARGET_RELATIONS:
+            raise ValueError("Unknown target relationship")
+        if self.cardinality not in ("one_to_one", "one_to_many", "many_to_one", "many_to_many", "unknown"):
+            raise ValueError("Unknown target relationship cardinality")
+        if not self.evidence:
+            raise ValueError("Target relations require mapping evidence")
+        kinds = (self.left.kind, self.right.kind)
+        if self.relation == "same_target" and self.left.key != self.right.key:
+            raise ValueError("same_target requires identical scoped target identities")
+        if self.relation == "same_target" and self.cardinality != "one_to_one":
+            raise ValueError("An identical target has one-to-one cardinality")
+        if self.relation == "canonical_translation" and kinds not in (("gene", "protein"), ("transcript", "protein")):
+            raise ValueError("Canonical translation links a gene/transcript to a protein")
+        if self.relation == "parent_rna_context" and kinds not in (("gene", "orf"), ("transcript", "orf")):
+            raise ValueError("Parent RNA context links a gene/transcript to an ORF")
+        if self.relation == "shared_group_member" and kinds not in (("protein_group", "protein"), ("protein_group", "orf")):
+            raise ValueError("Group membership links a group to one candidate member")
+        _metadata(self, "evidence")
+
+    @classmethod
+    def from_dict(cls, data):
+        values = dict(data)
+        values["left"], values["right"] = _target(values["left"]), _target(values["right"])
+        return cls(**values)
+
+
+@dataclass(frozen=True)
+class MatchedMeasurements(_Record):
+    """One declared relationship with all original values and explicit missingness.
+
+    Tuples avoid multiplying technical/quantity records into pseudo-replicates.
+    For parent_rna_context, left values remain measurements of the parent RNA.
+    They are never measurements of the ORF named on the right.
+    """
+
+    pairing: AssayPair
+    relation: TargetRelation
+    left: tuple
+    right: tuple
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(AssayPair.from_dict(data["pairing"]), TargetRelation.from_dict(data["relation"]),
+                   tuple(Measurement.from_dict(value) for value in data["left"]),
+                   tuple(Measurement.from_dict(value) for value in data["right"]))
+
+    def __post_init__(self):
+        pair, relation = self.pairing, self.relation
+        if not isinstance(pair, AssayPair) or not isinstance(relation, TargetRelation):
+            raise TypeError("A match requires an AssayPair and TargetRelation")
+        if (pair.dataset_id, pair.dataset_version) != (relation.dataset_id, relation.dataset_version):
+            raise ValueError("Pairing and target relation belong to different dataset releases")
+        if pair.reference.key != relation.left.reference.key:
+            raise ValueError("Pairing and target relation have different references")
+        for side in ("left", "right"):
+            values = tuple(getattr(self, side))
+            target = getattr(relation, side)
+            assay_id = getattr(pair, side + "_assay_id")
+            seen = set()
+            for value in values:
+                if not isinstance(value, Measurement):
+                    raise TypeError("Matched values must be Measurements")
+                if (value.dataset_id, value.dataset_version) != (pair.dataset_id, pair.dataset_version):
+                    raise ValueError("Matched measurement belongs to a different dataset release")
+                if value.target.key != target.key or value.assay_id != assay_id:
+                    raise ValueError("Matched observation disagrees with its declared target/assay")
+                if value.measurement_id in seen:
+                    raise ValueError("Duplicate matched measurement")
+                seen.add(value.measurement_id)
+            object.__setattr__(self, side, values)
+
+    def to_table_row(self):
+        """Return named assay-quantity columns with original units and provenance.
+
+        Columns contain lists, preserving multiple measurements without silently
+        averaging them. Empty columns are missing observations, not measured zero.
+        Pairing and target relationships remain present to qualify comparisons.
+        """
+        columns = {name: [] for name in (
+            "rna_abundance", "ribosome_occupancy", "translation_efficiency",
+            "protein_abundance", "peptide_abundance", "spectrum_count", "other")}
+        for value in self.left + self.right:
+            key = value.quantity if value.quantity in columns else "other"
+            columns[key].append(value.to_dict())
+        return dict(dataset_id=self.pairing.dataset_id, dataset_version=self.pairing.dataset_version,
+                    pairing=self.pairing.to_dict(), target_relation=self.relation.to_dict(), **columns)
+
+    def ratio(self, numerator, denominator, *, measurement_id, method, normalization):
+        """Derive a named native-unit ratio from explicitly selected observations.
+
+        No implicit log conversion, replicate aggregation, unit conversion or
+        uncertainty propagation. Undefined ratios are not_measured with a reason.
+        Parent RNA and ambiguous group membership cannot produce ORF ratios.
+        """
+        _identifier(method, "ratio method")
+        if not isinstance(normalization, Mapping) or not normalization:
+            raise ValueError("Ratio normalization and assumptions must be explicit")
+        if self.relation.relation not in ("same_target", "canonical_translation"):
+            raise ValueError("Parent RNA/group membership cannot establish target-specific ratios")
+        if self.relation.cardinality != "one_to_one":
+            raise ValueError("A target-specific ratio requires one-to-one attribution")
+        if not ((numerator in self.left and denominator in self.right)
+                or (numerator in self.right and denominator in self.left)):
+            raise ValueError("Ratio inputs must be original measurements on opposite sides")
+        if numerator.scale != "linear" or denominator.scale != "linear":
+            raise ValueError("Ratio inputs must be linear; any log conversion must be explicit")
+        if (numerator.quantity, denominator.quantity) == ("protein_abundance", "rna_abundance"):
+            quantity = "protein_rna_ratio"
+        elif (numerator.quantity, denominator.quantity) == ("ribosome_occupancy", "rna_abundance"):
+            quantity = "translation_efficiency"
+        elif numerator.quantity == denominator.quantity:
+            quantity = "abundance_ratio"
+        else:
+            raise ValueError("Unsupported ratio quantity relationship")
+        reason = None
+        if numerator.status != "measured" or denominator.status != "measured":
+            reason = "input_not_measured"
+        elif denominator.value <= 0:
+            reason = "nonpositive_denominator"
+        derivation = dict(method=method, normalization=dict(normalization),
+                          pairing=self.pairing.to_dict(), target_relation=self.relation.to_dict(),
+                          uncertainty="not_propagated", unresolved_reason=reason)
+        return Measurement(
+            measurement_id=measurement_id, target=numerator.target,
+            sample_id=numerator.sample_id, assay_id=numerator.assay_id, quantity=quantity,
+            value=None if reason else numerator.value / denominator.value,
+            unit=f"({numerator.unit})/({denominator.unit})",
+            dataset_id=numerator.dataset_id, dataset_version=numerator.dataset_version,
+            status="not_measured" if reason else "measured", origin="derived",
+            input_measurements=(numerator.measurement_id, denominator.measurement_id),
+            derivation=derivation,
+        )
+
+
+@dataclass(frozen=True)
+class OrthologyMapping(_Record):
+    """Pinned cross-species mapping; it never transfers measurements or evidence."""
+
+    mapping_id: str
+    left: ScopedTarget
+    right: ScopedTarget
+    source: SourceAsset
+    source_release: str
+    cardinality: str
+    confidence: Mapping
+    evidence: Mapping
+
+    def __post_init__(self):
+        _identifier(self.mapping_id, "mapping_id")
+        _identifier(self.source_release, "source_release")
+        if not isinstance(self.left, ScopedTarget) or not isinstance(self.right, ScopedTarget):
+            raise TypeError("Orthology requires ScopedTargets")
+        if self.left.reference.taxon_id == self.right.reference.taxon_id:
+            raise ValueError("Orthology comparison requires different species")
+        if not isinstance(self.source, SourceAsset):
+            raise TypeError("Orthology source must have a pinned SourceAsset")
+        if self.cardinality not in ("one_to_one", "one_to_many", "many_to_one", "many_to_many"):
+            raise ValueError("Unknown orthology cardinality")
+        if (self.left.kind, self.right.kind) not in (("gene", "gene"), ("orf", "orf")):
+            raise ValueError("Orthology maps canonical genes or independently supported ORFs")
+        if not self.evidence or not self.confidence:
+            raise ValueError("Orthology evidence and source confidence definition are required")
+        if self.left.kind == "orf" and not all(self.evidence.get(key) for key in
+                                              ("sequence", "frame", "position")):
+            raise ValueError("ORF orthology requires its own sequence, frame and position evidence")
+        _metadata(self, "confidence", "evidence")
+
+    @classmethod
+    def from_dict(cls, data):
+        values = dict(data)
+        values["left"], values["right"] = _target(values["left"]), _target(values["right"])
+        values["source"] = SourceAsset.from_dict(values["source"])
+        return cls(**values)
+
+
+@dataclass(frozen=True)
+class OrthologyComparison(_Record):
+    mapping: OrthologyMapping
+    left: tuple
+    right: tuple
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(OrthologyMapping.from_dict(data["mapping"]),
+                   tuple(Measurement.from_dict(value) for value in data["left"]),
+                   tuple(Measurement.from_dict(value) for value in data["right"]))
+
+    def __post_init__(self):
+        if not isinstance(self.mapping, OrthologyMapping):
+            raise TypeError("Comparison requires an OrthologyMapping")
+        for side in ("left", "right"):
+            values = tuple(getattr(self, side))
+            target = getattr(self.mapping, side)
+            if any(not isinstance(value, Measurement) or value.target.key != target.key for value in values):
+                raise ValueError("Orthology observations must retain their original scoped targets")
+            object.__setattr__(self, side, values)
+
+
+def compare_orthologs(left_dataset, right_dataset, mappings, *,
+                     allowed_cardinalities=("one_to_one",), allow_orfs=False,
+                     left_filters=None, right_filters=None):
+    """Return both species' original observations for explicitly opted-in mappings."""
+    allowed = set(allowed_cardinalities)
+    valid = {"one_to_one", "one_to_many", "many_to_one", "many_to_many"}
+    if not allowed or allowed - valid:
+        raise ValueError("Explicit valid orthology cardinalities are required")
+    mappings = tuple(mappings)
+    seen = ({}, {})
+    for mapping in mappings:
+        if not isinstance(mapping, OrthologyMapping):
+            raise TypeError("Expected OrthologyMapping records")
+        for index, (source, target) in enumerate(((mapping.left, mapping.right), (mapping.right, mapping.left))):
+            _check_one_to_one(seen[index], (source.key, target.reference.key, target.namespace), target.key,
+                              mapping.cardinality == "one_to_one")
+    for mapping in mappings:
+        if mapping.cardinality not in allowed or (mapping.left.kind == "orf" and not allow_orfs):
+            continue
+        yield OrthologyComparison(
+            mapping,
+            tuple(left_dataset.measurements(target=mapping.left, **(left_filters or {}))),
+            tuple(right_dataset.measurements(target=mapping.right, **(right_filters or {}))),
+        )

orfdata-0.4.0/orfdata/version.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

{orfdata-0.3.0 → orfdata-0.4.0/orfdata.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orfdata
-Version: 0.3.0
+Version: 0.4.0
 Summary: Reference open reading frames and experimental translation evidence on annotated transcripts
 Author: OpenVax
 License-Expression: Apache-2.0

{orfdata-0.3.0 → orfdata-0.4.0}/orfdata.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ pyproject.toml
 test.sh
 docs/design.md
 docs/measurements.md
+docs/pairing.md
 docs/reference.md
 docs/species.md
 orfdata/__init__.py
@@ -19,6 +20,7 @@ orfdata/datasets.py
 orfdata/initiation_context.py
 orfdata/measurements.py
 orfdata/model.py
+orfdata/pairing.py
 orfdata/reference.py
 orfdata/sequence.py
 orfdata/version.py
@@ -37,8 +39,10 @@ orfdata/data/uorf-evidence/AUTHOR-LICENSE.txt
 orfdata/data/uorf-evidence/NOTICE.txt
 orfdata/data/uorf-evidence/catalog.json.gz
 orfdata/data/uorf-evidence/manifest.json
+tests/conftest.py
 tests/test_initiation_context.py
 tests/test_measurements.py
+tests/test_pairing.py
 tests/test_reference_context.py
 tests/test_reference_orf.py
 tests/test_uorf_catalog.py

orfdata-0.4.0/tests/conftest.py

@@ -0,0 +1,45 @@
+"""Shared synthetic quantitative fixtures; these are not experimental evidence."""
+
+import hashlib
+
+import pytest
+
+from orfdata import (
+    Assay,
+    DatasetManifest,
+    Measurement,
+    ReferenceContext,
+    Sample,
+    ScopedTarget,
+    SourceAsset,
+)
+
+
+@pytest.fixture
+def experiment(tmp_path):
+    source = tmp_path / "input.tsv"
+    source.write_text("source fixture\n")
+    contexts = tuple(ReferenceContext(taxon, species, assembly, "ensembl", "110")
+                     for taxon, species, assembly in (
+                         (9606, "human", "GRCh38"), (10090, "mouse", "GRCm39"),
+                         (9615, "dog", "ROS_Cfam_1.0"), (4932, "yeast", "R64-1-1")))
+    manifest = DatasetManifest(
+        "fixture", "1", "Synthetic four-species measurement validation", contexts,
+        (SourceAsset("input.tsv", source.as_uri(), hashlib.sha256(source.read_bytes()).hexdigest(),
+                     source.stat().st_size, "Synthetic test data; Apache-2.0", redistributable=True),),
+        ("Synthetic test fixture, not experimental evidence",), ("rna_seq", "digest_ms", "ribo_seq"),
+        dict(searched="Deliberately colliding test identifiers", exclusions="No biological inference"),
+        dict(software="orfdata tests", version="1", parameters={} ),
+    )
+    samples = tuple(Sample("sample", context, biological_unit_id="animal",
+                           attributes={"source_taxon": context.taxon_id}) for context in contexts)
+    assays = tuple(Assay("rna", "sample", "rna_seq", context, technical_replicate="1")
+                   for context in contexts)
+    observations = tuple(Measurement(
+        "value", ScopedTarget(context, "gene", "same_id", "ensembl:110"),
+        "sample", "rna", "rna_abundance", index, "TPM", "fixture", "1",
+        provenance=dict(source_asset="input.tsv", row=index + 1),
+    ) for index, context in enumerate(contexts))
+    return manifest, samples, assays, observations
+
+

{orfdata-0.3.0 → orfdata-0.4.0}/tests/test_measurements.py

@@ -9,15 +9,11 @@ from types import SimpleNamespace
 import pytest
 
 from orfdata import (
-    Assay,
     DatasetManifest,
     DatasetRegistry,
     Measurement,
     QuantitativeDataset,
-    ReferenceContext,
-    Sample,
     ScopedTarget,
-    SourceAsset,
     TargetMapping,
     build_dataset,
 )
@@ -25,34 +21,6 @@ from orfdata.cli import run
 from orfdata.measurements import MEASUREMENT_STATUSES
 
 
-@pytest.fixture
-def experiment(tmp_path):
-    source = tmp_path / "input.tsv"
-    source.write_text("source fixture\n")
-    contexts = tuple(ReferenceContext(taxon, species, assembly, "ensembl", "110")
-                     for taxon, species, assembly in (
-                         (9606, "human", "GRCh38"), (10090, "mouse", "GRCm39"),
-                         (9615, "dog", "ROS_Cfam_1.0"), (4932, "yeast", "R64-1-1")))
-    manifest = DatasetManifest(
-        "fixture", "1", "Synthetic four-species measurement validation", contexts,
-        (SourceAsset("input.tsv", source.as_uri(), hashlib.sha256(source.read_bytes()).hexdigest(),
-                     source.stat().st_size, "Synthetic test data; Apache-2.0", redistributable=True),),
-        ("Synthetic test fixture, not experimental evidence",), ("rna_seq", "digest_ms", "ribo_seq"),
-        dict(searched="Deliberately colliding test identifiers", exclusions="No biological inference"),
-        dict(software="orfdata tests", version="1", parameters={} ),
-    )
-    samples = tuple(Sample("sample", context, biological_unit_id="animal",
-                           attributes={"source_taxon": context.taxon_id}) for context in contexts)
-    assays = tuple(Assay("rna", "sample", "rna_seq", context, technical_replicate="1")
-                   for context in contexts)
-    observations = tuple(Measurement(
-        "value", ScopedTarget(context, "gene", "same_id", "ensembl:110"),
-        "sample", "rna", "rna_abundance", index, "TPM", "fixture", "1",
-        provenance=dict(source_asset="input.tsv", row=index + 1),
-    ) for index, context in enumerate(contexts))
-    return manifest, samples, assays, observations
-
-
 def write_dataset(path, experiment, **kwargs):
     manifest, samples, assays, observations = experiment
     return QuantitativeDataset.create(path, manifest, samples=samples, assays=assays,
@@ -77,7 +45,8 @@ def test_four_species_id_collisions_and_scoped_queries(tmp_path, experiment):
     assert len(observations) == 4
     assert {o.target.reference.taxon_id for o in observations} == {9606, 10090, 9615, 4932}
     assert {o.dataset_id for o in observations} == {"fixture"}
-    assert dataset.counts == dict(sample=4, assay=4, mapping=0, target=4, measurement=4)
+    assert dataset.counts == dict(sample=4, assay=4, mapping=0, target=4, measurement=4,
+                                  assay_pair=0, target_relation=0)
     for expected in experiment[3]:
         assert list(dataset.measurements(target=expected.target)) == [expected]
         assert list(dataset.measurements(reference=expected.target.reference, sample_id="sample")) == [expected]

orfdata-0.4.0/tests/test_pairing.py

@@ -0,0 +1,269 @@
+"""No manufactured sample matches, ORF specificity, replicates or molecule ratios."""
+
+import json
+import sqlite3
+from dataclasses import replace
+
+import pytest
+
+from orfdata import (
+    Assay,
+    AssayPair,
+    DatasetRegistry,
+    MatchedMeasurements,
+    Measurement,
+    OrthologyComparison,
+    OrthologyMapping,
+    QuantitativeDataset,
+    ScopedTarget,
+    TargetRelation,
+    compare_orthologs,
+)
+from orfdata.cli import run
+from orfdata.pairing import PAIRING_BASES
+
+
+@pytest.fixture
+def paired(experiment, tmp_path):
+    manifest, samples, assays, observations = experiment
+    proteins, pairs, relations = [], [], []
+    assays = list(assays)
+    for index, reference in enumerate(manifest.references):
+        target = ScopedTarget(reference, "protein", "same_protein", "source-fasta:1")
+        assays.append(Assay("protein", "sample", "digest_ms", reference, run_id="run-1",
+                            technical_replicate="1", channel="126", plex="plex-1", bridge="131C",
+                            normalization={"method": "source TMT bridge"}))
+        proteins.append(Measurement("protein-value", target, "sample", "protein", "protein_abundance",
+                                    100 + index, "iBAQ", "fixture", "1",
+                                    provenance={"source_asset": "input.tsv", "row": index + 9}))
+        pairs.append(AssayPair("pair", reference, "fixture", "1", "rna", "protein", "same_material",
+                               {"source_asset": "input.tsv", "source_pair_id": index}, "concurrent"))
+        relations.append(TargetRelation("encoding", "fixture", "1", observations[index].target,
+                                         target, "canonical_translation", "one_to_one",
+                                         {"source_asset": "input.tsv", "method": "test fixture"}))
+    values = dict(samples=samples, assays=assays, measurements=(*observations, *proteins),
+                  pairings=pairs, relations=relations)
+    return manifest, values
+
+
+def create(tmp_path, paired, **changes):
+    manifest, values = paired
+    return QuantitativeDataset.create(tmp_path / "paired.sqlite", manifest, **dict(values, **changes))
+
+
+def test_four_species_native_observations_and_tmt_lineage(tmp_path, paired):
+    dataset = create(tmp_path, paired)
+    matches = list(dataset.matched_measurements(allowed_bases=["same_material"]))
+    assert len(matches) == 4
+    for match in matches:
+        assert match.left[0].target.kind == "gene"
+        assert match.right[0].target.kind == "protein"
+        assert match.left[0].target.reference.key == match.right[0].target.reference.key
+        assert len(match.left) == len(match.right) == 1
+        assert match.left[0].unit == "TPM" and match.right[0].unit == "iBAQ"
+        assert AssayPair.from_dict(match.pairing.to_dict()) == match.pairing
+        assert TargetRelation.from_dict(match.relation.to_dict()) == match.relation
+        assert MatchedMeasurements.from_dict(match.to_dict()) == match
+    assay = next(a for a in dataset.assays() if a.kind == "digest_ms")
+    assert (assay.plex, assay.channel, assay.bridge, assay.technical_replicate) == ("plex-1", "126", "131C", "1")
+    with pytest.raises(TypeError):
+        list(dataset.matched_measurements())
+    with pytest.raises(ValueError, match="across species"):
+        list(dataset.matched_measurements(allowed_bases=["same_material"], pair_ids=["pair"]))
+
+
+@pytest.mark.parametrize("basis", PAIRING_BASES)
+def test_pairing_basis_must_be_allowed_explicitly(tmp_path, paired, basis):
+    pair = replace(paired[1]["pairings"][0], basis=basis)
+    dataset = create(tmp_path, paired, pairings=[pair])
+    assert len(list(dataset.matched_measurements(allowed_bases=[basis]))) == 1
+    excluded = "same_material" if basis != "same_material" else "independent_cultures"
+    assert list(dataset.matched_measurements(allowed_bases=[excluded])) == []
+    with pytest.raises(ValueError, match="valid allowed"):
+        list(dataset.matched_measurements(allowed_bases=[]))
+
+
+@pytest.mark.parametrize("temporal", ("unknown", "longitudinal"))
+def test_time_mismatch_requires_opt_in(tmp_path, paired, temporal):
+    pair = replace(paired[1]["pairings"][0], temporal_relation=temporal)
+    dataset = create(tmp_path, paired, pairings=[pair])
+    assert list(dataset.matched_measurements(allowed_bases=["same_material"])) == []
+    assert len(list(dataset.matched_measurements(allowed_bases=["same_material"],
+                                                allowed_temporal=[temporal]))) == 1
+    with pytest.raises(ValueError, match="nonzero interval"):
+        replace(pair, temporal_relation="concurrent", interval=1, interval_unit="day")
+
+
+def test_missing_mates_and_multiple_values_do_not_create_replicates(tmp_path, paired):
+    pair = replace(paired[1]["pairings"][0], right_assay_id=None)
+    original = paired[1]["measurements"][0]
+    extra = replace(original, measurement_id="rna-count", unit="counts", value=99)
+    dataset = create(tmp_path, paired, pairings=[pair], measurements=(*paired[1]["measurements"], extra))
+    match = next(dataset.matched_measurements(allowed_bases=["same_material"]))
+    assert len(match.left) == 2 and match.right == ()
+    assert {v.sample_id for v in match.left} == {"sample"}
+    assert {v.assay_id for v in match.left} == {"rna"}
+
+
+def test_same_tissue_does_not_make_a_pair(tmp_path, paired):
+    samples = tuple(replace(sample, tissue="liver") for sample in paired[1]["samples"])
+    dataset = create(tmp_path, paired, samples=samples, pairings=[])
+    assert list(dataset.matched_measurements(allowed_bases=PAIRING_BASES)) == []
+
+
+def test_pairing_cannot_disagree_with_known_donors_or_release(tmp_path, paired):
+    sample = replace(paired[1]["samples"][0], sample_id="other", biological_unit_id="other-animal")
+    assays = [replace(a, sample_id="other") if a.assay_id == "protein" and a.reference == sample.reference else a
+              for a in paired[1]["assays"]]
+    with pytest.raises(ValueError, match="biological-unit"):
+        create(tmp_path, paired, samples=(*paired[1]["samples"], sample), assays=assays)
+    pair = replace(paired[1]["pairings"][0], dataset_version="different")
+    with pytest.raises(ValueError, match="different dataset release"):
+        create(tmp_path, paired, pairings=[pair])
+    pair = replace(paired[1]["pairings"][0], right_assay_id="missing")
+    with pytest.raises(sqlite3.IntegrityError):
+        create(tmp_path, paired, pairings=[pair])
+
+
+def test_native_ratios_keep_units_inputs_and_undefined_denominators(tmp_path, paired):
+    dataset = create(tmp_path, paired)
+    matches = list(dataset.matched_measurements(allowed_bases=["same_material"]))
+    for match in matches:
+        numerator, denominator = match.right[0], match.left[0]
+        value = match.ratio(numerator, denominator, measurement_id="ratio", method="native_ratio",
+                            normalization={"protein": "source bridge", "rna": "source TPM"})
+        assert value.unit == "(iBAQ)/(TPM)"
+        assert value.quantity == "protein_rna_ratio"
+        assert value.input_measurements == (numerator.measurement_id, denominator.measurement_id)
+        assert value.derivation["uncertainty"] == "not_propagated"
+        if denominator.value == 0:
+            assert value.value is None and value.status == "not_measured"
+            assert value.derivation["unresolved_reason"] == "nonpositive_denominator"
+        else:
+            assert value.value == numerator.value / denominator.value
+    original = matches[0]
+    for status in ("below_detection", "missing", "not_measured", "not_mapped"):
+        denominator = replace(original.left[0], value=None, status=status)
+        match = replace(original, left=(denominator,))
+        value = match.ratio(match.right[0], denominator, measurement_id="ratio", method="test",
+                            normalization={"method": "unchanged"})
+        assert value.value is None and value.status == "not_measured"
+    logged = replace(original.left[0], scale="log", log_base=2, value=1)
+    match = replace(original, left=(logged,))
+    with pytest.raises(ValueError, match="must be linear"):
+        match.ratio(match.right[0], logged, measurement_id="ratio", method="test",
+                    normalization={"method": "unchanged"})
+
+
+def test_parent_rna_and_ambiguous_groups_cannot_become_orf_ratios(paired):
+    pair, relation = paired[1]["pairings"][0], paired[1]["relations"][0]
+    left, right = paired[1]["measurements"][0], paired[1]["measurements"][4]
+    orf = replace(right.target, kind="orf")
+    relation = replace(relation, right=orf, relation="parent_rna_context", cardinality="one_to_many")
+    match = MatchedMeasurements(pair, relation, (left,), (replace(right, target=orf),))
+    assert match.left[0].target.kind == "gene"
+    with pytest.raises(ValueError, match="Parent RNA/group"):
+        match.ratio(match.right[0], left, measurement_id="ratio", method="test", normalization={"method": "none"})
+    group = replace(left.target, kind="protein_group")
+    group_relation = replace(relation, left=group, relation="shared_group_member")
+    match = MatchedMeasurements(pair, group_relation, (replace(left, target=group),), match.right)
+    with pytest.raises(ValueError, match="Parent RNA/group"):
+        match.ratio(match.right[0], match.left[0], measurement_id="ratio", method="test", normalization={"method": "none"})
+
+
+def test_duplicate_isoform_attribution_is_not_one_to_one(tmp_path, paired):
+    relation = paired[1]["relations"][0]
+    other = replace(relation, relation_id="isoform", right=replace(relation.right, identifier="isoform2"))
+    with pytest.raises(ValueError, match="Conflicting one-to-one"):
+        create(tmp_path, paired, relations=[relation, other])
+    with pytest.raises(ValueError, match="Conflicting one-to-one"):
+        create(tmp_path, paired, relations=[relation, replace(other, cardinality="one_to_many")])
+    pair = paired[1]["pairings"][0]
+    left, right = paired[1]["measurements"][0], paired[1]["measurements"][4]
+    match = MatchedMeasurements(pair, replace(relation, cardinality="one_to_many"), (left,), (right,))
+    with pytest.raises(ValueError, match="one-to-one attribution"):
+        match.ratio(right, left, measurement_id="ratio", method="test", normalization={"method": "none"})
+
+
+def test_gene_and_transcript_links_are_distinct_attribution_axes(tmp_path, paired):
+    gene_relation = paired[1]["relations"][0]
+    transcript_relation = replace(gene_relation, relation_id="transcript-encoding",
+                                   left=replace(gene_relation.left, kind="transcript", identifier="rna"))
+    dataset = create(tmp_path, paired, relations=[gene_relation, transcript_relation])
+    assert len(list(dataset.relations())) == 2
+
+
+def test_same_target_across_samples_stays_a_separate_comparison(tmp_path, paired):
+    manifest, values = paired
+    original = values["measurements"][0]
+    sample = replace(values["samples"][0], sample_id="second", biological_unit_id="animal-2")
+    assay = Assay("rna-2", "second", "rna_seq", sample.reference)
+    other = replace(original, measurement_id="second-value", sample_id="second", assay_id="rna-2", value=2)
+    relation = TargetRelation("same", "fixture", "1", original.target, original.target,
+                               "same_target", "one_to_one", {"identity": "exact scoped target"})
+    pair = replace(values["pairings"][0], right_assay_id="rna-2", basis="biological_replicate")
+    dataset = create(tmp_path, paired, samples=(*values["samples"], sample),
+                      assays=(*values["assays"], assay), measurements=(*values["measurements"], other),
+                      pairings=[pair], relations=[relation])
+    match = next(dataset.matched_measurements(allowed_bases=["biological_replicate"]))
+    assert match.left[0].target == match.right[0].target
+    assert match.left[0].sample_id != match.right[0].sample_id
+
+
+def test_old_storage_has_no_inferred_relationships(tmp_path, paired):
+    dataset = create(tmp_path, paired)
+    with sqlite3.connect(dataset.path) as connection:
+        connection.execute("DROP TABLE assay_pair")
+        connection.execute("DROP TABLE target_relation")
+        connection.execute("PRAGMA user_version=1")
+    old = QuantitativeDataset(dataset.path)
+    assert list(old.pairings()) == list(old.relations()) == []
+    assert list(old.matched_measurements(allowed_bases=PAIRING_BASES)) == []
+    assert len(list(old.measurements())) == 8
+
+
+def test_orthology_keeps_both_species_and_never_transfers_abundance(tmp_path, paired):
+    dataset = create(tmp_path, paired)
+    observations = paired[1]["measurements"]
+    mappings = [OrthologyMapping(str(index), observations[0].target, observations[index].target,
+                                paired[0].sources[0], "test:1", "one_to_one",
+                                {"definition": "synthetic fixture, not biological evidence"},
+                                {"method": "test fixture"}) for index in (1, 2, 3)]
+    comparisons = list(compare_orthologs(dataset, dataset, mappings))
+    assert len(comparisons) == 3
+    for index, comparison in enumerate(comparisons, 1):
+        assert comparison.left == (observations[0],)
+        assert comparison.right == (observations[index],)
+        assert comparison.left[0].value != comparison.right[0].value
+        assert OrthologyMapping.from_dict(comparison.mapping.to_dict()) == comparison.mapping
+        assert OrthologyComparison.from_dict(comparison.to_dict()) == comparison
+    assert list(compare_orthologs(dataset, dataset, [replace(mappings[0], cardinality="one_to_many")])) == []
+    alternate = replace(mappings[0], mapping_id="other", right=replace(mappings[0].right, identifier="other"))
+    with pytest.raises(ValueError, match="Conflicting one-to-one"):
+        list(compare_orthologs(dataset, dataset, [mappings[0], alternate]))
+    with pytest.raises(ValueError, match="sequence, frame and position"):
+        replace(mappings[0], left=replace(mappings[0].left, kind="orf"), right=replace(mappings[0].right, kind="orf"))
+    orf_mapping = replace(mappings[0], left=replace(mappings[0].left, kind="orf"),
+                           right=replace(mappings[0].right, kind="orf"),
+                           evidence={"sequence": "pinned alignment", "frame": "same frame", "position": "synteny"})
+    assert list(compare_orthologs(dataset, dataset, [orf_mapping])) == []
+    comparison = next(compare_orthologs(dataset, dataset, [orf_mapping], allow_orfs=True))
+    assert comparison.left == comparison.right == ()  # Gene values are not ORF values.
+
+
+def test_paired_table_cli_preserves_rna_protein_and_missing_ribo(tmp_path, paired, capsys):
+    from test_measurements import definition
+
+    dataset = create(tmp_path, paired)
+    metadata = definition(dataset)
+    cache_root = tmp_path / "cache"
+    DatasetRegistry(metadata, cache_root=cache_root).download("fixture", show_progress=False)
+    registry_path = tmp_path / "registry.json"
+    registry_path.write_text(json.dumps(metadata))
+    run(["datasets", "--registry", str(registry_path), "--cache-root", str(cache_root),
+         "pairs", "fixture", "--basis", "same_material"])
+    rows = [json.loads(line) for line in capsys.readouterr().out.splitlines()]
+    assert len(rows) == 4
+    assert all(row["ribosome_occupancy"] == [] for row in rows)
+    assert all(row["rna_abundance"][0]["unit"] == "TPM" for row in rows)
+    assert all(row["protein_abundance"][0]["unit"] == "iBAQ" for row in rows)

orfdata-0.3.0/orfdata/version.py

@@ -1 +0,0 @@
-__version__ = "0.3.0"