apb-fasta 0.1.0__py3-none-any.whl

apb_fasta/api.py

@@ -0,0 +1,164 @@
+"""Public in-memory FASTA annotation API."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from importlib.metadata import version
+from pathlib import Path
+
+import polars as pl
+from apb2.api import ParsedLevels
+from protein_fasta.api import ProteinDatabase, ProteinFormat
+from prozor.api import resolve_backend
+
+from apb_fasta.calculation.matching import match_peptide_levels
+from apb_fasta.calculation.peptide_properties import peptide_level_properties
+from apb_fasta.calculation.protein_groups import match_protein_groups
+from apb_fasta.calculation.results import FastaAnnotationReports
+from apb_fasta.configuration import (
+    DEFAULT_FASTA_ANNOTATION_PARAMETERS,
+    FastaAnnotationParameters,
+)
+from apb_fasta.errors import FastaAnnotationError
+from apb_fasta.integration import (
+    apply_peptide_matches,
+    apply_peptide_properties,
+    apply_protein_group_match,
+    peptide_inputs,
+    protein_frame_metadata,
+    protein_group_input,
+    validate_protein_frame,
+)
+
+_NO_PEPTIDE_LEVEL = (
+    "result contains no peptide-derived level with canonical ProForma_peptide values"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class FastaAnnotationResult:
+    """A replacement APB2 result and its FASTA reports."""
+
+    parsed: ParsedLevels
+    reports: FastaAnnotationReports
+
+
+class FastaAnnotator:
+    """Bind one protein database and its FASTA annotation behavior."""
+
+    __slots__ = ("_parameters", "_proteins")
+
+    def __init__(
+        self,
+        proteins: pl.DataFrame,
+        parameters: FastaAnnotationParameters = DEFAULT_FASTA_ANNOTATION_PARAMETERS,
+    ) -> None:
+        """Validate and bind a reusable protein database and configuration."""
+        validate_protein_frame(proteins)
+        self._proteins = proteins
+        self._parameters = parameters
+
+    @classmethod
+    def read(
+        cls,
+        fasta: Sequence[Path],
+        formats: Sequence[str] = ("uniprotkb", "refseq"),
+        parameters: FastaAnnotationParameters = DEFAULT_FASTA_ANNOTATION_PARAMETERS,
+    ) -> FastaAnnotator:
+        """Read FASTA files, or the protein-fasta database Parquet written from them."""
+        if not fasta:
+            raise ValueError("at least one FASTA path is required")
+        database = ProteinDatabase(*(ProteinFormat(name) for name in formats))
+        return cls(database.parse(tuple(fasta)), parameters)
+
+    @property
+    def proteins(self) -> pl.DataFrame:
+        """The bound protein table, one row per FASTA entry in file order."""
+        return self._proteins
+
+    def verify_peptides(self, parsed: ParsedLevels) -> FastaAnnotationResult:
+        """Verify every canonical stripped peptide against the protein sequences."""
+        inputs = peptide_inputs(parsed)
+        if not inputs:
+            raise FastaAnnotationError(_NO_PEPTIDE_LEVEL)
+        peptide_levels = match_peptide_levels(
+            inputs,
+            self._proteins,
+            backend=self._parameters.matcher_backend,
+            il_equivalent=self._parameters.il_equivalent,
+            protein_group_separator=self._parameters.protein_group_separator,
+        )
+        replacement, reports = apply_peptide_matches(
+            parsed,
+            peptide_levels,
+            requested_backend=self._parameters.matcher_backend,
+            resolved_backend=resolve_backend(self._parameters.matcher_backend),
+            il_equivalent=self._parameters.il_equivalent,
+            protein_metadata=protein_frame_metadata(self._proteins),
+        )
+        return FastaAnnotationResult(parsed=replacement, reports=reports)
+
+    def merge_annotations(self, parsed: ParsedLevels) -> FastaAnnotationResult:
+        """Merge FASTA annotations for every reported protein-group member."""
+        protein_input = protein_group_input(parsed)
+        if protein_input is None:
+            raise FastaAnnotationError("result contains no protein level to annotate")
+        protein_groups = match_protein_groups(
+            protein_input,
+            self._proteins,
+            separator=self._parameters.protein_group_separator,
+        )
+        replacement, reports = apply_protein_group_match(
+            parsed,
+            protein_groups,
+            protein_group_separator=self._parameters.protein_group_separator,
+            protein_metadata=protein_frame_metadata(self._proteins),
+        )
+        return FastaAnnotationResult(parsed=replacement, reports=reports)
+
+    def annotate(self, parsed: ParsedLevels) -> FastaAnnotationResult:
+        """Verify peptides and then merge protein annotations in memory."""
+        verified = self.verify_peptides(parsed)
+        annotated = self.merge_annotations(verified.parsed)
+        return FastaAnnotationResult(
+            parsed=annotated.parsed,
+            reports=FastaAnnotationReports(
+                peptide_levels=verified.reports.peptide_levels,
+                protein_groups=annotated.reports.protein_groups,
+            ),
+        )
+
+
+def add_peptide_properties(parsed: ParsedLevels) -> ParsedLevels:
+    """Attach sequence-derived properties to every peptide-derived level.
+
+    Writes a feature-aligned ``varm["peptide_properties"]`` computed by
+    ``protein_fasta.peptide_frame.peptide_property_frame`` from each level's ``ProForma_peptide``.
+    No protein database is needed. A feature without a sequence, or with a residue outside the 20
+    standard amino acids, has null properties.
+
+    Raises:
+        FastaAnnotationError: If the result has no peptide-derived level, already contains the
+            output, or already records the operation.
+        ValueError: If a sequence is not stripped upper-case letters.
+    """
+    inputs = peptide_inputs(parsed)
+    if not inputs:
+        raise FastaAnnotationError(_NO_PEPTIDE_LEVEL)
+    properties = {
+        name: peptide_level_properties(level.frame, level.sequence_column)
+        for name, level in inputs.items()
+    }
+    return apply_peptide_properties(
+        parsed, properties, protein_fasta_version=version("protein-fasta")
+    )
+
+
+__all__ = [
+    "FastaAnnotationParameters",
+    "FastaAnnotationReports",
+    "FastaAnnotationResult",
+    "FastaAnnotator",
+    "add_peptide_properties",
+]

apb_fasta/calculation/matching.py

@@ -0,0 +1,209 @@
+"""Peptide-to-protein matching and feature-aligned summaries."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+import polars as pl
+from prozor.api import annotate_peptides
+
+from apb_fasta.calculation.results import PeptideCoverage, PeptideLevelMatch
+
+
+@dataclass(frozen=True, slots=True)
+class PeptideLevelInput:
+    """The columns needed to validate one peptide-derived feature level."""
+
+    frame: pl.DataFrame
+    sequence_column: str
+    accession_column: str | None
+
+
+def match_peptide_levels(
+    levels: Mapping[str, PeptideLevelInput],
+    proteins: pl.DataFrame,
+    /,
+    *,
+    backend: str,
+    il_equivalent: bool,
+    protein_group_separator: str,
+) -> dict[str, PeptideLevelMatch]:
+    """Match distinct normalized peptides once and summarize every source feature."""
+    if not levels:
+        return {}
+    prepared = {name: _prepare_features(level, il_equivalent) for name, level in levels.items()}
+    peptides = (
+        pl.concat([frame.select("peptide") for frame in prepared.values()])
+        .drop_nulls()
+        .unique(maintain_order=True)
+    )
+    sequence = _text_column(proteins, "sequence")
+    if il_equivalent:
+        sequence = sequence.str.replace_all("I", "L", literal=True)
+    sequences = proteins.select(sequence).to_series()
+    if sequences.null_count():
+        raise ValueError("protein frame column 'sequence' contains a non-text value")
+    matched = annotate_peptides(
+        peptides.get_column("peptide").to_list(),
+        dict(zip(map(str, range(sequences.len())), sequences.to_list(), strict=True)),
+        backend=backend,
+    )
+    occurrences = pl.DataFrame(
+        [(match.peptide, int(match.protein_id)) for match in matched],
+        schema={"peptide": pl.String, "record": pl.UInt32},
+        orient="row",
+    )
+    site_counts = occurrences.group_by("peptide").agg(
+        pl.len().cast(pl.UInt64).alias("fasta_match_site_count")
+    )
+    columns = set(proteins.columns)
+    indexed = proteins.select(
+        id=_text_column(proteins, "id"),
+        organism=_text_column(
+            proteins, "organism_mnemonic" if "organism_mnemonic" in columns else None
+        ),
+        is_contaminant=pl.col("is_contaminant") if "is_contaminant" in columns else pl.lit(False),
+    ).with_row_index("record")
+    distinct = occurrences.unique(maintain_order=True).join(
+        indexed, on="record", how="left", maintain_order="left"
+    )
+    if distinct.get_column("id").null_count():
+        raise ValueError("protein frame column 'id' contains a non-text value")
+    matches = distinct.group_by("peptide", maintain_order=True).agg(
+        pl.col("record").alias("matched_records"),
+        pl.len().cast(pl.UInt64).alias("fasta_matching_protein_count"),
+        pl.col("id").str.join(";").alias("fasta_matching_protein_ids"),
+        fasta_matching_organisms=pl.col("organism").drop_nulls().unique().sort().str.join(";"),
+        fasta_matches_contaminant=pl.col("is_contaminant").any(),
+    )
+    matches = matches.join(site_counts, on="peptide", how="left")
+    assignments = _reported_assignments(prepared, proteins, protein_group_separator)
+    return {
+        name: _level_match(frame, matches, assignments, levels[name].accession_column is not None)
+        for name, frame in prepared.items()
+    }
+
+
+def _text_column(frame: pl.DataFrame, column: str | None) -> pl.Expr:
+    if column is None:
+        return pl.lit(None, dtype=pl.String)
+    dtype = frame.schema[column]
+    if isinstance(dtype, (pl.String, pl.Categorical, pl.Enum)):
+        return pl.col(column).cast(pl.String)
+    if dtype == pl.Object:
+        # Only foreign mixed-object columns need scalar type checking.
+        return pl.col(column).map_elements(_optional_text, return_dtype=pl.String)
+    return pl.lit(None, dtype=pl.String)
+
+
+def _optional_text(value: object) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _prepare_features(level: PeptideLevelInput, il_equivalent: bool) -> pl.DataFrame:
+    sequence = _text_column(level.frame, level.sequence_column).str.strip_chars().str.to_uppercase()
+    if il_equivalent:
+        sequence = sequence.str.replace_all("I", "L", literal=True)
+    # with_columns keeps the source height even when both expressions are scalar nulls.
+    return level.frame.with_columns(
+        sequence.alias("peptide"),
+        _text_column(level.frame, level.accession_column).alias("assignment"),
+    ).select(
+        pl.when(pl.col("peptide") != "").then(pl.col("peptide")).alias("peptide"),
+        "assignment",
+    )
+
+
+def _reported_assignments(
+    prepared: Mapping[str, pl.DataFrame], proteins: pl.DataFrame, separator: str
+) -> pl.DataFrame:
+    aliases = pl.concat(
+        [
+            proteins.with_columns(_text_column(proteins, column).alias("member"))
+            .select("member")
+            .with_row_index("record")
+            for column in ("id", "accession")
+            if column in proteins.columns
+        ]
+    )
+    aliases = (
+        aliases.filter(pl.col("member").is_not_null() & (pl.col("member") != ""))
+        .unique()
+        .group_by("member")
+        .agg("record")
+    )
+    assignments = (
+        pl.concat([frame.select("assignment") for frame in prepared.values()]).drop_nulls().unique()
+    )
+    return (
+        assignments.with_columns(
+            pl.col("assignment")
+            .str.split(separator)
+            .list.eval(pl.element().str.strip_chars())
+            .alias("member")
+        )
+        .explode("member", empty_as_null=True)
+        .filter(pl.col("member") != "")
+        .join(aliases, on="member", how="left")
+        .group_by("assignment")
+        .agg(
+            pl.len().cast(pl.UInt64).alias("reported_member_count"),
+            pl.col("record")
+            .is_not_null()
+            .sum()
+            .cast(pl.UInt64)
+            .alias("reported_members_in_fasta_count"),
+            pl.col("record")
+            .explode(empty_as_null=True)
+            .drop_nulls()
+            .unique()
+            .alias("reported_records"),
+        )
+    )
+
+
+def _level_match(
+    features: pl.DataFrame,
+    matches: pl.DataFrame,
+    assignments: pl.DataFrame,
+    has_assignment: bool,
+) -> PeptideLevelMatch:
+    joined = features.join(matches, on="peptide", how="left", maintain_order="left").join(
+        assignments, on="assignment", how="left", maintain_order="left"
+    )
+    summary = joined.select(
+        (pl.col("fasta_matching_protein_count").fill_null(0) > 0).alias("peptide_in_fasta"),
+        pl.col("fasta_match_site_count").fill_null(0),
+        pl.col("fasta_matching_protein_count").fill_null(0),
+        pl.col("fasta_matching_protein_ids").fill_null(""),
+        pl.col("fasta_matching_organisms").fill_null(""),
+        pl.col("fasta_matches_contaminant").fill_null(False),
+        pl.col("reported_member_count").fill_null(0),
+        pl.col("reported_members_in_fasta_count").fill_null(0),
+        (
+            pl.col("matched_records")
+            .fill_null([])
+            .list.set_intersection(pl.col("reported_records").fill_null([]))
+            .list.len()
+            > 0
+        ).alias("peptide_in_reported_protein"),
+    )
+    if not has_assignment:
+        summary = summary.with_columns(
+            pl.lit(None, dtype=pl.UInt64).alias("reported_member_count"),
+            pl.lit(None, dtype=pl.UInt64).alias("reported_members_in_fasta_count"),
+            pl.lit(None, dtype=pl.Boolean).alias("peptide_in_reported_protein"),
+        )
+    unique = joined.select("peptide", "fasta_match_site_count").drop_nulls("peptide").unique()
+    matched_count = int(summary.get_column("peptide_in_fasta").sum() or 0)
+    return PeptideLevelMatch(
+        summary=summary,
+        coverage=PeptideCoverage(
+            feature_count=features.height,
+            unique_sequence_count=unique.height,
+            matched_feature_count=matched_count,
+            unmatched_feature_count=features.height - matched_count,
+            match_site_count=int(unique.get_column("fasta_match_site_count").sum() or 0),
+        ),
+    )

apb_fasta/calculation/peptide_properties.py

@@ -0,0 +1,25 @@
+"""Feature-aligned sequence properties of one peptide-derived level."""
+
+from __future__ import annotations
+
+import polars as pl
+from protein_fasta.api import peptide_property_frame
+
+
+def peptide_level_properties(frame: pl.DataFrame, sequence_column: str, /) -> pl.DataFrame:
+    """Return one property row per feature of ``frame``, in feature order.
+
+    Each distinct sequence is computed once; a feature without a sequence has null properties.
+    """
+    features = frame.select(
+        pl.col(sequence_column)
+        .cast(pl.String)
+        .str.strip_chars()
+        .str.to_uppercase()
+        .alias("sequence")
+    ).select(pl.when(pl.col("sequence") != "").then(pl.col("sequence")).alias("sequence"))
+    sequences = features.get_column("sequence").drop_nulls().unique(maintain_order=True)
+    properties = peptide_property_frame(sequences.to_list())
+    return features.join(properties, on="sequence", how="left", maintain_order="left").drop(
+        "sequence"
+    )

apb_fasta/calculation/protein_groups.py

@@ -0,0 +1,231 @@
+"""Protein-group expansion and FASTA annotation over Polars values."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+import polars as pl
+
+from apb_fasta.calculation.results import ProteinGroupCoverage, ProteinGroupMatch
+
+_OPTIONAL_FASTA_COLUMNS = (
+    "is_decoy",
+    "is_contaminant",
+    "accession",
+    "protein_name",
+    "gene_name",
+    "organism_name",
+    "taxonomy_id",
+    "database",
+    "review_status",
+    "fasta_source_path",
+    "fasta_source_checksum",
+    "fasta_source_ordinal",
+    "fasta_record_ordinal",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ProteinGroupInput:
+    """The protein feature axis and its declared FASTA accession column."""
+
+    frame: pl.DataFrame
+    key_columns: tuple[str, ...]
+    accession_column: str
+
+
+def match_protein_groups(
+    source: ProteinGroupInput,
+    proteins: pl.DataFrame,
+    /,
+    *,
+    separator: str,
+) -> ProteinGroupMatch:
+    """Expand every reported member and retain every matching FASTA record."""
+    protein_rows = proteins.to_dicts()
+    aliases = _protein_aliases(protein_rows)
+    members_rows: list[dict[str, object]] = []
+    summaries: list[dict[str, object]] = []
+    relation_rows: list[dict[str, object]] = []
+    matched_members = 0
+    unmatched_members = 0
+    ambiguous_members = 0
+    member_count = 0
+    for group_index, group in enumerate(source.frame.to_dicts()):
+        raw_group = group.get(source.accession_column)
+        members = _members(raw_group, separator)
+        group_matched = 0
+        group_unmatched = 0
+        group_ambiguous = 0
+        descriptions: list[str] = []
+        gene_names: list[str] = []
+        organism_names: list[str] = []
+        for member_ordinal, member in enumerate(members):
+            member_count += 1
+            matches = aliases.get(member, ())
+            if not matches:
+                unmatched_members += 1
+                group_unmatched += 1
+                members_rows.append(
+                    _member_row(
+                        source,
+                        group,
+                        raw_group,
+                        member,
+                        member_ordinal,
+                        0,
+                        "unmatched",
+                        None,
+                    )
+                )
+                relation_rows.append(
+                    {"row": len(members_rows) - 1, "column": group_index, "value": 1.0}
+                )
+                continue
+            matched_members += 1
+            group_matched += 1
+            status = "ambiguous" if len(matches) > 1 else "matched"
+            if len(matches) > 1:
+                ambiguous_members += 1
+                group_ambiguous += 1
+            for match_ordinal, protein_index in enumerate(matches):
+                protein = protein_rows[protein_index]
+                members_rows.append(
+                    _member_row(
+                        source,
+                        group,
+                        raw_group,
+                        member,
+                        member_ordinal,
+                        match_ordinal,
+                        status,
+                        protein,
+                    )
+                )
+                relation_rows.append(
+                    {"row": len(members_rows) - 1, "column": group_index, "value": 1.0}
+                )
+                _append_text(descriptions, protein.get("description"))
+                _append_text(gene_names, protein.get("gene_name"))
+                _append_text(organism_names, protein.get("organism_name"))
+        summaries.append(
+            {
+                "reported_member_count": len(members),
+                "matched_member_count": group_matched,
+                "unmatched_member_count": group_unmatched,
+                "ambiguous_member_count": group_ambiguous,
+                "all_members_in_fasta": bool(members) and group_unmatched == 0,
+                "any_member_in_fasta": group_matched > 0,
+                "fasta_descriptions": ";".join(descriptions),
+                "fasta_gene_names": ";".join(gene_names),
+                "fasta_organism_names": ";".join(organism_names),
+            }
+        )
+    member_keys = ("source_level", *source.key_columns, "member_ordinal", "match_ordinal")
+    return ProteinGroupMatch(
+        members=pl.DataFrame(members_rows, schema=_member_schema(source, proteins)),
+        member_key_columns=member_keys,
+        summary=pl.DataFrame(summaries, schema=_summary_schema()),
+        relation=pl.DataFrame(
+            relation_rows,
+            schema={"row": pl.Int64, "column": pl.Int64, "value": pl.Float64},
+        ),
+        coverage=ProteinGroupCoverage(
+            group_count=source.frame.height,
+            member_count=member_count,
+            matched_member_count=matched_members,
+            unmatched_member_count=unmatched_members,
+            ambiguous_member_count=ambiguous_members,
+        ),
+    )
+
+
+def _member_row(
+    source: ProteinGroupInput,
+    group: Mapping[str, object],
+    raw_group: object,
+    member: str,
+    member_ordinal: int,
+    match_ordinal: int,
+    status: str,
+    protein: Mapping[str, object] | None,
+) -> dict[str, object]:
+    sequence = None if protein is None else protein.get("sequence")
+    row: dict[str, object] = {
+        "source_level": "protein",
+        **{name: group[name] for name in source.key_columns},
+        "member_ordinal": member_ordinal,
+        "match_ordinal": match_ordinal,
+        "protein_group": raw_group,
+        "protein_member": member,
+        "normalized_matching_key": member,
+        "match_status": status,
+        "fasta_id": None if protein is None else protein.get("id"),
+        "fasta_description": None if protein is None else protein.get("description"),
+        "fasta_sequence_length": (None if not isinstance(sequence, str) else len(sequence)),
+    }
+    for name in _OPTIONAL_FASTA_COLUMNS:
+        row[name] = None if protein is None else protein.get(name)
+    return row
+
+
+def _member_schema(
+    source: ProteinGroupInput,
+    proteins: pl.DataFrame,
+) -> dict[str, pl.DataType | type[pl.DataType]]:
+    schema: dict[str, pl.DataType | type[pl.DataType]] = {
+        "source_level": pl.String,
+        **{name: source.frame.schema[name] for name in source.key_columns},
+        "member_ordinal": pl.Int64,
+        "match_ordinal": pl.Int64,
+        "protein_group": source.frame.schema[source.accession_column],
+        "protein_member": pl.String,
+        "normalized_matching_key": pl.String,
+        "match_status": pl.String,
+        "fasta_id": pl.String,
+        "fasta_description": pl.String,
+        "fasta_sequence_length": pl.UInt64,
+    }
+    for name in _OPTIONAL_FASTA_COLUMNS:
+        schema[name] = proteins.schema.get(name, pl.Null)
+    return schema
+
+
+def _summary_schema() -> dict[str, type[pl.DataType]]:
+    return {
+        "reported_member_count": pl.UInt64,
+        "matched_member_count": pl.UInt64,
+        "unmatched_member_count": pl.UInt64,
+        "ambiguous_member_count": pl.UInt64,
+        "all_members_in_fasta": pl.Boolean,
+        "any_member_in_fasta": pl.Boolean,
+        "fasta_descriptions": pl.String,
+        "fasta_gene_names": pl.String,
+        "fasta_organism_names": pl.String,
+    }
+
+
+def _protein_aliases(rows: list[dict[str, object]]) -> dict[str, tuple[int, ...]]:
+    collected: dict[str, list[int]] = defaultdict(list)
+    for index, row in enumerate(rows):
+        aliases = {
+            value
+            for name in ("id", "accession")
+            if isinstance((value := row.get(name)), str) and value
+        }
+        for alias in aliases:
+            collected[alias].append(index)
+    return {name: tuple(indices) for name, indices in collected.items()}
+
+
+def _members(value: object, separator: str) -> tuple[str, ...]:
+    if not isinstance(value, str):
+        return ()
+    return tuple(token.strip() for token in value.split(separator) if token.strip())
+
+
+def _append_text(values: list[str], value: object) -> None:
+    if isinstance(value, str) and value and value not in values:
+        values.append(value)

apb_fasta/calculation/results.py

@@ -0,0 +1,57 @@
+"""Immutable calculation values returned to the APB2 integration boundary."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+import polars as pl
+
+
+@dataclass(frozen=True, slots=True)
+class PeptideCoverage:
+    """Aggregate FASTA coverage for one APB2 feature level."""
+
+    feature_count: int
+    unique_sequence_count: int
+    matched_feature_count: int
+    unmatched_feature_count: int
+    match_site_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class PeptideLevelMatch:
+    """Feature-aligned peptide facts and their aggregate coverage."""
+
+    summary: pl.DataFrame
+    coverage: PeptideCoverage
+
+
+@dataclass(frozen=True, slots=True)
+class ProteinGroupCoverage:
+    """Aggregate FASTA coverage for reported protein-group members."""
+
+    group_count: int
+    member_count: int
+    matched_member_count: int
+    unmatched_member_count: int
+    ambiguous_member_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class ProteinGroupMatch:
+    """Lossless member expansion, group summaries, and source relation."""
+
+    members: pl.DataFrame
+    member_key_columns: tuple[str, ...]
+    summary: pl.DataFrame
+    relation: pl.DataFrame
+    coverage: ProteinGroupCoverage
+
+
+@dataclass(frozen=True, slots=True)
+class FastaAnnotationReports:
+    """Persistable aggregate evidence from one annotation application."""
+
+    peptide_levels: Mapping[str, PeptideCoverage]
+    protein_groups: ProteinGroupCoverage | None

apb_fasta/cli.py

@@ -0,0 +1,160 @@
+"""Thin command-line composition for independent APB2 FASTA operations."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Literal
+
+from apb2.api import read_parsed_levels, write_parsed_levels
+from cyclopts import App
+from loguru import logger
+
+from apb_fasta.api import FastaAnnotationParameters, FastaAnnotationResult, FastaAnnotator
+
+app = App(
+    name="apb-fasta",
+    help="Verify peptides and merge protein annotations using FASTA files",
+    help_on_error=True,
+)
+
+
+@app.command
+def verify_peptides(
+    source: Path,
+    *fasta_paths: Path,
+    output: Path,
+    formats: tuple[str, ...] = ("uniprotkb", "refseq"),
+    backend: Literal["auto", "ahocorapy", "ahocorasick_rs"] = "auto",
+    il_equivalent: bool = False,
+    protein_group_separator: str = ";",
+) -> int:
+    """Verify stripped peptide sequences in SOURCE against FASTA_PATHS."""
+    try:
+        _require_new_target(source, output)
+        annotator = FastaAnnotator.read(
+            fasta_paths,
+            formats,
+            FastaAnnotationParameters(
+                protein_group_separator=protein_group_separator,
+                matcher_backend=backend,
+                il_equivalent=il_equivalent,
+            ),
+        )
+        result = annotator.verify_peptides(read_parsed_levels(source))
+        _write_result(result, output)
+        _report_peptide_verification(result)
+    except (OSError, ValueError) as error:
+        logger.error(str(error))
+        return 1
+    logger.info("wrote peptide-verified APB2 result to {}", output)
+    return 0
+
+
+@app.command
+def merge_annotations(
+    source: Path,
+    *fasta_paths: Path,
+    output: Path,
+    formats: tuple[str, ...] = ("uniprotkb", "refseq"),
+    protein_group_separator: str = ";",
+) -> int:
+    """Merge FASTA annotations into the reported protein groups in SOURCE."""
+    try:
+        _require_new_target(source, output)
+        annotator = FastaAnnotator.read(
+            fasta_paths,
+            formats,
+            FastaAnnotationParameters(
+                protein_group_separator=protein_group_separator,
+            ),
+        )
+        result = annotator.merge_annotations(read_parsed_levels(source))
+        _write_result(result, output)
+        _report_protein_annotations(result)
+    except (OSError, ValueError) as error:
+        logger.error(str(error))
+        return 1
+    logger.info("wrote FASTA-annotated APB2 result to {}", output)
+    return 0
+
+
+@app.command
+def run(
+    source: Path,
+    *fasta_paths: Path,
+    output: Path,
+    formats: tuple[str, ...] = ("uniprotkb", "refseq"),
+    backend: Literal["auto", "ahocorapy", "ahocorasick_rs"] = "auto",
+    il_equivalent: bool = False,
+    protein_group_separator: str = ";",
+) -> int:
+    """Verify peptides and merge protein annotations in one in-memory run."""
+    try:
+        _require_new_target(source, output)
+        annotator = FastaAnnotator.read(
+            fasta_paths,
+            formats,
+            FastaAnnotationParameters(
+                protein_group_separator=protein_group_separator,
+                matcher_backend=backend,
+                il_equivalent=il_equivalent,
+            ),
+        )
+        result = annotator.annotate(read_parsed_levels(source))
+        _write_result(result, output)
+        _report_peptide_verification(result)
+        _report_protein_annotations(result)
+    except (OSError, ValueError) as error:
+        logger.error(str(error))
+        return 1
+    logger.info("wrote peptide-verified and FASTA-annotated APB2 result to {}", output)
+    return 0
+
+
+def _require_new_target(source: Path, target: Path, /) -> None:
+    if source.resolve() == target.resolve():
+        raise ValueError("output must differ from source")
+    if target.exists():
+        raise ValueError(f"output already exists: {target}")
+
+
+def _write_result(result: FastaAnnotationResult, output: Path) -> None:
+    write_parsed_levels(result.parsed, output)
+
+
+def _report_peptide_verification(result: FastaAnnotationResult) -> None:
+    for level, coverage in result.reports.peptide_levels.items():
+        logger.info(
+            "level={} peptides_in_fasta={}/{} unmatched={} unique_sequences={} match_sites={}",
+            level,
+            coverage.matched_feature_count,
+            coverage.feature_count,
+            coverage.unmatched_feature_count,
+            coverage.unique_sequence_count,
+            coverage.match_site_count,
+        )
+
+
+def _report_protein_annotations(result: FastaAnnotationResult) -> None:
+    coverage = result.reports.protein_groups
+    if coverage is None:
+        return
+    logger.info(
+        "protein_groups={} members_in_fasta={}/{} unmatched={} ambiguous={}",
+        coverage.group_count,
+        coverage.matched_member_count,
+        coverage.member_count,
+        coverage.unmatched_member_count,
+        coverage.ambiguous_member_count,
+    )
+
+
+def main() -> int:
+    """Run the console application."""
+    result = app()
+    return int(result) if result is not None else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

apb_fasta/configuration.py

@@ -0,0 +1,21 @@
+"""User-selected FASTA annotation behavior."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass(frozen=True, slots=True)
+class FastaAnnotationParameters:
+    """Configuration shared by peptide validation and protein annotation."""
+
+    protein_group_separator: str = ";"
+    matcher_backend: Literal["auto", "ahocorapy", "ahocorasick_rs"] = "auto"
+    il_equivalent: bool = False
+
+    def __post_init__(self) -> None:
+        """Reject a separator that cannot define protein-group members."""
+        if not self.protein_group_separator:
+            raise ValueError("protein_group_separator must not be empty")
+
+
+DEFAULT_FASTA_ANNOTATION_PARAMETERS = FastaAnnotationParameters()

apb_fasta/errors.py

@@ -0,0 +1,5 @@
+"""Expected APB FASTA annotation failures."""
+
+
+class FastaAnnotationError(ValueError):
+    """The supplied APB2 result or protein frame cannot be annotated safely."""

apb_fasta/integration.py

@@ -0,0 +1,288 @@
+"""Translate between APB2 result values and FASTA calculations."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import asdict
+from typing import cast
+
+import polars as pl
+from apb2.api import JsonValue, ParsedLevels
+
+from apb_fasta.calculation.matching import PeptideLevelInput
+from apb_fasta.calculation.protein_groups import ProteinGroupInput
+from apb_fasta.calculation.results import (
+    FastaAnnotationReports,
+    PeptideLevelMatch,
+    ProteinGroupMatch,
+)
+from apb_fasta.errors import FastaAnnotationError
+
+FASTA_VALIDATION_NAME = "fasta_validation"
+FASTA_SUMMARY_NAME = "fasta"
+MEMBER_TABLE_NAME = "fasta_protein_group_members"
+MEMBER_RELATION_NAME = "fasta_protein_group_membership"
+PEPTIDE_PROPERTIES_NAME = "peptide_properties"
+PEPTIDE_VERIFICATION_OPERATION = "peptide_verification"
+PROTEIN_ANNOTATION_OPERATION = "protein_annotation"
+PEPTIDE_PROPERTIES_OPERATION = "peptide_properties"
+_PEPTIDE_COLUMN = "ProForma_peptide"
+_RESERVED_MEMBER_COLUMNS = frozenset({"source_level", "member_ordinal", "match_ordinal"})
+
+
+def validate_protein_frame(proteins: pl.DataFrame, /) -> None:
+    """Require the stable protein-fasta columns used by both calculations."""
+    required = {
+        "id",
+        "description",
+        "sequence",
+        "fasta_source_path",
+        "fasta_source_checksum",
+        "fasta_source_ordinal",
+        "fasta_record_ordinal",
+    }
+    missing = sorted(required.difference(proteins.columns))
+    if missing:
+        raise FastaAnnotationError(f"protein frame is missing required columns {missing}")
+    if proteins.get_column("id").null_count():
+        raise FastaAnnotationError("protein frame contains a missing id")
+    if proteins.get_column("sequence").null_count():
+        raise FastaAnnotationError("protein frame contains a missing sequence")
+
+
+def peptide_inputs(parsed: ParsedLevels, /) -> dict[str, PeptideLevelInput]:
+    """Extract every peptide-derived level carrying APB2's canonical sequence."""
+    result: dict[str, PeptideLevelInput] = {}
+    for name, level in parsed.levels.items():
+        if name == "protein" or _PEPTIDE_COLUMN not in level.var.frame.columns:
+            continue
+        result[name] = PeptideLevelInput(
+            frame=level.var.frame,
+            sequence_column=_PEPTIDE_COLUMN,
+            accession_column=_fasta_accession_column(level.var.roles, level.var.frame),
+        )
+    return result
+
+
+def protein_group_input(parsed: ParsedLevels, /) -> ProteinGroupInput | None:
+    """Extract the protein axis and its persisted FASTA-accession role."""
+    level = parsed.levels.get("protein")
+    if level is None:
+        return None
+    accession_column = _fasta_accession_column(level.var.roles, level.var.frame)
+    if accession_column is None:
+        raise FastaAnnotationError("protein level does not declare column_roles.fasta_accessions")
+    collisions = _RESERVED_MEMBER_COLUMNS.intersection(level.var.key_columns)
+    if collisions:
+        raise FastaAnnotationError(
+            f"protein variable keys collide with FASTA member columns {sorted(collisions)}"
+        )
+    return ProteinGroupInput(
+        frame=level.var.frame,
+        key_columns=level.var.key_columns,
+        accession_column=accession_column,
+    )
+
+
+def validate_peptide_output_names(
+    parsed: ParsedLevels,
+    matches: dict[str, PeptideLevelMatch],
+    /,
+) -> None:
+    """Reject peptide-verification collisions before constructing a replacement."""
+    _validate_operation_metadata(parsed, PEPTIDE_VERIFICATION_OPERATION)
+    for name in matches:
+        level_name = name
+        if FASTA_VALIDATION_NAME in parsed.levels[level_name].varm:
+            raise FastaAnnotationError(
+                f"level {name!r} already contains varm[{FASTA_VALIDATION_NAME!r}]"
+            )
+        if "fasta" in parsed.levels[level_name].metadata:
+            raise FastaAnnotationError(f"level {name!r} metadata already contains 'fasta'")
+
+
+def validate_protein_output_names(parsed: ParsedLevels, /) -> None:
+    """Reject protein-annotation collisions before constructing a replacement."""
+    _validate_operation_metadata(parsed, PROTEIN_ANNOTATION_OPERATION)
+    protein = parsed.levels["protein"]
+    if FASTA_SUMMARY_NAME in protein.varm:
+        raise FastaAnnotationError(f"level 'protein' already contains varm[{FASTA_SUMMARY_NAME!r}]")
+    if MEMBER_TABLE_NAME in parsed.annotation_tables:
+        raise FastaAnnotationError(
+            f"result already contains annotation table {MEMBER_TABLE_NAME!r}"
+        )
+    if MEMBER_RELATION_NAME in parsed.feature_relations:
+        raise FastaAnnotationError(
+            f"result already contains feature relation {MEMBER_RELATION_NAME!r}"
+        )
+
+
+def apply_peptide_matches(
+    parsed: ParsedLevels,
+    matches: dict[str, PeptideLevelMatch],
+    /,
+    *,
+    requested_backend: str,
+    resolved_backend: str,
+    il_equivalent: bool,
+    protein_metadata: dict[str, JsonValue],
+) -> tuple[ParsedLevels, FastaAnnotationReports]:
+    """Attach peptide verification to a deep replacement of the APB2 result."""
+    validate_peptide_output_names(parsed, matches)
+    result = deepcopy(parsed)
+    for name, match in matches.items():
+        level_name = name
+        result.levels[level_name].varm[FASTA_VALIDATION_NAME] = match.summary.clone()
+        level_metadata = result.levels[level_name].metadata
+        level_metadata["fasta"] = {
+            PEPTIDE_VERIFICATION_OPERATION: cast(dict[str, JsonValue], asdict(match.coverage))
+        }
+    _record_operation_metadata(
+        result,
+        PEPTIDE_VERIFICATION_OPERATION,
+        {
+            "requested_backend": requested_backend,
+            "resolved_backend": resolved_backend,
+            "il_equivalent": il_equivalent,
+            **protein_metadata,
+        },
+    )
+    reports = FastaAnnotationReports(
+        peptide_levels={name: match.coverage for name, match in matches.items()},
+        protein_groups=None,
+    )
+    return result, reports
+
+
+def apply_protein_group_match(
+    parsed: ParsedLevels,
+    match: ProteinGroupMatch,
+    /,
+    *,
+    protein_group_separator: str,
+    protein_metadata: dict[str, JsonValue],
+) -> tuple[ParsedLevels, FastaAnnotationReports]:
+    """Attach protein FASTA annotations to a deep replacement of the APB2 result."""
+    validate_protein_output_names(parsed)
+    result = deepcopy(parsed)
+    result.levels["protein"].varm[FASTA_SUMMARY_NAME] = match.summary.clone()
+    result = result.with_annotation_table(
+        MEMBER_TABLE_NAME,
+        match.members.clone(),
+        match.member_key_columns,
+        {"producer": "apb-fasta", "schema_version": "1"},
+    ).with_feature_relation(
+        MEMBER_RELATION_NAME,
+        MEMBER_TABLE_NAME,
+        "protein",
+        match.relation.clone(),
+        {"producer": "apb-fasta", "semantic": "member_of"},
+    )
+    _record_operation_metadata(
+        result,
+        PROTEIN_ANNOTATION_OPERATION,
+        {
+            "protein_group_separator": protein_group_separator,
+            **protein_metadata,
+        },
+    )
+    return result, FastaAnnotationReports(
+        peptide_levels={},
+        protein_groups=match.coverage,
+    )
+
+
+def apply_peptide_properties(
+    parsed: ParsedLevels,
+    properties: dict[str, pl.DataFrame],
+    /,
+    *,
+    protein_fasta_version: str,
+) -> ParsedLevels:
+    """Attach feature-aligned peptide properties to a deep replacement of the APB2 result."""
+    _validate_operation_metadata(parsed, PEPTIDE_PROPERTIES_OPERATION)
+    for name in properties:
+        if PEPTIDE_PROPERTIES_NAME in parsed.levels[name].varm:
+            raise FastaAnnotationError(
+                f"level {name!r} already contains varm[{PEPTIDE_PROPERTIES_NAME!r}]"
+            )
+    result = deepcopy(parsed)
+    for name, frame in properties.items():
+        result.levels[name].varm[PEPTIDE_PROPERTIES_NAME] = frame.clone()
+    _record_operation_metadata(
+        result,
+        PEPTIDE_PROPERTIES_OPERATION,
+        {"protein_fasta_version": protein_fasta_version},
+    )
+    return result
+
+
+def protein_frame_metadata(proteins: pl.DataFrame, /) -> dict[str, JsonValue]:
+    """Return bounded source and schema provenance for one protein frame."""
+    sources = (
+        proteins.select(
+            "fasta_source_ordinal",
+            "fasta_source_path",
+            "fasta_source_checksum",
+        )
+        .unique(maintain_order=True)
+        .sort("fasta_source_ordinal")
+        .to_dicts()
+    )
+    return {
+        "protein_count": proteins.height,
+        "protein_columns": list(proteins.columns),
+        "sources": {
+            str(_json_scalar(source["fasta_source_ordinal"])): {
+                "ordinal": _json_scalar(source["fasta_source_ordinal"]),
+                "path": _json_scalar(source["fasta_source_path"]),
+                "checksum": _json_scalar(source["fasta_source_checksum"]),
+            }
+            for source in sources
+        },
+    }
+
+
+def _validate_operation_metadata(parsed: ParsedLevels, operation: str) -> None:
+    metadata = parsed.metadata.get("fasta")
+    if metadata is None:
+        return
+    if not isinstance(metadata, dict):
+        raise FastaAnnotationError("result metadata 'fasta' section is not an object")
+    provenance = metadata.get("provenance", {})
+    if not isinstance(provenance, dict):
+        raise FastaAnnotationError("result FASTA provenance is not an object")
+    if operation in provenance:
+        raise FastaAnnotationError(f"result already contains FASTA operation {operation!r}")
+
+
+def _record_operation_metadata(
+    parsed: ParsedLevels,
+    operation: str,
+    operation_metadata: dict[str, JsonValue],
+) -> None:
+    existing = parsed.metadata.get("fasta")
+    metadata: dict[str, JsonValue]
+    if existing is None:
+        metadata = {"schema_version": "2", "provenance": {}}
+    else:
+        metadata = cast(dict[str, JsonValue], deepcopy(existing))
+    provenance = metadata.setdefault("provenance", {})
+    if not isinstance(provenance, dict):
+        raise FastaAnnotationError("result FASTA provenance is not an object")
+    provenance[operation] = operation_metadata
+    parsed.metadata["fasta"] = metadata
+
+
+def _fasta_accession_column(
+    roles: dict[str, str],
+    frame: pl.DataFrame,
+) -> str | None:
+    value = roles.get("fasta_accessions")
+    return value if isinstance(value, str) and value in frame.columns else None
+
+
+def _json_scalar(value: object) -> bool | int | float | str | None:
+    if value is None or isinstance(value, bool | int | float | str):
+        return value
+    raise FastaAnnotationError(f"protein source provenance contains {type(value).__name__}")

apb_fasta-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: apb-fasta
+Version: 0.1.0
+Summary: FASTA validation and protein annotation for APB2 results.
+Keywords: proteomics,fasta,anndata,protein annotation,mass spectrometry
+Author: Witold Wolski
+Author-email: Witold Wolski <wew@fgcz.ethz.ch>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Typing :: Typed
+Requires-Dist: apb2>=0.1,<0.2
+Requires-Dist: cyclopts>=4,<5
+Requires-Dist: loguru>=0.7,<1
+Requires-Dist: polars>=1.43,<2
+Requires-Dist: protein-fasta>=0.3,<0.4
+Requires-Dist: prozor>=0.1,<0.2
+Requires-Python: >=3.13
+Project-URL: Documentation, https://anndata-omics-bridge.github.io/apb-fasta/
+Project-URL: Repository, https://github.com/anndata-omics-bridge/apb-fasta
+Project-URL: Issues, https://github.com/anndata-omics-bridge/apb-fasta/issues
+Description-Content-Type: text/markdown
+
+# apb-fasta
+
+FASTA verification and protein annotation for APB2 results.
+
+**[Online documentation](https://anndata-omics-bridge.github.io/apb-fasta/)** or its [source index](https://github.com/anndata-omics-bridge/apb-fasta/blob/main/docs/index.md).
+
+The first release exposes two independent operations:
+
+- verify that APB2's modification-stripped peptide sequences occur in the supplied FASTA database;
+- merge FASTA annotations for every reported protein-group member without collapsing the group to its leading accession.
+
+Protein inference with Prozor is the planned third operation. It will remain explicit and opt-in.
+
+## Installation
+
+APB FASTA requires Python 3.13 or later.
+
+```bash
+pip install apb-fasta
+```
+
+## Python API
+
+Read the FASTA files once and load the APB2 result:
+
+```python
+from pathlib import Path
+
+from apb2.api import read_parsed_levels, write_parsed_levels
+from apb_fasta.api import FastaAnnotator
+
+annotator = FastaAnnotator.read((Path("human.fasta"), Path("contaminants.fasta")))
+parsed = read_parsed_levels(Path("input.h5mu"))
+```
+
+Verify peptides only:
+
+```python
+verified = annotator.verify_peptides(parsed)
+print(verified.reports.peptide_levels)
+write_parsed_levels(verified.parsed, Path("verified.h5mu"))
+```
+
+Merge protein annotations only:
+
+```python
+annotated = annotator.merge_annotations(parsed)
+print(annotated.reports.protein_groups)
+write_parsed_levels(annotated.parsed, Path("annotated.h5mu"))
+```
+
+Apply both operations in memory:
+
+```python
+complete = annotator.annotate(parsed)
+write_parsed_levels(complete.parsed, Path("complete.h5mu"))
+```
+
+The operations can also be chained explicitly without an intermediate file:
+
+```python
+verified = annotator.verify_peptides(parsed)
+complete = annotator.merge_annotations(verified.parsed)
+```
+
+The annotator validates and binds the reusable protein frame once. Every method accepts one canonical `ParsedLevels` value and returns an immutable `FastaAnnotationResult` containing its replacement plus typed operation reports. `apb_fasta` neither opens result files nor receives raw AnnData or MuData objects.
+
+## CLI
+
+Verify peptides only:
+
+```bash
+apb-fasta verify-peptides input.h5mu human.fasta contaminants.fasta --output verified.h5mu
+```
+
+Merge protein annotations only:
+
+```bash
+apb-fasta merge-annotations input.h5mu human.fasta contaminants.fasta --output annotated.h5mu
+```
+
+Apply both operations together:
+
+```bash
+apb-fasta run input.h5mu human.fasta contaminants.fasta --output complete.h5mu
+```
+
+Peptide verification adds feature-aligned `varm["fasta_validation"]` tables. Protein annotation adds protein-aligned `varm["fasta"]`, the lossless `fasta_protein_group_members` annotation table, and its directed relation to the protein axis.

apb_fasta-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+apb_fasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apb_fasta/api.py,sha256=2squHIacOk51JchAEupW2A6rrvCCGBFf2tgBkbhzSL0,6202
+apb_fasta/calculation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apb_fasta/calculation/matching.py,sha256=Sw8WeWyW89hGzkxAgAWmh_mTccxC9hkfbewPiSMxqg4,8097
+apb_fasta/calculation/peptide_properties.py,sha256=80A_PjI_kgG0_kX_KjccRmAkLfkOaAc_oL6Dhy-DGl8,982
+apb_fasta/calculation/protein_groups.py,sha256=FKg7kqvb1Tsisgd-HiJIUlZOTdGq8bufJqZIfNWGQ9o,8178
+apb_fasta/calculation/results.py,sha256=9iOPBPfeekJ04W7jErm0k4uskPMkSumXx_8sd0IdE9s,1474
+apb_fasta/cli.py,sha256=V6VqCzmuogjZj8EaIh53SWRhhkVoIgQqnxWat2eYMAc,5064
+apb_fasta/configuration.py,sha256=blQIb9ywCp00Xr6ypWfQzUQ-x8aF7aegAB3veD0cgF4,706
+apb_fasta/errors.py,sha256=_oLU8leci5hMXN9XJa0rD6HEnvfzv8CYlGn3e50u7P0,168
+apb_fasta/integration.py,sha256=TcH0jtL_Aby2RKZydhLD_-qCXsSqv0wEYYKZ8_xWY6I,10643
+apb_fasta/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apb_fasta-0.1.0.dist-info/licenses/LICENSE,sha256=OPECQFbzDYwcWIzs8D8qw6o9AZsc97_u2fwqbe-ojAM,1070
+apb_fasta-0.1.0.dist-info/WHEEL,sha256=cmC5s21ojypbVslldL7IJq3hjZH-tINy4rziKePFsG0,81
+apb_fasta-0.1.0.dist-info/entry_points.txt,sha256=mPjMZ9aiQIs5fOumE4mwi2Kf-dm8BxDeLg-RFaXyNVQ,50
+apb_fasta-0.1.0.dist-info/METADATA,sha256=McjRlQmEL64BaJuEAU2_Bd0kR7PRTFqURKySPP99knE,3864
+apb_fasta-0.1.0.dist-info/RECORD,,

apb_fasta-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.23
+Root-Is-Purelib: true
+Tag: py3-none-any

apb_fasta-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+apb-fasta = apb_fasta.cli:main
+

apb_fasta-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Witold Wolski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.