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

biofiles/types/feature_v2.py

@@ -1,105 +0,0 @@
-from dataclasses import dataclass, Field, field as dataclass_field
-from typing import dataclass_transform
-
-from biofiles.common import Strand
-
-
-@dataclass
-class Relation:
-    id_field_name: str
-    inverse: "InverseRelation | None" = None
-    class_: type | None = None
-
-
-@dataclass
-class InverseRelation:
-    inverse: Relation
-    one_to_one: bool
-    class_: type | None = None
-
-
-@dataclass_transform()
-class FeatureMetaclass(type):
-    __id_field_name__: str
-    __filter_type__: str
-    __filter_starts__: Relation | None
-    __filter_ends__: Relation | None
-
-    def __new__(
-        cls,
-        name,
-        bases,
-        namespace,
-        type: str | None = None,
-        starts: Field | None = None,
-        ends: Field | None = None,
-    ):
-        result = super().__new__(cls, name, bases, namespace)
-        result.__id_field_name__ = ""
-        for key, value in namespace.items():
-            match value:
-                case Field(metadata={"id_field_name": id_field_name}):
-                    if result.__id_field_name__:
-                        raise TypeError(
-                            f"should specify exactly one id_field() in class {result.__name__}"
-                        )
-                    result.__id_field_name__ = id_field_name
-                case Field(metadata={"relation": Relation() as r}):
-                    r.class_ = result
-                    if key in result.__annotations__:
-                        # TODO handle optionality and forward refs
-                        r.inverse.class_ = result.__annotations__[key]
-                case Field(metadata={"relation": InverseRelation() as r}):
-                    r.class_ = result
-                    # TODO calculating r.inverse.class_ based on type annotation
-
-        if type is not None:
-            result.__filter_type__ = type
-        result.__filter_starts__ = None
-        if starts is not None:
-            result.__filter_starts__ = starts.metadata["relation"]
-        result.__filter_ends__ = None
-        if ends is not None:
-            result.__filter_ends__ = ends.metadata["relation"]
-
-        # TODO generate dataclass-like __init__ method,
-        #      keep all relations optional
-
-        return result
-
-
-class Feature(metaclass=FeatureMetaclass):
-    sequence_id: str
-    source: str
-    type_: str
-
-    start_original: int
-    end_original: int
-    # Original values as they were present in the file (1-based inclusive for .gff and .gtf).
-
-    start_c: int
-    end_c: int
-    # Standardized ("C-style") 0-based values, start inclusive, end exclusive.
-
-    score: float | None
-    strand: Strand | None
-    phase: int | None
-    attributes: dict[str, str]
-
-
-def id_field(source: str) -> Field:
-    return dataclass_field(metadata={"id_field_name": source})
-
-
-def field(source: str) -> Field:
-    return dataclass_field(metadata={"field_name": source})
-
-
-def relation(source: str, *, one_to_one: bool = False) -> tuple[Field, Field]:
-    forward = Relation(id_field_name=source)
-    inverse = InverseRelation(inverse=forward, one_to_one=one_to_one)
-    forward.inverse = inverse
-
-    return dataclass_field(metadata={"relation": forward}), dataclass_field(
-        metadata={"relation": inverse}
-    )

biofiles/utility/feature_v2.py

@@ -1,148 +0,0 @@
-from collections import deque, defaultdict
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Iterator, TextIO
-
-from biofiles.common import Strand, Reader
-from biofiles.types.feature_v2 import Feature, FeatureMetaclass, Relation
-
-
-@dataclass
-class FeatureDraft:
-    idx: int
-    sequence_id: str
-    source: str
-    type_: str
-    start_original: int
-    end_original: int
-    score: float | None
-    strand: Strand | None
-    phase: int | None
-    attributes: dict[str, str]
-
-    class_: type | None = None
-    id: Any = None
-    finalized: Feature | None = None
-
-
-class FeatureTypes:
-    def __init__(self, feature_types: list[FeatureMetaclass]) -> None:
-        for ft in feature_types:
-            if not ft.__id_field_name__:
-                raise ValueError(
-                    f"{ft.__name__} is not proper feature type - has no id_field()"
-                )
-
-        self.ambiguous_type_mapping: dict[str, list[FeatureMetaclass]] = defaultdict(
-            list
-        )
-        self.unique_type_mapping: dict[str, FeatureMetaclass] = {}
-
-        for ft in feature_types:
-            self.ambiguous_type_mapping[ft.__filter_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)
-
-
-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_):
-            draft.class_ = class_
-            draft.id = draft.attributes[class_.__id_field_name__]
-            self.register(draft)
-
-    def register(self, draft: FeatureDraft) -> None:
-        if (key := (draft.class_, draft.id)) in self.by_class_and_id:
-            raise ValueError(
-                f"duplicate feature ID {draft.id} for class {class_.__name__}"
-            )
-        self.by_class_and_id[key] = draft
-
-
-class FeatureReader(Reader):
-
-    def __init__(
-        self, input_: TextIO | Path | str, feature_types: list[FeatureMetaclass]
-    ) -> None:
-        super().__init__(input_)
-        self._feature_types = FeatureTypes(feature_types)
-
-    def __iter__(self) -> Iterator[Feature]:
-        raise NotImplementedError
-
-    def _finalize_drafts(self, fds: FeatureDrafts) -> Iterator[Feature]:
-        self._choose_classes(fds)
-        pass
-
-    def _choose_classes(self, fds: FeatureDrafts) -> Iterator[Feature]:
-        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(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 = fd.attributes[ft.__id_field_name__]
-            fds.register(fd)
-
-    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_field_name]
-        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/RECORD

@@ -1,25 +0,0 @@
-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=b3apOmJNoiy_qQHtyUSnNh0s999B6gyAODyjI7fN15g,6246
-biofiles/gtf.py,sha256=jDQmQ3LB1iNxCCYExScJ6ivQM49TrRO7IPDfUe8VK3Y,2611
-biofiles/repeatmasker.py,sha256=7KObXELCHQ6oBkO8yK6Znrs6MX8sfVuxNSmOMe0Ogfk,3289
-biofiles/dialects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-biofiles/dialects/havana_ensembl.py,sha256=7I97U3UUiFoSOTOR0_orw5eBjCit5FyViosRZqb6AcQ,3379
-biofiles/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-biofiles/types/alignment.py,sha256=Kc0XteLyfj1gNJNLsUgzSKzAAoMobhkJyPFsovaU7dM,1696
-biofiles/types/feature.py,sha256=RKul07UEV1xgWwf8W1C6O2Okb8B0nGZXDaFEezikMsc,1315
-biofiles/types/feature_v2.py,sha256=ozlNyx1sKoo82970TP7a6C_OurCGYDkceg0WdTQA05c,3222
-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=bkUzmT5R4qdJ0YtA4LNU5JYpimD1HmZlHtoSaKzDsUc,4032
-biofiles/utility/feature.py,sha256=O7KV3uI9JtUJWZNrOZ3XfVapwmEmRHm9li4XlpqtlMs,8865
-biofiles/utility/feature_v2.py,sha256=ByhUCkG45d_wra8W5vz-8CMnNYMCHzNglFMMEhMKoWk,5440
-biofiles-0.0.14.dist-info/licenses/LICENSE,sha256=CbR8ssdFyViKj25JAlMjIt1_FbiZ1tAC5t-uwUbxqak,1070
-biofiles-0.0.14.dist-info/METADATA,sha256=DaOVBrpMhK_bKgBEU1uTjjUu6QJS7Zfx8mV4gYL2MLM,3056
-biofiles-0.0.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-biofiles-0.0.14.dist-info/top_level.txt,sha256=laFaFv8hpkI4U-Pgs0yBaAJXN2_CJKl7jb-m3-tGfSc,9
-biofiles-0.0.14.dist-info/RECORD,,