biofiles 0.0.14__py3-none-any.whl → 0.1.2__py3-none-any.whl

biofiles/utility/feature.py

@@ -1,17 +1,16 @@
-from collections import deque
+from collections import deque, defaultdict
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Iterator, TextIO, Type, TypeVar, cast
+from typing import Any, Iterator, TextIO, Type
 
-from biofiles.common import Reader, Strand
+from biofiles.common import Strand, Reader
 from biofiles.types.feature import (
     Feature,
-    Gene,
-    ThreePrimeUTR,
-    Exon,
-    UTR,
-    Transcript,
-    CDS,
+    FeatureMetaclass,
+    Relation,
+    Source,
+    get_composite_field,
+    Dialect,
 )
 
 
@@ -23,225 +22,195 @@ class FeatureDraft:
     type_: str
     start_original: int
     end_original: int
+    start_c: int
+    end_c: int
     score: float | None
     strand: Strand | None
     phase: int | None
-    attributes: dict[str, str]
+    attributes: dict[str, str | list[str]]
 
-    def pick_attribute(self, *keys: str) -> str | None:
-        for key in keys:
-            if (value := self.attributes.get(key, None)) is not None:
-                return value
-        return None
+    class_: Type[Feature] | None = None
+    id: Any = None
+    finalized: Feature | None = None
 
 
-@dataclass
-class FeatureDrafts:
-    drafts: deque[FeatureDraft] = field(default_factory=deque)
-    by_id: dict[str, FeatureDraft] = field(default_factory=dict)
-    # deps: dict[int, deque[int]] = field(default_factory=lambda: defaultdict(deque))
+class FeatureTypes:
+    ambiguous_type_mapping: dict[str, list[FeatureMetaclass]]
+    unique_type_mapping: dict[str, FeatureMetaclass]
 
-    def add(self, draft: FeatureDraft) -> None:
-        self.drafts.append(draft)
-        if id_ := draft.attributes.get("ID", None):
-            self.by_id[id_] = draft
-        # if parent_id := draft.attributes.get("Parent", None):
-        #     parent = self.by_id[parent_id]
-        #     self.deps[parent.idx].append(draft.idx)
+    def __init__(self, feature_types: list[FeatureMetaclass]) -> None:
+        self.ambiguous_type_mapping = defaultdict(list)
+        self.unique_type_mapping = {}
 
-    # def remove_first_n(self, n: int) -> None:
-    #     for _ in range(n):
-    #         draft = self.drafts.popleft()
-    #         if id_ := draft.attributes.get("ID", None):
-    #             del self.by_id[id_]
-    #         self.deps.pop(draft.idx, None)
+        for ft in feature_types:
+            for type in ft.__filter_type__:
+                self.ambiguous_type_mapping[type].append(ft)
 
+        for key, fts in [*self.ambiguous_type_mapping.items()]:
+            if len(fts) == 1:
+                self.unique_type_mapping[key] = fts[0]
+                del self.ambiguous_type_mapping[key]
+                continue
+            self.ambiguous_type_mapping[key] = _sort_by_filter_specificity(fts)
 
-@dataclass
-class Features:
-    features: list[Feature] = field(default_factory=list)
-    by_id: dict[str, Feature] = field(default_factory=dict)
 
-    def add(self, feature: Feature):
-        self.features.append(feature)
-        if id_ := feature.id:
-            self.by_id[id_] = feature
+def _sort_by_filter_specificity(fts: list[FeatureMetaclass]) -> list[FeatureMetaclass]:
+    """Sort feature classes by their filter specificity, most specific -> least specific."""
+    key = lambda ft: bool(ft.__filter_starts__) + bool(ft.__filter_ends__)
+    return sorted(fts, key=key, reverse=True)
+
+
+@dataclass
+class FeatureDrafts:
+    feature_types: FeatureTypes
+    drafts: list[FeatureDraft] = field(default_factory=deque)
+    by_class_and_id: dict[tuple[type, Any], FeatureDraft] = field(default_factory=dict)
 
+    def add(self, draft: FeatureDraft) -> None:
+        self.drafts.append(draft)
+        if class_ := self.feature_types.unique_type_mapping.get(draft.type_.lower()):
+            draft.class_ = class_
+            draft.id = get_composite_field(
+                draft.attributes, class_.__id_attribute_source__
+            )
+            self.register(draft)
+
+    def register(self, draft: FeatureDraft) -> None:
+        if draft.id is None:
+            return
+        if (key := (draft.class_, draft.id)) in self.by_class_and_id:
+            raise ValueError(
+                f"duplicate feature ID {draft.id} for class {draft.class_.__name__}"
+            )
+        self.by_class_and_id[key] = draft
+
+
+class RawFeatureReader(Reader):
+    def __init__(self, input_: TextIO | Path) -> None:
+        super().__init__(input_)
 
-FeatureT = TypeVar("FeatureT", bound=Feature)
-GeneT = TypeVar("GeneT", bound=Gene)
-TranscriptT = TypeVar("TranscriptT", bound=Transcript)
-UTRT = TypeVar("UTRT", bound=UTR)
+    def __iter__(self) -> Iterator[FeatureDraft]:
+        raise NotImplementedError
 
 
 class FeatureReader(Reader):
-    def __init__(
-        self, input_: TextIO | Path | str, /, streaming_window: int | None = 1000
-    ):
+
+    def __init__(self, input_: TextIO | Path | str, dialect: Dialect) -> None:
         super().__init__(input_)
-        self._streaming_window = streaming_window
+        self._feature_types = FeatureTypes(dialect.feature_types)
+        self._raw_reader = self._make_raw_feature_reader()
 
-    def __iter__(self) -> Iterator[Feature]:
+    def _make_raw_feature_reader(self) -> RawFeatureReader:
         raise NotImplementedError
 
-    def _finalize_drafts(
-        self, drafts: FeatureDrafts, w: int | None
-    ) -> Iterator[Feature]:
-        # TODO streaming version!
-        #      code below is already tracking
-        # if not drafts.drafts:
-        #     return
-        # if w is not None and len(drafts.drafts) <= w:
-        #     return
-        #
-        # end_idx = drafts.drafts[-w].idx if w is not None else drafts.drafts[-1].idx
-        #
-        # i = 0
-        # while i < len(drafts.drafts) and (
-        #     not drafts.deps[drafts.drafts[i].idx]
-        #     or drafts.deps[drafts.drafts[i].idx][-1] <= end_idx
-        # ):
-        #     i += 1
-        #
-        # print(f"FINALIZING {i} DRAFTS OUT OF {len(drafts.drafts)}")
-        #
-        # result = _Features()
-        # for j in range(i):
-        #     draft = drafts.drafts[j]
-        #     feature = self._finalize_draft(draft, result)
-        #     result.add(feature)
-        # drafts.remove_first_n(i)
-        # yield from result.features
-
-        result = Features()
-        for draft in drafts.drafts:
-            feature = self._finalize_draft(draft, result)
-            result.add(feature)
-        yield from result.features
-
-    def _finalize_draft(self, draft: FeatureDraft, result: Features) -> Feature:
-        match draft.type_.lower():
-            case "gene" | "ncrna_gene":
-                feature = self._finalize_gene(draft, result, Gene)
-            case "transcript" | "mrna" | "lnc_rna":
-                feature = self._finalize_transcript(draft, result, Transcript)
-            case "exon":
-                feature = self._finalize_exon(draft, result)
-            case "cds":
-                feature = self._finalize_cds(draft, result)
-            case "three_prime_utr":
-                feature = self._finalize_utr(draft, result, ThreePrimeUTR)
-            case "utr":
-                feature = self._finalize_utr(draft, result, UTR)
-            case _:
-                feature = self._finalize_other(draft, result)
-        if feature.parent:
-            new_children = feature.parent.children + (feature,)
-            object.__setattr__(feature.parent, "children", new_children)
-        return feature
-
-    def _finalize_gene(
-        self, draft: FeatureDraft, result: Features, type_: Type[GeneT]
-    ) -> Feature:
-        feature = self._finalize_other(draft, result)
-        name = draft.pick_attribute("gene_name", "Name")
-        biotype = draft.pick_attribute("gene_biotype", "biotype", "gene_type")
-        if name is None or biotype is None:
-            return feature
-        return type_(**feature.__dict__, name=name, biotype=biotype, transcripts=())
-
-    def _finalize_transcript(
-        self, draft: FeatureDraft, result: Features, type_: Type[TranscriptT]
-    ) -> Feature:
-        feature = self._finalize_other(draft, result)
-        if not (gene := self._find_ancestor_of_type(feature, Gene)):
-            return feature
-        transcript = type_(**feature.__dict__, gene=gene, exons=())
-        object.__setattr__(gene, "transcripts", gene.transcripts + (transcript,))
-        return transcript
-
-    def _finalize_exon(self, draft: FeatureDraft, result: Features) -> Feature:
-        feature = self._finalize_other(draft, result)
-        if not (transcript := self._find_ancestor_of_type(feature, Transcript)):
-            return feature
-        exon = Exon(
-            **feature.__dict__, gene=transcript.gene, transcript=transcript, cds=None
-        )
-        object.__setattr__(transcript, "exons", transcript.exons + (exon,))
-        return exon
-
-    def _finalize_cds(self, draft: FeatureDraft, result: Features) -> Feature:
-        feature = self._finalize_other(draft, result)
-        if not (exon := self._find_ancestor_of_type(feature, Exon)):
-            return feature
-        cds = CDS(
-            **feature.__dict__,
-            exon=exon,
-            transcript=exon.transcript,
-            gene=exon.transcript.gene,
-        )
-        object.__setattr__(exon, "cds", cds)
-        return cds
-
-    def _finalize_utr(
-        self, draft: FeatureDraft, result: Features, type_: Type[UTRT]
-    ) -> Feature:
-        feature = self._finalize_other(draft, result)
-        if not (transcript := self._find_ancestor_of_type(feature, Transcript)):
-            return feature
-        return type_(**feature.__dict__, gene=transcript.gene, transcript=transcript)
-
-    def _find_ancestor_of_type(
-        self, feature: Feature, t: Type[FeatureT]
-    ) -> FeatureT | None:
-        ancestor = feature.parent
-        while ancestor and not isinstance(ancestor, t):
-            ancestor = ancestor.parent
-        return cast(FeatureT | None, ancestor)
-
-    def _finalize_other(self, draft: FeatureDraft, result: Features) -> Feature:
-        parent_id = self._extract_parent_id(draft)
-        parent = result.by_id.get(parent_id) if parent_id is not None else None
-
-        return Feature(
-            sequence_id=draft.sequence_id,
-            source=draft.source,
-            type_=draft.type_,
-            start_original=draft.start_original,
-            end_original=draft.end_original,
-            start_c=draft.start_original - 1,
-            end_c=draft.end_original,
-            score=draft.score,
-            strand=draft.strand,
-            phase=draft.phase,
-            attributes=draft.attributes,
-            id=self._extract_id(draft),
-            parent=parent,
-            children=(),
-        )
-
-    def _extract_id(self, draft: FeatureDraft) -> str | None:
-        if (id_ := draft.attributes.get("ID")) is not None:
-            return id_
-        if draft.type_ == "gene" and (id_ := draft.attributes.get("gene_id")):
-            return id_
-        if draft.type_ == "transcript" and (
-            id_ := draft.attributes.get("transcript_id")
-        ):
-            return id_
-        if draft.type_ == "exon" and (id_ := draft.attributes.get("exon_id")):
-            return id_
-        return None
-
-    def _extract_parent_id(self, draft: FeatureDraft) -> str | None:
-        if (id_ := draft.attributes.get("Parent")) is not None:
-            return id_
-        if draft.type_ == "transcript" and (id_ := draft.attributes.get("gene_id")):
-            return id_
-        if draft.type_ in ("exon", "UTR", "three_prime_UTR", "five_prime_UTR") and (
-            id_ := draft.attributes.get("transcript_id")
-        ):
-            return id_
-        if draft.type_.lower() == "cds" and (id_ := draft.attributes.get("exon_id")):
-            return id_
-        return None
+    def __iter__(self) -> Iterator[Feature]:
+        fds = FeatureDrafts(self._feature_types)
+        for draft in self._raw_reader:
+            fds.add(draft)
+        yield from self._finalize_drafts(fds)
+
+    def _finalize_drafts(self, fds: FeatureDrafts) -> Iterator[Feature]:
+        self._choose_classes(fds)
+        self._instantiate_objects(fds)
+        self._fill_relations(fds)
+        for fd in fds.drafts:
+            yield fd.finalized
+
+    def _choose_classes(self, fds: FeatureDrafts) -> None:
+        for fd in fds.drafts:
+            if fd.class_:
+                continue
+
+            fts = self._feature_types.ambiguous_type_mapping[fd.type_]
+            matching_fts = [ft for ft in fts if self._check_filters(fds, fd, ft)]
+            if not matching_fts:
+                raise ValueError(
+                    f"no matching classes (out of {len(fts)}) for "
+                    f"feature with type {fd.type_!r}, attributes {fd.attributes!r}"
+                )
+            if len(matching_fts) > 1:
+                raise ValueError(
+                    f"too many matching classes ({len(matching_fts)}) for "
+                    f"feature with type {fd.type_!r}, attributes {fd.attributes!r}"
+                )
+            ft = matching_fts[0]
+            fd.class_ = ft
+            fd.id = get_composite_field(fd.attributes, ft.__id_attribute_source__)
+            fds.register(fd)
+
+    def _instantiate_objects(self, fds: FeatureDrafts) -> None:
+        for fd in fds.drafts:
+            fd.finalized = fd.class_(
+                sequence_id=fd.sequence_id,
+                source=fd.source,
+                type_=fd.type_,
+                start_original=fd.start_original,
+                end_original=fd.end_original,
+                start_c=fd.start_c,
+                end_c=fd.end_c,
+                score=fd.score,
+                strand=fd.strand,
+                phase=fd.phase,
+                attributes=fd.attributes,
+            )
+
+    def _fill_relations(self, fds: FeatureDrafts) -> None:
+        for fd in fds.drafts:
+            for relation in fd.class_.__relations__:
+                related_id = get_composite_field(
+                    fd.attributes, relation.id_attribute_source
+                )
+                related_class = relation.inverse.class_
+                try:
+                    related_fd = fds.by_class_and_id[related_class, related_id]
+                except KeyError as exc:
+                    raise ValueError(
+                        f"can't find related {related_class.__name__} {related_id} for {fd.finalized}"
+                    ) from exc
+                setattr(fd.finalized, relation.attribute_name, related_fd.finalized)
+                if relation.inverse.attribute_name is None:
+                    pass
+                elif relation.inverse.one_to_one:
+                    setattr(
+                        related_fd.finalized,
+                        relation.inverse.attribute_name,
+                        fd.finalized,
+                    )
+                else:
+                    getattr(
+                        related_fd.finalized, relation.inverse.attribute_name
+                    ).append(fd.finalized)
+
+    def _check_filters(
+        self, fds: FeatureDrafts, fd: FeatureDraft, ft: FeatureMetaclass
+    ) -> bool:
+        if r := ft.__filter_starts__:
+            related_fd = self._get_related_feature_draft(fds, fd, r)
+            if fd.strand != related_fd.strand:
+                return False
+            if fd.strand == "+" and fd.start_original != related_fd.start_original:
+                return False
+            if fd.strand == "-" and fd.end_original != related_fd.end_original:
+                return False
+        if r := ft.__filter_ends__:
+            related_fd = self._get_related_feature_draft(fds, fd, r)
+            if fd.strand != related_fd.strand:
+                return False
+            if fd.strand == "+" and fd.end_original != related_fd.end_original:
+                return False
+            if fd.strand == "-" and fd.start_original != related_fd.start_original:
+                return False
+        return True
+
+    def _get_related_feature_draft(
+        self, fds: FeatureDrafts, fd: FeatureDraft, r: Relation
+    ) -> FeatureDraft:
+        related_class = r.inverse.class_
+        related_id = fd.attributes[r.id_attribute_source]
+        try:
+            return fds.by_class_and_id[related_class, related_id]
+        except KeyError as exc:
+            raise ValueError(
+                f"can't find related {related_class.__name__} for "
+                f"{fd.class_.__name__} with attributes {fd.attributes!r}"
+            ) from exc

{biofiles-0.0.14.dist-info → biofiles-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: biofiles
-Version: 0.0.14
+Version: 0.1.2
 Summary: Pure-Python, zero-dependency collection of bioinformatics-related file readers and writers
 Author-email: Tigran Saluev <tigran@saluev.com>
 Maintainer-email: Tigran Saluev <tigran@saluev.com>
@@ -30,7 +30,6 @@ Project-URL: Homepage, https://github.com/Saluev/biofiles
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
@@ -84,14 +83,20 @@ Reading GFF genome annotations:
 
 ```python
 from biofiles.gff import GFFReader
-from biofiles.types.feature import Gene
+from biofiles.dialects.gencode import GENCODE_DIALECT
+from biofiles.dialects.genomic_base import Gene
 
-with GFFReader("GCF_009914755.1_T2T-CHM13v2.0_genomic.gff") as r:
+with GFFReader("GCF_009914755.1_T2T-CHM13v2.0_genomic.gff", dialect=GENCODE_DIALECT) as r:
     for feature in r:
         if isinstance(feature, Gene):
             print(feature.name, len(feature.exons))
 ```
 
+Currently three dialects are supported:
+* `biofiles.dialects.gencode.GENCODE_DIALECT` for GENCODE genome annotation;
+* `biofiles.dialects.refseq.REFSEQ_DIALECT` for RefSeq genome annotation;
+* `biofiles.dialects.stringtie.STRINGTIE_DIALECT` for StringTie output files.
+
 ## License 
 
 MIT license, see [License](LICENSE).

biofiles-0.1.2.dist-info/RECORD

@@ -0,0 +1,27 @@
+biofiles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biofiles/bam.py,sha256=w32LLOAuKWdGF7joTSrB4HYXCdfvvijZW44jizG36R8,6771
+biofiles/common.py,sha256=Yi0i85FpD2wR3vqL645LTUAE6TybGDxxZQsUmEGHqu4,1126
+biofiles/fai.py,sha256=gG2oDmaU7PIIYYBc8LiudaeKdo-6WIdwsMDIM7qi098,678
+biofiles/fasta.py,sha256=ctIt5I_fcZx-xQN921zpmlZS7e9_ICf-3_i6mTs5qbs,2135
+biofiles/gff.py,sha256=X1VK6QTPq0_w5jR2zwyjHcs9SE339yh3QGpwF5hg-T8,6357
+biofiles/gtf.py,sha256=wCtHzLTCqR-oAGPtiRDJ4GvyS_Z5FzmLLzw8lgTj5Ig,3490
+biofiles/repeatmasker.py,sha256=7KObXELCHQ6oBkO8yK6Znrs6MX8sfVuxNSmOMe0Ogfk,3289
+biofiles/dialects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biofiles/dialects/detector.py,sha256=OP42NhQf3s609fmDaRRFEMawgf0VMZdeAfkbK6IL4yM,2461
+biofiles/dialects/gencode.py,sha256=oxTKmcipalgdhy_eNhCqRd5Rdchz8Pn1SXlQHlg6YuM,7730
+biofiles/dialects/genomic_base.py,sha256=mw46OgVW1TjsZ-RnH_Nnfs2bJIqJiaPV8d-MaAbjPSQ,362
+biofiles/dialects/refseq.py,sha256=ZjTpm-AOLs2jQRU9G4V11uiAAtrJop1OF-HyDIr-IrI,4217
+biofiles/dialects/stringtie.py,sha256=kuQ6IWRo7c4xkNjN-4jjYy3_dRUPorMaffYvDYvQDD8,834
+biofiles/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biofiles/types/alignment.py,sha256=Kc0XteLyfj1gNJNLsUgzSKzAAoMobhkJyPFsovaU7dM,1696
+biofiles/types/feature.py,sha256=r4zJlwKcO8LSy9EfRsLfrDcLyVLMH1uGGX1-ZNnQLOc,11580
+biofiles/types/repeat.py,sha256=63SqzAwEGIDIGP9pxC85RUdwXbbSm0S5WNL3lSiWlmc,641
+biofiles/types/sequence.py,sha256=XeJ3wgi8AwRaVYVKmf41y5mOmWQfdsS8ysaRLZWbNoQ,254
+biofiles/utility/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biofiles/utility/cli.py,sha256=i2kYpPFnpTYdbd_6T-U9-egitKhDGQVDbw5gme4Kelg,4074
+biofiles/utility/feature.py,sha256=bHUOfYir_Dfk_DEBrlO1GXvkJKDRkpj2YJfSl4w698s,7931
+biofiles-0.1.2.dist-info/licenses/LICENSE,sha256=CbR8ssdFyViKj25JAlMjIt1_FbiZ1tAC5t-uwUbxqak,1070
+biofiles-0.1.2.dist-info/METADATA,sha256=FecyQR9RV1AgLstbkbARgEbSqzsaP2LwMY03f7gZqiA,3361
+biofiles-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+biofiles-0.1.2.dist-info/top_level.txt,sha256=laFaFv8hpkI4U-Pgs0yBaAJXN2_CJKl7jb-m3-tGfSc,9
+biofiles-0.1.2.dist-info/RECORD,,

biofiles/dialects/havana_ensembl.py

@@ -1,101 +0,0 @@
-"""Feature dialect for HAVANA+Ensembl .gtf files (e.g. T2T annotation)."""
-
-from enum import StrEnum
-
-from biofiles.types.feature_v2 import Feature, id_field, field, relation
-
-
-class GeneType(StrEnum):
-    LNC_RNA = "lncRNA"
-    PROTEIN_CODING = "protein_coding"
-
-
-class TranscriptType(StrEnum):
-    LNC_RNA = "lncRNA"
-    PROTEIN_CODING = "protein_coding"
-
-
-transcript_gene, gene_transcripts = relation(source="gene_id")
-exon_transcript, transcript_exons = relation(source="transcript_id")
-exon_gene, _ = relation(source="gene_id")
-cds_exon, exon_cds = relation(source="exon_id", one_to_one=True)
-utr_transcript, transcript_utrs = relation(source="transcript_id")
-utr_gene, _ = relation(source="gene_id")
-five_prime_utr_transcript, transcript_five_prime_utr = relation(
-    source="transcript_id", one_to_one=True
-)
-five_prime_utr_gene, _ = relation(source="gene_id")
-three_prime_utr_transcript, transcript_three_prime_utr = relation(
-    source="transcript_id", one_to_one=True
-)
-three_prime_utr_gene, _ = relation(source="gene_id")
-start_codon_transcript, transcript_start_codon = relation(
-    source="transcript_id", one_to_one=True
-)
-start_codon_exon, _ = relation(source="exon_id", one_to_one=True)
-stop_codon_transcript, transcript_stop_codon = relation(
-    source="transcript_id", one_to_one=True
-)
-stop_codon_exon, _ = relation(source="exon_id", one_to_one=True)
-
-
-class Gene(Feature, type="gene"):
-    id: str = id_field(source="gene_id")
-    type: GeneType = field(source="gene_type")
-    name: str = field(source="gene_name")
-    transcripts: list["Transcript"] = gene_transcripts
-
-
-class Transcript(Feature, type="transcript"):
-    id: str = id_field(source="transcript_id")
-    type: TranscriptType = field(source="transcript_type")
-    name: str = field(source="transcript_name")
-    gene: Gene = transcript_gene
-    exons: list["Exon"] = transcript_exons
-    five_prime_utr: "FivePrimeUTR | None" = transcript_five_prime_utr
-    three_prime_utr: "ThreePrimeUTR | None" = transcript_three_prime_utr
-    start_codon: "StartCodon | None" = transcript_start_codon
-    stop_codon: "StopCodon | None" = transcript_stop_codon
-
-
-class Exon(Feature, type="exon"):
-    id: str = id_field(source="exon_id")
-    number: int = field(source="exon_number")
-    transcript: Transcript = exon_transcript
-    gene: Gene = exon_gene
-    cds: "CDS | None" = exon_cds
-
-
-class CDS(Feature, type="cds"):
-    id: str = id_field(source="exon_id")
-    exon: Exon = cds_exon
-
-
-class UTR(Feature, type="utr"):
-    id: str = id_field(source="transcript_id")
-    transcript: Transcript = utr_transcript
-    gene: Gene = utr_gene
-
-
-class FivePrimeUTR(UTR, starts=five_prime_utr_transcript):
-    id: str = id_field(source="transcript_id")
-    transcript: Transcript = five_prime_utr_transcript
-    gene: Gene = five_prime_utr_gene
-
-
-class ThreePrimeUTR(UTR, ends=three_prime_utr_transcript):
-    id: str = id_field(source="transcript_id")
-    transcript: Transcript = three_prime_utr_transcript
-    gene: Gene = three_prime_utr_gene
-
-
-class StartCodon(Feature, type="start_codon"):
-    id: str = id_field(source="transcript_id")
-    transcript: Transcript = start_codon_transcript
-    exon: Exon = start_codon_exon
-
-
-class StopCodon(Feature, type="stop_codon"):
-    id: str = id_field(source="transcript_id")
-    transcript: Transcript = stop_codon_transcript
-    exon: Exon = stop_codon_exon