biofiles 0.0.1__tar.gz

biofiles-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Tigran Saluev
+
+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.

biofiles-0.0.1/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: biofiles
+Version: 0.0.1
+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>
+License: MIT License
+        
+        Copyright (c) 2023 Tigran Saluev
+        
+        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.
+        
+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
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# biofiles
+
+Pure-Python, zero-dependency collection of bioinformatics-related 
+file readers and writers.
+
+## Installation
+
+```shell
+python -m pip install biofiles
+```
+
+## Usage
+
+Reading FASTA files:
+
+```python
+from biofiles.fasta import FASTAReader
+
+with FASTAReader("sequences.fasta") as r:
+    for seq in r:
+        print(seq.id, len(seq.sequence))
+
+# or
+
+with open("sequences.fasta") as f:
+    r = FASTAReader(f)
+    for seq in r:
+        print(seq.id, len(seq.sequence))
+```
+
+Writing FASTA files:
+
+```python
+from biofiles.fasta import FASTAWriter
+from biofiles.types.sequence import Sequence
+
+seq = Sequence(id="SEQ", description="Important sequence", sequence="GAGAGA")
+
+with FASTAWriter("output.fasta") as w:
+    w.write(seq)
+```
+
+Reading GFF genome annotations:
+
+```python
+from biofiles.gff import GFFReader
+from biofiles.types.feature import Gene
+
+with GFFReader("GCF_009914755.1_T2T-CHM13v2.0_genomic.gff") as r:
+    for feature in r:
+        if isinstance(feature, Gene):
+            print(feature.name, len(feature.exons))
+```
+
+## License 
+
+MIT license, see [License](LICENSE).

biofiles-0.0.1/README.md

@@ -0,0 +1,57 @@
+# biofiles
+
+Pure-Python, zero-dependency collection of bioinformatics-related 
+file readers and writers.
+
+## Installation
+
+```shell
+python -m pip install biofiles
+```
+
+## Usage
+
+Reading FASTA files:
+
+```python
+from biofiles.fasta import FASTAReader
+
+with FASTAReader("sequences.fasta") as r:
+    for seq in r:
+        print(seq.id, len(seq.sequence))
+
+# or
+
+with open("sequences.fasta") as f:
+    r = FASTAReader(f)
+    for seq in r:
+        print(seq.id, len(seq.sequence))
+```
+
+Writing FASTA files:
+
+```python
+from biofiles.fasta import FASTAWriter
+from biofiles.types.sequence import Sequence
+
+seq = Sequence(id="SEQ", description="Important sequence", sequence="GAGAGA")
+
+with FASTAWriter("output.fasta") as w:
+    w.write(seq)
+```
+
+Reading GFF genome annotations:
+
+```python
+from biofiles.gff import GFFReader
+from biofiles.types.feature import Gene
+
+with GFFReader("GCF_009914755.1_T2T-CHM13v2.0_genomic.gff") as r:
+    for feature in r:
+        if isinstance(feature, Gene):
+            print(feature.name, len(feature.exons))
+```
+
+## License 
+
+MIT license, see [License](LICENSE).

biofiles-0.0.1/biofiles/common.py

@@ -0,0 +1,43 @@
+from pathlib import Path
+from types import TracebackType
+from typing import TypeAlias, Literal, TextIO
+
+Strand: TypeAlias = Literal["+", "-"]
+
+
+class Reader:
+    def __init__(self, input_: TextIO | Path | str) -> None:
+        if isinstance(input_, Path | str):
+            input_ = open(input_)
+        self._input = input_
+
+    def __enter__(self):
+        self._input.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._input.__exit__(exc_type, exc_val, exc_tb)
+
+
+class Writer:
+    def __init__(self, output: TextIO | Path | str) -> None:
+        if isinstance(output, Path | str):
+            output = open(output, "w")
+        self._output = output
+
+    def __enter__(self):
+        self._output.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._output.__exit__(exc_type, exc_val, exc_tb)

biofiles-0.0.1/biofiles/fasta.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TextIO, Iterator
+
+from biofiles.common import Reader, Writer
+from biofiles.types.sequence import Sequence
+
+
+__all__ = ["FASTAReader", "FASTAWriter"]
+
+
+@dataclass
+class _SequenceDraft:
+    id: str
+    description: str
+    sequence_parts: list[str] = field(default_factory=list)
+
+    def finalize(self) -> Sequence:
+        return Sequence(
+            id=self.id,
+            description=self.description,
+            sequence="".join(self.sequence_parts),
+        )
+
+
+class FASTAReader(Reader):
+    def __iter__(self) -> Iterator[Sequence]:
+        draft: _SequenceDraft | None = None
+        for line in self._input:
+            line = line.rstrip("\n")
+            if line.startswith(">"):
+                if draft:
+                    yield draft.finalize()
+                line = line.removeprefix(">").lstrip()
+                match line.split(maxsplit=1):
+                    case [id_, desc]:
+                        pass
+                    case [id_]:
+                        desc = ""
+                    case []:
+                        raise ValueError(
+                            f"unexpected line {line!r}, expected a non-empty sequence identifier"
+                        )
+                draft = _SequenceDraft(id=id_, description=desc)
+            elif line:
+                if not draft:
+                    raise ValueError(f"unexpected line {line!r}, expected >")
+                draft.sequence_parts.append(line)
+        if draft:
+            yield draft.finalize()
+
+
+class FASTAWriter(Writer):
+    def __init__(self, output: TextIO | Path | str, width: int = 80) -> None:
+        super().__init__(output)
+        self._width = width
+
+    def write(self, sequence: Sequence) -> None:
+        self._output.write(f">{sequence.id} {sequence.description}\n")
+        sequence_len = len(sequence.sequence)
+        for offset in range(0, sequence_len, self._width):
+            self._output.write(
+                sequence.sequence[offset : min(offset + self._width, sequence_len)]
+            )
+            self._output.write("\n")

biofiles-0.0.1/biofiles/gff.py

@@ -0,0 +1,283 @@
+import sys
+from collections import deque
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterator, cast, TextIO
+
+from biofiles.common import Strand, Reader
+from biofiles.types.feature import Feature, Gene, Exon
+
+__all__ = ["GFFReader"]
+
+
+@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]
+
+    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
+
+
+@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))
+
+    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 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)
+
+
+@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.attributes.get("ID", None):
+            self.by_id[id_] = feature
+
+
+class GFFReader(Reader):
+    def __init__(
+        self, input_: TextIO | Path | str, /, streaming_window: int | None = 1000
+    ):
+        super().__init__(input_)
+        self._streaming_window = streaming_window
+
+    def __iter__(self) -> Iterator[Feature]:
+        for line in self._input:
+            line = line.rstrip("\n")
+            if line.startswith(_VERSION_PREFIX):
+                version = line.removeprefix(_VERSION_PREFIX)
+                if version == "3":
+                    yield from self._read_gff3()
+                    return
+                raise ValueError(f"unsupported version {version!r}")
+            if line.startswith("#"):
+                continue
+            raise ValueError(f"unexpected line {line!r}, expected version")
+
+    def _read_gff3(self) -> Iterator[Feature]:
+        drafts = _FeatureDrafts()
+        idx = 0
+        for line in self._input:
+            if line.startswith("#"):
+                continue
+            line = line.rstrip("\n")
+            parts = line.split("\t", maxsplit=8)
+            if len(parts) != 9:
+                raise ValueError(f"unexpected line {line!r}, expected 9 columns")
+            (
+                sequence_id,
+                source,
+                type_,
+                start_str,
+                end_str,
+                score_str,
+                strand_str,
+                phase_str,
+                attributes_str,
+            ) = parts
+            score = self._parse_score(line, score_str)
+            strand = self._parse_strand(line, strand_str)
+            phase = self._parse_phase(line, phase_str)
+            attributes = self._parse_attributes(line, attributes_str)
+
+            parent_id = attributes.get("Parent", None)
+            # if parent_id is None:
+            #     yield from self._finalize_drafts(drafts)
+            #     drafts = _FeatureDrafts()
+            if parent_id is not None and parent_id not in drafts.by_id:
+                raise ValueError(
+                    f"unexpected line {line!r}, parent ID not among recent feature IDs"
+                )
+
+            draft = _FeatureDraft(
+                idx=idx,
+                sequence_id=sequence_id,
+                source=source,
+                type_=type_,
+                start_original=int(start_str),
+                end_original=int(end_str),
+                score=score,
+                strand=strand,
+                phase=phase,
+                attributes=attributes,
+            )
+            drafts.add(draft)
+            idx += 1
+
+            # yield from self._finalize_drafts(drafts, self._streaming_window)
+
+        yield from self._finalize_drafts(drafts, None)
+
+    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_:
+            case "gene":
+                feature = self._finalize_gene(draft, result)
+            case "exon":
+                feature = self._finalize_exon(draft, result)
+            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) -> Feature:
+        feature = self._finalize_other(draft, result)
+        name = draft.pick_attribute("gene_name", "Name")
+        biotype = draft.pick_attribute("gene_biotype", "biotype")
+        if name is None or biotype is None:
+            return feature
+        return Gene(**feature.__dict__, name=name, biotype=biotype, exons=())
+
+    def _finalize_exon(self, draft: _FeatureDraft, result: _Features) -> Feature:
+        feature = self._finalize_other(draft, result)
+
+        gene = feature.parent
+        while gene and not isinstance(gene, Gene):
+            gene = gene.parent
+
+        if gene is None:
+            return feature
+        exon = Exon(**feature.__dict__, gene=gene)
+        object.__setattr__(gene, "exons", gene.exons + (exon,))
+        return exon
+
+    def _finalize_other(self, draft: _FeatureDraft, result: _Features) -> Feature:
+        parent_id = draft.attributes.get("Parent", None)
+        parent = result.by_id[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,
+            parent=parent,
+            children=(),
+        )
+
+    def _parse_score(self, line: str, score_str: str) -> float | None:
+        if score_str == ".":
+            return None
+        try:
+            return float(score_str)
+        except ValueError as exc:
+            raise ValueError(
+                f"unexpected line {line!r}, score should be a number or '.'"
+            ) from exc
+
+    def _parse_strand(self, line: str, strand_str: str) -> Strand | None:
+        if strand_str in ("-", "+"):
+            return cast(Strand, strand_str)
+        if strand_str == ".":
+            return None
+        raise ValueError(f"unexpected line {line!r}, strand should be '-', '+' or '.'")
+
+    def _parse_phase(self, line: str, phase_str: str) -> int | None:
+        if phase_str == ".":
+            return None
+        try:
+            return int(phase_str)
+        except ValueError as exc:
+            raise ValueError(
+                f"unexpected line {line!r}, phase should be an integer or '.'"
+            ) from exc
+
+    def _parse_attributes(self, line: str, attributes_str: str) -> dict[str, str]:
+        return {
+            k: v
+            for part in attributes_str.strip(";").split(";")
+            for k, v in (part.split("=", 1),)
+        }
+
+
+_VERSION_PREFIX = "##gff-version "
+
+
+if __name__ == "__main__":
+    for path in sys.argv[1:]:
+        with GFFReader(path) as r:
+            total_features = 0
+            annotated_genes = 0
+            annotated_exons = 0
+            parsed_genes = 0
+            parsed_exons = 0
+            for feature in r:
+                total_features += 1
+                annotated_genes += feature.type_ == "gene"
+                annotated_exons += feature.type_ == "exon"
+                parsed_genes += isinstance(feature, Gene)
+                parsed_exons += isinstance(feature, Exon)
+        print(
+            f"{path}: {total_features} features, {parsed_genes} genes parsed out of {annotated_genes}, {parsed_exons} exons parsed out of {annotated_exons}"
+        )

biofiles-0.0.1/biofiles/repeatmasker.py

@@ -0,0 +1,87 @@
+import sys
+from collections import Counter
+from typing import Iterator
+
+from biofiles.common import Reader
+from biofiles.types.repeat import Repeat
+
+
+__all__ = ["RepeatMaskerReader"]
+
+
+class RepeatMaskerReader(Reader):
+    def __iter__(self) -> Iterator[Repeat]:
+        for line in self._input:
+            parts = line.split("\t")
+            if not (14 <= len(parts) <= 15):
+                # Probably some metainfo. No way to tell.
+                continue
+
+            (
+                sw_score_str,
+                div_str,
+                del_str,
+                ins_str,
+                seq_id,
+                seq_start_str,
+                seq_end_str,
+                seq_left_str,
+                strand_str,
+                repeat_name,
+                repeat_class_family,
+                repeat_start_str,
+                repeat_end_str,
+                repeat_left_str,
+                *repeat_id_or_none,
+            ) = parts
+
+            sw_score = int(sw_score_str)
+            div_percent = float(div_str)
+            del_percent = float(del_str)
+            ins_percent = float(ins_str)
+            seq_start = int(seq_start_str)
+            seq_end = int(seq_end_str)
+            seq_left = int(seq_left_str[1:-1])
+            strand = {"+": "+", "C": "-"}[strand_str]
+
+            if "/" in repeat_class_family:
+                repeat_class, repeat_family = repeat_class_family.split("/", 1)
+            else:
+                repeat_class, repeat_family = repeat_class_family, None
+            if strand_str == "C":
+                repeat_start_str, repeat_left_str = (repeat_left_str, repeat_start_str)
+            repeat_start = int(repeat_start_str)
+            repeat_end = int(repeat_end_str)
+            repeat_left = int(repeat_left_str[1:-1])
+            repeat_id = repeat_id_or_none[0] if repeat_id_or_none else None
+            yield Repeat(
+                sw_score=sw_score,
+                divergence_percent=div_percent,
+                insertion_percent=ins_percent,
+                deletion_percent=del_percent,
+                sequence_id=seq_id,
+                sequence_start_original=seq_start,
+                sequence_end_original=seq_end,
+                sequence_start_c=seq_start - 1,
+                sequence_end_c=seq_end,
+                sequence_left=seq_left,
+                strand=strand,
+                repeat_name=repeat_name,
+                repeat_class=repeat_class,
+                repeat_family=repeat_family,
+                repeat_start_original=repeat_start,
+                repeat_end_original=repeat_end,
+                repeat_start_c=repeat_start - 1,
+                repeat_end_c=repeat_end,
+                repeat_left=repeat_left,
+                repeat_id=repeat_id,
+            )
+
+
+if __name__ == "__main__":
+    for path in sys.argv[1:]:
+        with RepeatMaskerReader(path) as r:
+            repeats_per_class = Counter(repeat.repeat_class for repeat in r)
+        print(f"Repeat classes in {path}:")
+        for k, v in repeats_per_class.most_common():
+            print(f"    {k}: {v} repeats")

biofiles-0.0.1/biofiles/types/feature.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+
+from biofiles.common import Strand
+
+
+__all__ = ["Feature", "Gene", "Exon"]
+
+
+@dataclass(frozen=True)
+class Feature:
+    sequence_id: str
+    source: str
+    type_: str
+
+    start_original: int
+    end_original: int
+    # Original, 1-based inclusive values.
+
+    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]
+
+    parent: "GFFFeature | None"
+    children: tuple["Feature", ...]
+
+
+# Custom types for particular kinds of features:
+
+
+@dataclass(frozen=True)
+class Gene(Feature):
+    name: str
+    biotype: str
+    exons: tuple["Exon", ...]
+
+
+@dataclass(frozen=True)
+class Exon(Feature):
+    gene: Gene
+    # TODO transcript, mRNA

biofiles-0.0.1/biofiles/types/repeat.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+
+from biofiles.common import Strand
+
+
+__all__ = ["Repeat"]
+
+
+@dataclass(frozen=True)
+class Repeat:
+    sw_score: int
+    divergence_percent: float
+    deletion_percent: float
+    insertion_percent: float
+    sequence_id: str
+    sequence_start_original: int
+    sequence_end_original: int
+    sequence_start_c: int
+    sequence_end_c: int
+    sequence_left: int
+    strand: Strand
+    repeat_name: str
+    repeat_class: str
+    repeat_family: str | None
+    repeat_start_original: int
+    repeat_end_original: int
+    repeat_start_c: int
+    repeat_end_c: int
+    repeat_left: int
+    repeat_id: str | None

biofiles-0.0.1/biofiles/types/sequence.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+__all__ = ["Sequence"]
+
+
+@dataclass(frozen=True)
+class Sequence:
+    id: str
+    description: str
+    sequence: str

biofiles-0.0.1/biofiles.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: biofiles
+Version: 0.0.1
+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>
+License: MIT License
+        
+        Copyright (c) 2023 Tigran Saluev
+        
+        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.
+        
+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
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# biofiles
+
+Pure-Python, zero-dependency collection of bioinformatics-related 
+file readers and writers.
+
+## Installation
+
+```shell
+python -m pip install biofiles
+```
+
+## Usage
+
+Reading FASTA files:
+
+```python
+from biofiles.fasta import FASTAReader
+
+with FASTAReader("sequences.fasta") as r:
+    for seq in r:
+        print(seq.id, len(seq.sequence))
+
+# or
+
+with open("sequences.fasta") as f:
+    r = FASTAReader(f)
+    for seq in r:
+        print(seq.id, len(seq.sequence))
+```
+
+Writing FASTA files:
+
+```python
+from biofiles.fasta import FASTAWriter
+from biofiles.types.sequence import Sequence
+
+seq = Sequence(id="SEQ", description="Important sequence", sequence="GAGAGA")
+
+with FASTAWriter("output.fasta") as w:
+    w.write(seq)
+```
+
+Reading GFF genome annotations:
+
+```python
+from biofiles.gff import GFFReader
+from biofiles.types.feature import Gene
+
+with GFFReader("GCF_009914755.1_T2T-CHM13v2.0_genomic.gff") as r:
+    for feature in r:
+        if isinstance(feature, Gene):
+            print(feature.name, len(feature.exons))
+```
+
+## License 
+
+MIT license, see [License](LICENSE).

biofiles-0.0.1/biofiles.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+biofiles/__init__.py
+biofiles/common.py
+biofiles/fasta.py
+biofiles/gff.py
+biofiles/repeatmasker.py
+biofiles.egg-info/PKG-INFO
+biofiles.egg-info/SOURCES.txt
+biofiles.egg-info/dependency_links.txt
+biofiles.egg-info/top_level.txt
+biofiles/types/__init__.py
+biofiles/types/feature.py
+biofiles/types/repeat.py
+biofiles/types/sequence.py

biofiles-0.0.1/biofiles.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

biofiles-0.0.1/biofiles.egg-info/top_level.txt

@@ -0,0 +1 @@
+biofiles

biofiles-0.0.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "biofiles"
+version = "0.0.1"
+authors = [
+  { name="Tigran Saluev", email="tigran@saluev.com" },
+]
+maintainers = [
+  { name="Tigran Saluev", email="tigran@saluev.com" },
+]
+description = "Pure-Python, zero-dependency collection of bioinformatics-related file readers and writers"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]

biofiles-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+