fastasma 0.1.1__py3-none-any.whl

fastasma/Annotators.py

@@ -0,0 +1,276 @@
+import sqlite3
+from fastasma.Types import Sequence, SequenceSource
+from typing import Iterator, Callable, Optional
+
+class DropAnnotations:
+    def __init__(self, source: SequenceSource):
+        self._source = source
+
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        for seq in self._source:
+            yield Sequence(header=seq.header, sequence=seq.sequence)
+
+class DropAnnotationKeys:
+    def __init__(self, source: SequenceSource, keys_to_remove: list[str]):
+        self._source = source
+        self._keys_to_remove = set(keys_to_remove)
+
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        for seq in self._source:
+            new_annotation = {
+                key: value 
+                for key, value in seq.annotation.items() 
+                if key not in self._keys_to_remove
+            }
+            yield Sequence(header=seq.header, sequence=seq.sequence, annotation=new_annotation)
+
+class AddTaxonomyFromFilename:
+    def __init__(self, source: SequenceSource, key: Callable = lambda x: x, header_formatter: Callable = None):
+        self._source = source
+        self._fun = key
+        self._header_formatter = header_formatter or self.default_header_formatter
+
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def default_header_formatter(self, seq: Sequence, taxon: str) -> str:
+        return f"{seq.header} taxon={taxon}"
+
+    def yield_sequence(self) -> Iterator[Sequence]:
+        for seq in self._source:
+            taxon = self._fun(getattr(self._source, "filepath", None))
+            new_header = self._header_formatter(seq, taxon)
+            yield Sequence(new_header, seq.sequence)
+
+class AddTaxidFromName:
+    def __init__(self, source: SequenceSource, taxonomy_db: str, organims_field: str = "organism"):
+        """Adds taxid information to Sequence objects from a taxonomy database.
+        taxonomy_db schema (SQLite):
+            CREATE TABLE names (taxid INTEGER, name TEXT, unique_name TEXT, name_class TEXT);
+        Correspondence between sequence headers and taxids: names.name (scientific name) -> names.taxid
+        """
+        self._source = source
+        self._taxonomy_db = taxonomy_db
+        self._organism_field = organims_field
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        import sqlite3
+
+        conn = sqlite3.connect(self._taxonomy_db)
+        cursor = conn.cursor()
+
+        # Loads all names and taxids into a dictionary for quick lookup
+        cursor.execute("SELECT name, taxid FROM names")
+        taxid_dict = {name: taxid for name, taxid in cursor.fetchall()}
+
+        for seq in self._source:
+            organism_name = seq.annotation.get(self._organism_field, None)
+            taxid = taxid_dict.get(organism_name)
+            new_annotation = dict(seq.annotation)
+            new_annotation["taxid"] = taxid
+            yield Sequence(header=seq.header, sequence=seq.sequence, annotation=new_annotation)
+
+        conn.close()
+
+class AddNameFromTaxid:
+    def __init__(self, source: SequenceSource, taxonomy_db: str, taxid_field: str = "taxid", name_field: str = "organism"):
+        """Converts taxid information in Sequence objects to scientific names using a taxonomy database.
+        taxonomy_db schema (SQLite):
+            CREATE TABLE names (taxid INTEGER, name TEXT, unique_name TEXT, name_class TEXT);
+        Correspondence between taxids and scientific names: names.taxid -> names.name (scientific name)        
+        """
+        self._source = source
+        self._taxonomy_db = taxonomy_db
+        self._taxid_field = taxid_field
+        self._name_field = name_field
+
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        import sqlite3
+
+        conn = sqlite3.connect(self._taxonomy_db)
+        cursor = conn.cursor()
+
+        # Loads all taxids and names into a dictionary for quick lookup
+        cursor.execute("SELECT taxid, name FROM names")
+        name_dict = {taxid: name for taxid, name in cursor.fetchall()}
+
+        for seq in self._source:
+            taxid = seq.annotation.get(self._taxid_field, None)
+            name = name_dict.get(int(taxid))
+            new_annotation = dict(seq.annotation)
+            new_annotation[self._name_field] = name
+            yield Sequence(header=seq.header, sequence=seq.sequence, annotation=new_annotation)
+
+        conn.close()
+
+class AddTaxonomicRankFromTaxid:
+    def __init__(
+        self, 
+        source: SequenceSource, 
+        taxonomy_db: str, 
+        taxid_field: str = "taxid", 
+        rank: str = "species"
+    ):
+        """Adds taxonomic rank information to Sequence objects from a taxonomy database.
+        
+        Args:
+            source: Source that yields Sequence objects
+            taxonomy_db: Path to SQLite taxonomy database
+            taxid_field: Name of the field containing the taxid in annotations
+            rank: Taxonomic rank to retrieve (e.g., 'species', 'genus', 'family')
+        
+        Database schema (SQLite):
+            CREATE TABLE nodes (taxid INTEGER PRIMARY KEY, parent INTEGER, rank TEXT);
+            CREATE TABLE names (taxid INTEGER, name TEXT, unique_name TEXT, name_class TEXT);
+        """
+        self._source = source
+        self._taxonomy_db = taxonomy_db
+        self._taxid_field = taxid_field
+        self._rank = rank
+        
+        # Connection will be opened lazily
+        self._conn: Optional[sqlite3.Connection] = None
+        self._nodes_dict: dict[int, tuple[Optional[int], str]] = {}
+        self._names_cache: dict[int, str] = {}
+        
+    def _ensure_connection(self):
+        """Lazy initialization of database connection and data loading."""
+        if self._conn is not None:
+            return
+            
+        self._conn = sqlite3.connect(self._taxonomy_db)
+        self._cursor = self._conn.cursor()
+        
+        # Preload nodes into memory for fast traversal
+        self._cursor.execute("SELECT taxid, parent, rank FROM nodes")
+        self._nodes_dict = {
+            taxid: (parent, rank) 
+            for taxid, parent, rank in self._cursor.fetchall()
+        }
+        
+        # Preload scientific names into memory
+        self._cursor.execute(
+            "SELECT taxid, name FROM names WHERE name_class = 'scientific name'"
+        )
+        self._names_cache = {
+            taxid: name 
+            for taxid, name in self._cursor.fetchall()
+        }
+    
+    def _get_rank_name(self, taxid: int) -> Optional[str]:
+        """Traverse taxonomy tree to find the requested rank and return its name.
+        
+        Args:
+            taxid: Starting taxonomic ID
+            
+        Returns:
+            Scientific name of the taxon at the requested rank, or None if not found
+        """
+        current_taxid: Optional[int] = taxid
+        max_iterations = 1000  # Prevent infinite loops in corrupted data
+        iterations = 0
+        
+        while current_taxid is not None and iterations < max_iterations:
+            node_info = self._nodes_dict.get(current_taxid)
+            if node_info is None:
+                # Taxid not found in database
+                break
+                
+            parent, rank = node_info
+            
+            if rank == self._rank:
+                # Found the requested rank, return the scientific name
+                return self._names_cache.get(current_taxid)
+            
+            current_taxid = parent
+            iterations += 1
+            
+        return None
+    
+    def __enter__(self):
+        """Context manager entry."""
+        self._ensure_connection()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - ensures connection is closed."""
+        self.close()
+        return False
+    
+    def close(self):
+        """Close database connection."""
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+    
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        """Yield sequences with added taxonomic rank information.
+        
+        Yields:
+            Sequence objects with the taxonomic rank added to annotations
+        """
+        self._ensure_connection()
+        
+        try:
+            for seq in self._source:
+                rank_name = None
+                
+                # Get taxid from annotations
+                taxid_str = seq.annotation.get(self._taxid_field) if seq.annotation else None
+                
+                if taxid_str is not None:
+                    try:
+                        taxid = int(taxid_str)
+                        rank_name = self._get_rank_name(taxid)
+                    except (ValueError, TypeError):
+                        # Invalid taxid format, leave rank_name as None
+                        pass
+                
+                # Create new annotation dict with the rank added
+                new_annotation = dict(seq.annotation) if seq.annotation else {}
+                new_annotation[self._rank] = rank_name
+                
+                yield Sequence(
+                    header=seq.header, 
+                    sequence=seq.sequence, 
+                    annotation=new_annotation
+                )
+        finally:
+            # Ensure connection is closed when iteration completes or fails
+            self.close()
+
+class AddAnnotationToHeader:
+    def __init__(self, source: SequenceSource, annotation_key: str, separator: str = "_", position: str = "suffix"):
+        self._source = source
+        self._annotation_key = annotation_key
+        self._separator = separator
+        self._position = position
+
+    def __iter__(self):
+        return self.yield_sequence()
+
+    def yield_sequence(self) -> Iterator[Sequence]:
+        for seq in self._source:
+            value = seq.annotation.get(self._annotation_key) if seq.annotation else None
+            if value is not None:
+                if self._position == "prefix":
+                    new_header = f"{value}{self._separator}{seq.header}"
+                else:
+                    new_header = f"{seq.header}{self._separator}{value}"
+            else:
+                new_header = seq.header
+            yield Sequence(header=new_header, sequence=seq.sequence, annotation=seq.annotation)

fastasma/Importers.py

@@ -0,0 +1,128 @@
+import os
+import re
+from typing import List, Iterator
+from fastasma.Types import Sequence
+
+
+class ImportFasta:
+    def __init__(self, filepath: str):
+        self.filepath = filepath
+        self._valid_seq = re.compile("^[A-Za-z*-]+$")
+
+    def __iter__(self):
+        return self.yield_sequence()
+
+    def _is_header(self, text: str)-> bool:
+        return bool(text) and text[0] == ">"
+    
+    def _parse_header(self, line: str)-> str:
+        # Returns the name of the sequence without the annotations
+        if not line.startswith(">"):
+            raise ValueError(f"Invalid FASTA header: {line}")
+        return line[1:].split()[0]
+    
+    def _parse_sequence(self, lines: List[str])-> str:
+        seq = ''.join(lines).replace(" ", "").replace("\n", "")
+        if not self._valid_seq.match(seq):
+            raise ValueError(f"Invalid FASTA sequence: {seq}")
+        return seq
+    
+    def _parse_annotation(self, line: str) -> dict:
+        # Parses annotations in the header line formatted as [key=value] or key=value
+        # considering that brackets may contain spaces
+        annotations = {}
+        parts = re.findall(r'\[.*?\]|[^ \[\]]+', line[1:])
+        for part in parts[1:]:  # Skip the first part which is the header
+            part = part.strip("[]")  # Remove brackets if present
+            if '=' in part:
+                key, value = part.split('=', 1)
+                annotations[key] = value
+        return annotations
+
+    def _yield_sequence(self, filepath: str) -> Iterator[Sequence]:
+        header: str | None = None
+        seq_lines: list[str] = []
+        annotations: dict = {}
+        with open(filepath, "r") as file:
+            for raw in file:
+                line = raw.strip()
+                if not line:
+                    continue
+                if self._is_header(line):
+                    if header is not None:
+                        yield Sequence(
+                            header = header, 
+                            sequence = self._parse_sequence(seq_lines),
+                            annotation=annotations
+                        )
+                    header = self._parse_header(line)
+                    annotations = self._parse_annotation(line)
+                    seq_lines = []
+                else:
+                    seq_lines.append(line)
+            if header is not None:
+                yield Sequence(
+                    header = header,
+                    sequence = self._parse_sequence(seq_lines),
+                    annotation=annotations
+                )
+
+    def yield_sequence(self) -> Iterator[Sequence]:
+        for seq in self._yield_sequence(self.filepath):
+            yield seq
+
+class ImportFastas:
+    def __init__(self, filepaths: List[str] | None = None, directory: str | None = None):
+        if filepaths is None and directory is None:
+            raise ValueError("Either filepaths or directory must be provided.")
+        if directory is not None:
+            filepaths = [
+                os.path.join(directory, f)
+                for f in os.listdir(directory)
+                if f.endswith(".fasta") or f.endswith(".fa")
+            ]
+        self.filepaths = filepaths
+
+    def __iter__(self):
+        return self.yield_sequence()
+
+    def yield_sequence(self) -> Iterator[Sequence]:
+        for path in self.filepaths:
+            fasta = ImportFasta(path)
+            self.filepath = path  # For use in AddTaxonomyFromFilename
+            for seq in fasta.yield_sequence():
+                yield seq
+
+class ImportTSV:
+    def __init__(self, filepath: str, header_idx: int = 0, seq_idx: int = 1, annotation_idx: dict | None = None, header: bool = True):
+        """Parses a TSV file to yield Sequence objects.
+        Args:
+            filepath (str): Path to the TSV file.
+            header_idx (int): Column index for the header.
+            seq_idx (int): Column index for the sequence.
+            annotation_idx (dict | None): Optional dictionary mapping annotation names to column indices.
+            header (bool): Whether the TSV file has a header row to skip.
+        """
+        self.filepath = filepath
+        self.header_idx = header_idx
+        self.seq_idx = seq_idx
+        self.annotation_idx = annotation_idx or {}
+        self.header = header
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        with open(self.filepath, "r") as file:
+            for i, line in enumerate(file):
+                if self.header and i == 0:
+                    continue
+                parts = line.strip().split("\t")
+                if not parts or len(parts) <= max(self.header_idx, self.seq_idx, *(self.annotation_idx.values())):
+                    continue
+                header = parts[self.header_idx]
+                sequence = parts[self.seq_idx]
+                annotation = {
+                    key: parts[idx]
+                    for key, idx in self.annotation_idx.items()
+                }
+                yield Sequence(header=header, sequence=sequence, annotation=annotation)

fastasma/Mutators.py

@@ -0,0 +1,59 @@
+from fslab.Types import Sequence, SequenceSource
+from typing import Iterator, Callable, Optional
+from collections import deque
+
+class Head:
+    def __init__(self, source: SequenceSource, n: int):
+        self._source = source
+        self._n = n
+
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        count = 0
+        for seq in self._source:
+            if count >= self._n:
+                break
+            yield seq
+            count += 1
+
+class Tail:
+    def __init__(self, source: SequenceSource, n: int):
+        self._source = source
+        self._n = n
+
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        buffer = deque(maxlen=self._n)
+        for seq in self._source:
+            buffer.append(seq)
+        for seq in buffer:
+            yield seq
+
+class Sample:
+    def __init__(self, source: SequenceSource, k: int, seed: Optional[int] = None):
+        """Randomly samples k sequences from the source without unpacking the generator into memory.
+        Uses reservoir sampling algorithm.
+        """
+        import random
+        self._source = source
+        self._k = k
+        self._random = random.Random(seed)
+
+    def __iter__(self):
+        return self.yield_sequence()
+    
+    def yield_sequence(self) -> Iterator[Sequence]:
+        reservoir = []
+        for i, seq in enumerate(self._source):
+            if i < self._k:
+                reservoir.append(seq)
+            else:
+                j = self._random.randint(0, i)
+                if j < self._k:
+                    reservoir[j] = seq
+        for seq in reservoir:
+            yield seq

fastasma/Types.py

@@ -0,0 +1,13 @@
+from typing import Iterator, Protocol
+from dataclasses import dataclass
+
+@dataclass
+class Sequence:
+    header: str
+    sequence: str
+    annotation: dict = None
+
+class SequenceSource(Protocol):
+    def yield_sequence(self) -> Iterator[Sequence]:
+        ...
+    

fastasma/Writers.py

@@ -0,0 +1,149 @@
+from fastasma.Types import Sequence, SequenceSource
+from typing import List, Iterator, Callable
+
+class SeqSourceToString:
+    def __init__(self, source: SequenceSource, wrap: int = 80, annotaton_transform: Callable = None):
+        self._source = source
+        self._wrap = wrap
+
+    def __iter__(self):
+        return self._sequence_to_str()
+    
+    def annotation_transform(self, seq: Sequence) -> str:
+        return ' '.join(f"[{key}={value}]" for key, value in seq.annotation.items()) or ""
+
+    def _format_header(self, seq: Sequence) -> str:
+        annotation = self.annotation_transform(seq)
+        if annotation:
+            return f">{seq.header} {annotation}\n"
+        else:
+            return f">{seq.header}\n"
+    
+    def _sequence_to_str(self)-> Iterator[str]:
+        for seq in self._source.yield_sequence():
+            header_line = self._format_header(seq)
+            seq_lines = [
+                seq.sequence[i:i+self._wrap] + "\n"
+                for i in range(0, len(seq.sequence), self._wrap)
+            ]
+            yield header_line + ''.join(seq_lines)
+    
+    def yield_sequence(self) -> Iterator[str]:
+        return self._sequence_to_str()
+
+class WriteFasta:
+    def __init__(self, source: SequenceSource, output_path: str, wrap: int = 80):
+        self._source = source
+        self._output_path = output_path
+        self._wrap = wrap
+        self.write()
+
+    def write(self):
+        with open(self._output_path, "w") as outfile:
+            fasta_str_source = SeqSourceToString(self._source, wrap=self._wrap)
+            for record_str in fasta_str_source:
+                outfile.write(record_str)
+
+class WriteTSV:
+    def __init__(self, source: SequenceSource, output_path: str, sep: str = "\t"):
+        """Converts Sequence objects to a TSV file, using annotations as columns, plus header and sequence."""
+        self._source = source
+        self._output_path = output_path
+        self._sep = sep
+        self.write()
+
+    def _get_columns(self) -> List[str]:
+        columns = set()
+        for seq in self._source:
+            columns.update(seq.annotation.keys())
+        return ["header", "sequence"] + sorted(columns)
+
+    def write(self):
+        columns = self._get_columns()
+        with open(self._output_path, "w") as outfile:
+            outfile.write(self._sep.join(columns) + "\n")
+            for seq in self._source:
+                row = [
+                    seq.header,
+                    seq.sequence
+                ] + [
+                    str(seq.annotation.get(col, "")) for col in columns[2:]
+                ]
+                outfile.write(self._sep.join(row) + "\n")
+
+class WriteDB:
+    def __init__(self, source: SequenceSource, db_path: str):
+        """Writes Sequence objects to a SQLite database, using annotations as columns, plus header and sequence.
+        All the annotations are used as foreign keys to a separate annotations table. Annotations are stored as follows:
+        sequence table:
+            CREATE TABLE sequences (sequence_id INTEGER PRIMARY KEY, sequence_header TEXT, sequence_sequence TEXT);
+        annotation table:
+            CREATE TABLE annotations (annotation_id INTEGER PRIMARY KEY, annotation_name TEXT);
+        annotation_data table:
+            CREATE TABLE annotation_data (annotation_data_id INTEGER PRIMARY KEY, annotation_id INTEGER, annotation_data_value TEXT, sequence_id INTEGER,
+            FOREIGN KEY(annotation_id) REFERENCES annotations(annotation_id),
+            FOREIGN KEY(sequence_id) REFERENCES sequences(sequence_id));
+        """
+        self._source = source
+        self._db_path = db_path
+        self.write()
+
+    def write(self):
+        import sqlite3
+
+        conn = sqlite3.connect(self._db_path)
+        cursor = conn.cursor()
+
+        # Create tables
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS sequences (
+                sequence_id INTEGER PRIMARY KEY,
+                sequence_header TEXT,
+                sequence_sequence TEXT
+            )
+        """)
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS annotations (
+                annotation_id INTEGER PRIMARY KEY,
+                annotation_name TEXT UNIQUE
+            )
+        """)
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS annotation_data (
+                annotation_data_id INTEGER PRIMARY KEY,
+                annotation_id INTEGER,
+                annotation_data_value TEXT,
+                sequence_id INTEGER,
+                FOREIGN KEY(annotation_id) REFERENCES annotations(annotation_id),
+                FOREIGN KEY(sequence_id) REFERENCES sequences(sequence_id)
+            )
+        """)
+
+        # Insert data
+        for seq in self._source:
+            cursor.execute(
+                "INSERT INTO sequences (sequence_header, sequence_sequence) VALUES (?, ?)",
+                (seq.header, seq.sequence)
+            )
+            sequence_id = cursor.lastrowid
+
+            for key, value in seq.annotation.items():
+                cursor.execute(
+                    "INSERT OR IGNORE INTO annotations (annotation_name) VALUES (?)",
+                    (key,)
+                )
+                cursor.execute(
+                    "SELECT annotation_id FROM annotations WHERE annotation_name = ?",
+                    (key,)
+                )
+                annotation_id = cursor.fetchone()[0]
+
+                cursor.execute(
+                    "INSERT INTO annotation_data (annotation_id, annotation_data_value, sequence_id) VALUES (?, ?, ?)",
+                    (annotation_id, value, sequence_id)
+                )
+
+        conn.commit()
+        conn.close()
+
+

fastasma/__init__.py

@@ -0,0 +1,4 @@
+from fastasma.Importers import ImportFasta, ImportFastas, ImportTSV
+from fastasma.Annotators import DropAnnotations, DropAnnotationKeys, AddTaxonomyFromFilename, AddTaxidFromName, AddNameFromTaxid, AddTaxonomicRankFromTaxid, AddAnnotationToHeader
+from fastasma.Writers import WriteFasta, WriteTSV, WriteDB
+from fastasma.Mutators import Head, Tail, Sample

fastasma-0.1.1.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: fastasma
+Version: 0.1.1
+Summary: A collection of tools for working with FASTA files.
+Author-email: Daniel Pérez-Rodríguez <daniel.perez.rodriguez@uvigo.es>
+License: MIT License
+        
+        Copyright (c) 2026 Daniel Pérez Rodríguez
+        
+        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.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+# fastasma
+
+A collection of tools for working with FASTA files.
+
+## Installation
+
+```bash
+pip install fastasma
+```
+
+## Usage
+
+```python
+import fastasma
+
+# Import a FASTA file
+source = fstools.ImportFasta("sequences.fasta")
+
+# Annotate sequences
+annotated = fstools.AddAnnotationToHeader(
+    source,
+    annotation_key="organism",
+    separator="_",
+    position="suffix"
+)
+
+# Write output
+fstools.WriteFasta(annotated, output_path="output.fasta")
+```
+
+### Pipeline example
+
+```python
+import fastasma
+
+# Multiple steps can be chained
+source = fstools.ImportFasta("input.fasta")
+source = fstools.DropAnnotationKeys(source, keys_to_remove=["length"])
+source = fstools.AddAnnotationToHeader(source, annotation_key="organism", position="suffix")
+source = fstools.Head(source, n=10)
+fstools.WriteFasta(source, output_path="output.fasta")
+```
+
+### Available modules
+
+**Importers:** `ImportFasta`, `ImportFastas`, `ImportTSV`
+
+**Annotators:** `DropAnnotations`, `DropAnnotationKeys`, `AddTaxonomyFromFilename`, `AddTaxidFromName`, `AddNameFromTaxid`, `AddTaxonomicRankFromTaxid`, `AddAnnotationToHeader`
+
+**Mutators:** `Head`, `Tail`, `Sample`
+
+**Writers:** `WriteFasta`, `WriteTSV`, `WriteDB`

fastasma-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+fastasma/Annotators.py,sha256=nRtCUG9eoBTAAGekjmeCoi-ourQ6p9XFdCZnCDAZbbw,10537
+fastasma/Importers.py,sha256=g85Ou5VE8jN6884BeThT8uNayRz7dxYdZjzQrbl08OY,5089
+fastasma/Mutators.py,sha256=pGwFDp6PpeRvCZfhv3LBpISmKswYnpc1TiHGnwNJXD4,1718
+fastasma/Types.py,sha256=LWhPy1u5SMAuF03RWhj_ukKdirNohbO3shpvVcqz1bM,263
+fastasma/Writers.py,sha256=KQeVzIFkCuudn3KjLwjanVct2GCAqKynfpUOLPJ7Vtc,5663
+fastasma/__init__.py,sha256=FRo17sFcLBljWeiMaP75lNLja8KdAbKRhoVdswlU5io,355
+fastasma-0.1.1.dist-info/licenses/LICENSE.txt,sha256=88hCDT3C1ZtV_UNguH5oKZVYyfZfcWmTs4z43Ir--dU,1080
+fastasma-0.1.1.dist-info/METADATA,sha256=sVG41bWwvNCAGLp0gEKlzjNi5ga1COpqfqt8EBZ3cGQ,2735
+fastasma-0.1.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+fastasma-0.1.1.dist-info/top_level.txt,sha256=ciUMyRkhn8ZUEers_6u6kYrmC5vMXOuaW4fPU1XL8vk,9
+fastasma-0.1.1.dist-info/RECORD,,

fastasma-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fastasma-0.1.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Pérez Rodríguez
+
+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.

fastasma-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastasma