eefinder 1.1.2__tar.gz

eefinder-1.1.2/.gitignore

@@ -0,0 +1,16 @@
+scripts/__pycache__/
+*.pyc
+*.pin
+*.phr
+*.psq
+output/
+
+docs/_build/
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+
+# macOS
+.DS_Store

eefinder-1.1.2/LICENSE

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

eefinder-1.1.2/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.5
+Name: eefinder
+Version: 1.1.2
+Summary: Identification of endogenous viral and bacterial elements in eukaryotic genomes
+Project-URL: Homepage, https://github.com/WallauBioinfo/EEfinder
+Project-URL: Documentation, https://eefinder.readthedocs.io
+Project-URL: Repository, https://github.com/WallauBioinfo/EEfinder
+Project-URL: Issues, https://github.com/WallauBioinfo/EEfinder/issues
+Project-URL: Publication, https://doi.org/10.1016/j.csbj.2024.10.012
+Author-email: Filipe Zimmer Dezordi <zimmer.filipe@gmail.com>, Yago Dias <yag.dias@gmail.com>
+Maintainer-email: Filipe Zimmer Dezordi <zimmer.filipe@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: EVE,bioinformatics,endogenous elements,genomics,horizontal gene transfer,virus
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: <3.12,>=3.9
+Requires-Dist: biopython<1.86,>=1.79
+Requires-Dist: click>=8.1
+Requires-Dist: numpy<3,>=1.22
+Requires-Dist: pandas<3,>=1.4
+Description-Content-Type: text/markdown
+
+# EEfinder
+
+EEfinder is a tool/python package that automatizes several tasks related to identification of Endogenous Elements present on Eukaryotic Genomes.
+
+#### Install
+
+EEfinder drives BLAST, DIAMOND and bedtools, which are not pip-installable — install them first, then the package.
+
+##### From PyPI
+
+```bash
+conda create -n EEfinder -c conda-forge -c bioconda \
+  "python>=3.9,<3.12" "blast>=2.5" "diamond>=2.0.15" "bedtools>=2.27"
+conda activate EEfinder
+
+pip install eefinder
+```
+
+##### From source
+
+Cloning also gives you `env.yml`, which pins the exact versions EEfinder was developed and tested against (BLAST 2.5.0, DIAMOND 2.0.15, bedtools 2.27.1), plus the example data in `test_files/`.
+
+```bash
+git clone https://github.com/WallauBioinfo/EEfinder.git
+cd EEfinder
+conda env create -f env.yml
+conda activate EEfinder
+pip install .
+```
+
+#### Check tool
+
+```bash
+eefinder --version
+
+#eefinder, version 1.1.2
+```
+
+#### Documentation
+
+Full documentation is hosted on Read the Docs: **https://eefinder.readthedocs.io**
+
+#### Cite us
+
+If you use EEfinder in your research, please cite https://www.sciencedirect.com/science/article/pii/S2001037024003325:
+
+```
+Dias, Y. J. M., Dezordi, F. Z., & Wallau, G. L. (2024). EEFinder: A general-purpose tool for identification of bacterial and viral endogenized elements in eukaryotic genomes. Computational and Structural Biotechnology Journal. https://doi.org/10.1016/j.csbj.2024.10.012
+```

eefinder-1.1.2/README.md

@@ -0,0 +1,49 @@
+# EEfinder
+
+EEfinder is a tool/python package that automatizes several tasks related to identification of Endogenous Elements present on Eukaryotic Genomes.
+
+#### Install
+
+EEfinder drives BLAST, DIAMOND and bedtools, which are not pip-installable — install them first, then the package.
+
+##### From PyPI
+
+```bash
+conda create -n EEfinder -c conda-forge -c bioconda \
+  "python>=3.9,<3.12" "blast>=2.5" "diamond>=2.0.15" "bedtools>=2.27"
+conda activate EEfinder
+
+pip install eefinder
+```
+
+##### From source
+
+Cloning also gives you `env.yml`, which pins the exact versions EEfinder was developed and tested against (BLAST 2.5.0, DIAMOND 2.0.15, bedtools 2.27.1), plus the example data in `test_files/`.
+
+```bash
+git clone https://github.com/WallauBioinfo/EEfinder.git
+cd EEfinder
+conda env create -f env.yml
+conda activate EEfinder
+pip install .
+```
+
+#### Check tool
+
+```bash
+eefinder --version
+
+#eefinder, version 1.1.2
+```
+
+#### Documentation
+
+Full documentation is hosted on Read the Docs: **https://eefinder.readthedocs.io**
+
+#### Cite us
+
+If you use EEfinder in your research, please cite https://www.sciencedirect.com/science/article/pii/S2001037024003325:
+
+```
+Dias, Y. J. M., Dezordi, F. Z., & Wallau, G. L. (2024). EEFinder: A general-purpose tool for identification of bacterial and viral endogenized elements in eukaryotic genomes. Computational and Structural Biotechnology Journal. https://doi.org/10.1016/j.csbj.2024.10.012
+```

eefinder-1.1.2/eefinder/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("eefinder")
+except PackageNotFoundError:  # pragma: no cover - package not installed
+    __version__ = "unknown"

eefinder-1.1.2/eefinder/bed.py

@@ -0,0 +1,206 @@
+import pandas as pd
+import numpy as np
+import shlex
+import subprocess
+import re
+
+
+class GetFasta:
+    """
+    This function execute the bedtools getfasta.
+
+    Keyword arguments:
+    input_file: input_file, parsed with -in argument.
+    bed_file: bed file, genereated along the pipeline
+    out_file: output file
+    """
+
+    def __init__(self, input_file: str, bed_file: str, out_file: str) -> object:
+        self.input_file = input_file
+        self.bed_file = bed_file
+        self.out_file = out_file
+
+        self.get_fasta()
+
+    def get_fasta(self) -> None:
+        get_fasta = f"bedtools getfasta -fi {self.input_file} -bed {self.bed_file} -fo {self.out_file}"
+        get_fasta = shlex.split(get_fasta)
+        cmd_get_fasta = subprocess.Popen(
+            get_fasta, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+        )
+        cmd_get_fasta.wait()
+
+
+class GetAnnotBed:
+    """
+    Create a bed file that will be used to merge truncated EVEs of the same
+    family in the same sense based on a limite length treshold.
+
+    Keyword arguments:
+    blast_tax_info: csv file generated in the get_taxonomy_info function on get_taxonomy.py
+    merge_level: genus or family, choose which level going to merge nearby elements
+    """
+
+    def __init__(self, blast_tax_info: str, merge_level: str) -> object:
+        self.blast_tax_info = blast_tax_info
+        self.merge_level = merge_level
+
+        self.get_annotated_bed()
+
+    def get_annotated_bed(self) -> None:
+        df_blast_tax_info = pd.read_csv(self.blast_tax_info, sep=",")
+        df_blast_tax_info["qseqid"] = df_blast_tax_info["qseqid"].str.replace(
+            r"\:.*", "", regex=True
+        )
+        df_blast_tax_info["sseqid"] = (
+            df_blast_tax_info["sseqid"]
+            + "|"
+            + df_blast_tax_info["sense"]
+            + "|"
+            + df_blast_tax_info["pident"].astype(str)
+        )
+        df_blast_tax_info["Family"] = df_blast_tax_info["Family"].fillna("Unknown")
+        df_blast_tax_info["Genus"] = df_blast_tax_info["Genus"].fillna("Unknown")
+
+        if self.merge_level == "genus":
+            df_blast_tax_info["formated_name"] = np.where(
+                df_blast_tax_info["Genus"] != "Unknown",
+                df_blast_tax_info["qseqid"]
+                + "|"
+                + df_blast_tax_info["Family"]
+                + "|"
+                + df_blast_tax_info["Genus"]
+                + "|"
+                + df_blast_tax_info["sense"],
+                df_blast_tax_info["qseqid"]
+                + "|"
+                + df_blast_tax_info["sseqid"]
+                + "|"
+                + df_blast_tax_info["Genus"],
+            )
+        else:
+            df_blast_tax_info["formated_name"] = np.where(
+                df_blast_tax_info["Family"] != "Unknown",
+                df_blast_tax_info["qseqid"]
+                + "|"
+                + df_blast_tax_info["Family"]
+                + "|"
+                + df_blast_tax_info["sense"],
+                df_blast_tax_info["qseqid"]
+                + "|"
+                + df_blast_tax_info["sseqid"]
+                + "|"
+                + df_blast_tax_info["Family"],
+            )
+        bed_blast_info = df_blast_tax_info[
+            ["formated_name", "qstart", "qend", "sseqid"]
+        ].copy()
+        bed_blast_info = bed_blast_info.sort_values(
+            ["formated_name", "qstart"], ascending=(True, True)
+        )
+        bed_blast_info.to_csv(
+            f"{self.blast_tax_info}.bed", index=False, header=False, sep="\t"
+        )
+
+
+class RemoveAnnotation:
+    """
+    Remove the annotated information generate into the get_annotated_bed function.
+
+    Keyword arguments:
+    bed_annotated_merged_file: tsv file generated in the merge_bedfile function on bed_merge.py
+    """
+
+    def __init__(self, bed_annotated_merged_file: str) -> object:
+        self.bed_annotated_merged_file = bed_annotated_merged_file
+
+        self.reformat_bed()
+
+    def reformat_bed(self) -> None:
+        df_merge_file = pd.read_csv(
+            self.bed_annotated_merged_file, sep="\t", header=None
+        )
+        df_merge_file.iloc[:, 0] = df_merge_file.iloc[:, 0].str.replace(
+            "\|.*", "", regex=True
+        )
+        df_merge_file.to_csv(
+            f"{self.bed_annotated_merged_file}.fmt", index=False, header=False, sep="\t"
+        )
+
+
+class MergeBed:
+    """
+    Execute the bedtools merge.
+
+    Keyword arguments:
+    bed_annotated_file: annotated bed file created at get_annotated_bed function
+    limit_merge: Limit of bases to merge regions, parsed with -lm argument
+    """
+
+    def __init__(self, bed_annotated_file: str, limit_merge: int) -> object:
+        self.bed_annotated_file = bed_annotated_file
+        self.limit_merge = limit_merge
+
+        self.merge_bed()
+
+    def merge_bed(self) -> None:
+        bed_merge_output = open(f"{self.bed_annotated_file}.merge", "w")
+        bed_merge_cmd = f'bedtools merge -d {int(self.limit_merge)} -i {self.bed_annotated_file} -c 4 -o collapse -delim " AND "'
+        bed_merge_cmd = shlex.split(bed_merge_cmd)
+        bed_merge_process = subprocess.Popen(bed_merge_cmd, stdout=bed_merge_output)
+        bed_merge_process.wait()
+
+
+class BedFlank:
+    """
+    Extract flanking regions of EEs using bedtools slop.
+
+    Keyword arguments:
+    input_file: bed file generated by get_bed function
+    lenght_file: lenght file produced by get_length function
+    flank_region: desired lenght regions for extraction, parsed from
+    """
+
+    def __init__(self, input_file: str, length_file: str, flank_region: int) -> object:
+        self.input_file = input_file
+        self.length_file = length_file
+        self.flank_region = flank_region
+
+        self.bedtools_flank()
+
+    def bedtools_flank(self) -> None:
+        with open(f"{self.input_file}.flank", "w") as flank_out:
+            bed_flank_cmd = f"bedtools slop -i {self.input_file} -g {self.length_file} -b {str(self.flank_region)}"
+            bed_flank_cmd = shlex.split(bed_flank_cmd)
+            bed_flank_process = subprocess.Popen(bed_flank_cmd, stdout=flank_out)
+            bed_flank_process.wait()
+
+
+class GetBed:
+    """
+    Create a bed file from fasta file using replace logic.
+
+    Keyword arguments:
+    input_file: fasta file for desired bed file
+    """
+
+    def __init__(self, input_file: str) -> object:
+        self.input_file = input_file
+
+        self.get_bed()
+
+    def get_bed(self) -> None:
+        with open(f"{self.input_file}", "r") as repeat_eves, open(
+            f"{self.input_file}.bed", "w"
+        ) as repeat_eves_bed_out:
+            repeat_eves_lines = repeat_eves.readlines()
+            for line in repeat_eves_lines:
+                if ">" in line:
+                    line_name = line.replace(">", "")
+                    line_name = re.sub(":.*", "", line_name).rstrip("\n")
+                    line_start = re.sub(".*:", "", line)
+                    line_start = re.sub("-.*", "", line_start).rstrip("\n")
+                    line_end = re.sub(".*-", "", line).rstrip("\n")
+                    repeat_eves_bed_out.write(
+                        f"{line_name}\t{line_start}\t{line_end}\n"
+                    )

eefinder-1.1.2/eefinder/clean_data.py

@@ -0,0 +1,64 @@
+from Bio import SeqIO
+
+
+class RemoveShortSequences:
+    """
+    Remove sequences bellow the cutoff threshold.
+
+    Keyword arguments:
+    input_file: input fasta file
+    cutoff: cutoff length, parsed by -ln
+    """
+
+    def __init__(self, input_file: str, cutoff: int) -> object:
+        self.input_file = input_file
+        self.cutoff = cutoff
+
+        self.cut_seq()
+
+    def cut_seq(self) -> None:
+        new_sequences = []
+        input_handle = open(self.input_file, "r")
+        output_handle = open(self.input_file + ".fmt", "w")
+        for record in SeqIO.parse(input_handle, "fasta"):
+            if len(record.seq) >= int(self.cutoff):
+                new_sequences.append(record)
+        SeqIO.write(new_sequences, output_handle, "fasta")
+
+
+class MaskClean:
+    """
+    Remove sequences of EE on regions with a certain % of soft masked bases.
+
+    Keyword arguments:
+    input_file: fasta file, with putative EEs
+    m_per: treshold masked percentage value, parsed with -mp argument
+    """
+
+    def __init__(self, input_file: str, m_per: int) -> object:
+        self.input_file = input_file
+        self.m_per = m_per
+
+        self.mask_clean()
+
+    def mask_clean(self) -> None:
+        sequences = {}
+        for seq_record in SeqIO.parse(self.input_file, "fasta"):
+            sequence = str(seq_record.seq)
+            sequence_id = str(seq_record.id)
+            if (
+                float(
+                    sequence.count("a")
+                    + sequence.count("t")
+                    + sequence.count("c")
+                    + sequence.count("g")
+                    + sequence.count("n")
+                    + sequence.count("N")
+                )
+                / float(len(sequence))
+            ) * 100 <= float(self.m_per):
+                if sequence_id not in sequences:
+                    sequences[sequence_id] = sequence
+        with open(self.input_file + ".cl", "w+") as output_file:
+            for sequence_id, sequence in sequences.items():
+                output_file.write(f">{sequence_id}\n{sequence}\n")

eefinder-1.1.2/eefinder/compare_results.py

@@ -0,0 +1,30 @@
+import pandas as pd
+
+
+class CompareResults:
+    """
+    This function compares 2 blast results, for queries with same ID, only the one
+    with the major bitscore is keept. In a final step only queries with tag EE are maintained
+
+    Keyword arguments:
+    vir_result: filtred blast against ee database
+    host_result: filtred blast against filter database
+    """
+
+    def __init__(self, vir_result: str, host_result: str) -> object:
+        self.vir_result = vir_result
+        self.host_result = host_result
+
+        self.compare_results()
+
+    def compare_results(self) -> None:
+        df_vir = pd.read_csv(self.vir_result, sep="\t")
+        df_vir["qseqid"] = df_vir["bed_name"]
+        df_host = pd.read_csv(self.host_result, sep="\t")
+        df_hybrid = pd.concat([df_vir, df_host], ignore_index=True)
+        df_hybrid = df_hybrid.sort_values(by=["qseqid", "bitscore"], ascending=False)
+        df_hybrid.to_csv(self.host_result + ".concat", sep="\t", index=False)
+        df_nr = df_hybrid.drop_duplicates(subset=["qseqid"])
+        df_nr.to_csv(self.host_result + ".concat.nr", sep="\t", index=False)
+        df_nr_vir = df_nr[df_nr.tag == "EE"]
+        df_nr_vir.to_csv(self.host_result + ".concat.nr", sep="\t", index=False)

eefinder-1.1.2/eefinder/filter_table.py

@@ -0,0 +1,135 @@
+import pandas as pd
+import csv
+import os
+import re
+import glob
+import shutil
+
+
+class FilterTable:
+    """
+    Receives a blastx result and filter based on query ID and ranges of qstart and qend.
+
+    Keyword arguments:
+    blast_result: input blastx result
+    rangejunction: range for filter redundant hits
+    tag: HOST or EE, tells which blastx is
+    out_dir: output directory, parsed by -od
+    """
+
+    def __init__(
+        self, blast_result: str, rangejunction: int, tag: str, out_dir: str
+    ) -> object:
+        self.blast_result = blast_result
+        self.rangejunction = rangejunction
+        self.tag = tag
+        self.out_dir = out_dir
+
+        self.filter_blast()
+
+    def filter_blast(self) -> None:
+        header_outfmt6 = [
+            "qseqid",
+            "sseqid",
+            "pident",
+            "length",
+            "mismatch",
+            "gapopen",
+            "qstart",
+            "qend",
+            "sstart",
+            "send",
+            "evalue",
+            "bitscore",
+        ]  # creates a blast header output in format = 6
+        df = pd.read_csv(
+            self.blast_result, sep="\t", header=None, names=header_outfmt6
+        ).sort_values(by="bitscore", ascending=False)
+        df["sense"] = ""
+        df["bed_name"] = ""
+        df["tag"] = ""
+        df["new_qstart"] = df["qstart"]
+        df["new_qend"] = df["qend"]
+        df.to_csv(self.blast_result + ".csv", sep="\t")
+        chunks = df = pd.read_csv(
+            f"{self.blast_result}.csv", sep="\t", chunksize=200000
+        )
+        count = 0
+        tmp_path = f"{self.out_dir}/tmp/"
+        if os.path.exists(tmp_path) == False:
+            os.mkdir(tmp_path)
+        for df in chunks:
+            df["sense"] = df["sense"].astype(object)
+            df.loc[
+                df["qstart"].astype(int) > df["qend"].values.astype(int), "sense"
+            ] = "neg"
+            df.loc[
+                df["qend"].values.astype(int) > df["qstart"].astype(int), "sense"
+            ] = "pos"
+            df.loc[df["sense"] == "neg", "new_qstart"] = df["qend"]
+            df.loc[df["sense"] == "neg", "new_qend"] = df["qstart"]
+            df.loc[df["sense"] == "neg", "qstart"] = df["new_qstart"]
+            df.loc[df["sense"] == "neg", "qend"] = df["new_qend"]
+            df.drop(columns=["new_qstart", "new_qend"], inplace=True)
+            if self.tag == "EE":
+                df["tag"] = "EE"
+                df["bed_name"] = df.apply(
+                    lambda x: "%s:%s-%s" % (x["qseqid"], x["qstart"], x["qend"]), axis=1
+                )
+            else:
+                df["tag"] = "HOST"
+                df["bed_name"] = df["qseqid"]
+            pd.options.display.float_format = "{:,.2f}".format
+            df["evalue"] = pd.to_numeric(df["evalue"], downcast="float")
+            df = df[df.length >= 33]
+            header = [
+                "qseqid",
+                "sseqid",
+                "pident",
+                "length",
+                "mismatch",
+                "gapopen",
+                "qstart",
+                "qend",
+                "sstart",
+                "send",
+                "evalue",
+                "bitscore",
+                "sense",
+                "bed_name",
+                "tag",
+            ]
+            df = df[header]
+            with open(f"{tmp_path}chunk.{count}.tsv", "w") as chunk_writer:
+                df.to_csv(chunk_writer, sep="\t", index=False)
+            count += 1
+        all_chunks = glob.glob(f"{tmp_path}/*.tsv")
+        final_filtred_file = pd.DataFrame()
+        chunks_list = []
+        for chunk in all_chunks:
+            df = pd.read_csv(chunk, sep="\t")
+            chunks_list.append(df)
+        final_filtred_file = pd.concat(chunks_list, ignore_index=True)
+        final_filtred_file["qstart_rng"] = final_filtred_file.qstart.floordiv(
+            self.rangejunction
+        )
+        final_filtred_file["qend_rng"] = final_filtred_file.qend.floordiv(
+            self.rangejunction
+        )
+        final_filtred_file = (
+            final_filtred_file.drop_duplicates(subset=["qseqid", "qstart_rng", "sense"])
+            .drop_duplicates(subset=["qseqid", "qstart_rng", "sense"])
+            .sort_values(by=["qseqid"])
+        )
+        final_filtred_file.to_csv(
+            f"{self.blast_result}.filtred", sep="\t", index=False, columns=header
+        )
+        if self.tag == "EE":
+            final_filtred_file.to_csv(
+                f"{self.blast_result}.filtred.bed",
+                header=False,
+                sep="\t",
+                index=False,
+                columns=["qseqid", "qstart", "qend"],
+            )
+        shutil.rmtree(tmp_path, ignore_errors=True)

eefinder-1.1.2/eefinder/get_length.py

@@ -0,0 +1,21 @@
+from Bio import SeqIO
+
+
+class GetLength:
+    """
+    Creates a length file with the module SeqIO.
+
+    Keywords arguments:
+    input_file: formated genome, generated by cut_seq function
+    """
+
+    def __init__(self, input_file: str) -> object:
+        self.input_file = input_file
+
+        self.get_length()
+
+    def get_length(self) -> None:
+        with open(f"{self.input_file}.rn.fmt.lenght", "w") as output_length:
+            length_list = []
+            for seq_record in SeqIO.parse(self.input_file, "fasta"):
+                output_length.write(f"{seq_record.id}\t{str(len(seq_record))}\n")