maphelios 0.8.3__tar.gz

maphelios-0.8.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Zimmermann-Kogadeeva Group
+
+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.

maphelios-0.8.3/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: maphelios
+Version: 0.8.3
+Summary: Package for making genome related plots
+Author-email: Bartosz Bartmanski <bartosz.bartmanski@embl.de>, Katarina Erbstein <katarina.erbstein@embl.de>
+License: MIT License
+        
+        Copyright (c) 2024 Zimmermann-Kogadeeva Group
+        
+        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.
+        
+Project-URL: Homepage, https://git.embl.de/grp-zimmermann-kogadeeva/Maphelios
+Project-URL: Bug tracker, https://git.embl.de/grp-zimmermann-kogadeeva/Maphelios/issues/
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: biopython
+Requires-Dist: bcbio-gff
+Requires-Dist: dna_features_viewer
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: platformdirs
+Requires-Dist: pysam>=0.23.0
+Requires-Dist: pycirclize>=1.9.1
+Requires-Dist: scipy>=1.13.1
+Provides-Extra: streamlit
+Requires-Dist: streamlit; extra == "streamlit"
+Requires-Dist: seaborn; extra == "streamlit"
+Dynamic: license-file
+
+
+# Maphelios
+
+Package to find and plot inserts alongside the genome or contigs.
+
+BLAST is required. You can follow the instructions to download and install
+BLAST
+[here](https://blast.ncbi.nlm.nih.gov/doc/blast-help/downloadblastdata.html). 
+
+## Installation
+
+```
+pip install git+https://git.embl.org/grp-zimmermann-kogadeeva/Maphelios.git
+```
+
+## Running
+
+### Docker
+
+To run the streamlit app with docker:
+```
+docker run -it --rm -p 8501:8501 docker://registry.git.embl.org/grp-zimmermann-kogadeeva/maphelios:0.7.3
+```
+
+### Apptainer
+
+To run the streamlit app with apptainer:
+```
+apptainer exec --no-home --writable-tmpfs --workdir /app docker://registry.git.embl.org/grp-zimmermann-kogadeeva/maphelios:0.7.3 streamlit run /app/app/app.py --server.headless true
+```
+

maphelios-0.8.3/README.md

@@ -0,0 +1,31 @@
+
+# Maphelios
+
+Package to find and plot inserts alongside the genome or contigs.
+
+BLAST is required. You can follow the instructions to download and install
+BLAST
+[here](https://blast.ncbi.nlm.nih.gov/doc/blast-help/downloadblastdata.html). 
+
+## Installation
+
+```
+pip install git+https://git.embl.org/grp-zimmermann-kogadeeva/Maphelios.git
+```
+
+## Running
+
+### Docker
+
+To run the streamlit app with docker:
+```
+docker run -it --rm -p 8501:8501 docker://registry.git.embl.org/grp-zimmermann-kogadeeva/maphelios:0.7.3
+```
+
+### Apptainer
+
+To run the streamlit app with apptainer:
+```
+apptainer exec --no-home --writable-tmpfs --workdir /app docker://registry.git.embl.org/grp-zimmermann-kogadeeva/maphelios:0.7.3 streamlit run /app/app/app.py --server.headless true
+```
+

maphelios-0.8.3/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools>=64.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "maphelios"
+version = "0.8.3"
+requires-python = ">=3.9"
+description = "Package for making genome related plots"
+readme = "README.md"
+license = {file = "LICENSE"}
+authors = [
+    { name = "Bartosz Bartmanski", email = "bartosz.bartmanski@embl.de" },
+    { name = "Katarina Erbstein", email = "katarina.erbstein@embl.de" }
+]
+
+dependencies = [
+    "biopython",
+    "bcbio-gff",
+    "dna_features_viewer",
+    "matplotlib",
+    "pandas",
+    "platformdirs",
+    "pysam>=0.23.0",
+    "pycirclize>=1.9.1",
+    "scipy>=1.13.1",
+]
+
+[project.optional-dependencies]
+streamlit = ["streamlit", "seaborn"]
+
+[project.scripts]
+maphelios = "maphelios.__main__:main"
+
+[project.urls]
+"Homepage" = "https://git.embl.de/grp-zimmermann-kogadeeva/Maphelios"
+"Bug tracker" = "https://git.embl.de/grp-zimmermann-kogadeeva/Maphelios/issues/"
+
+[tool.isort]
+profile = "black"
+src_paths = ["src", "tests"]
+
+[tool.bumpver]
+current_version = "0.8.3"
+version_pattern = "MAJOR.MINOR.PATCH"
+commit_message  = "Bump version {old_version} -> {new_version}"
+commit          = true
+tag             = true
+push            = true
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = ['current_version = "{version}"', 'version = "{version}"']
+"src/maphelios/__init__.py" = ['^__version__ = "{version}"$']
+
+[dependency-groups]
+dev = [
+    "ipympl>=0.8.8",
+    "jupyterlab>=2.3.2",
+]

maphelios-0.8.3/setup.cfg

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

maphelios-0.8.3/src/maphelios/__init__.py

@@ -0,0 +1,5 @@
+from .comparison import Comparison
+from .insert import Insert
+from .mapping import Mapping
+
+__version__ = "0.8.3"

maphelios-0.8.3/src/maphelios/__main__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

maphelios-0.8.3/src/maphelios/cli.py

@@ -0,0 +1,106 @@
+import argparse
+
+import matplotlib.pyplot as plt
+
+from .main import Pipeline
+from .plotting import plot_insert, plot_insert_dists, plot_genome
+
+
+def get_args(*args):
+    # Create the CLI using argparse
+    # TODO: maybe switch from argparse to click
+    parser = argparse.ArgumentParser(description="Generating plots")
+
+    subparsers = parser.add_subparsers(help="sub-command help")
+
+    parser_ncbi = subparsers.add_parser("ncbi", help="Download genome from NCBI")
+    parser_ncbi.add_argument("search_term", help="search term for BLAST")
+    parser_ncbi.add_argument("email", help="Your email address - needed by BLAST")
+    parser_ncbi.add_argument(
+        "--retmax",
+        default=200,
+        help="Maximum number of records to download from NCBI",
+    )
+
+    parser_genome = subparsers.add_parser("file", help="Specify a local genome.")
+    parser_genome.add_argument("path_to_genome")
+
+    parser.add_argument("seq_file", help="file with the sequences")
+    parser.add_argument("output_prefix", help="Output directory")
+
+    parser.add_argument(
+        "--fwd_suffix", default="_F", help="Suffix for forward seq. default='_F'"
+    )
+    parser.add_argument(
+        "--rev_suffix", default="_R", help="Suffix for reverse seq. default='_R'"
+    )
+    parser.add_argument(
+        "--insert_types", help="matched, unmatched or both inserts", default="both"
+    )
+    parser.add_argument(
+        "--filter",
+        default=0.5,
+        help="Threshold value for filtering out blast results with low coverage",
+    )
+
+    # Get all the command line arguments
+    return parser.parse_args(*args)
+
+
+def main():
+    args = get_args()
+    if "path_to_genome" in args:
+        search_term = None
+        email = None
+        retmax = None
+        path_to_genome = args.path_to_genome
+    else:
+        search_term = args.search_term
+        email = args.email
+        retmax = int(args.retmax)
+        path_to_genome = None
+
+    pipeline = Pipeline(
+        args.seq_file,
+        args.output_prefix,
+        genome_file=path_to_genome,
+        search_term=search_term,
+        email=email,
+        retmax=retmax,
+        fwd_suffix=args.fwd_suffix,
+        rev_suffix=args.rev_suffix,
+    )
+
+    # Create linear plots of inserts with annotations
+    for seq_id in pipeline.seq_ids:
+        inserts = pipeline.get_inserts(
+            seq_id, insert_types=args.insert_types, filter_threshold=args.filter
+        )
+        for i, insert in enumerate(inserts):
+            fig, axs = plt.subplots(2, 1, figsize=(10, 10), height_ratios=[3, 5])
+            axs = plot_insert(insert, pipeline.genome, axs=axs)
+            fig.savefig(pipeline.work_dir / f"{seq_id}_hit{i}.png", dpi=300)
+            plt.close()
+
+    # Get all inserts (used in both next plots)
+    inserts = pipeline.get_all_inserts(args.insert_types, filter_threshold=args.filter)
+
+    # Create a plot of genome / all contigs as circular plot with inserts
+    # layered on top
+    fig, ax = plt.subplots(figsize=(10, 30))
+    ax = plot_on_genome(inserts, pipeline.genome, ax=ax)
+    fig.savefig(pipeline.work_dir / "genome_plot.png", dpi=300)
+
+    # Plots of distributions of insert sizes
+    fig, axs = plt.subplots(1, 3, figsize=(12, 5))
+    axs = plot_insert_dists(inserts, axs=axs)
+    fig.savefig(pipeline.work_dir / "insert_length_dist.png", dpi=300)
+
+    df = pipeline.to_dataframe(
+        insert_types=args.insert_types, filter_threshold=args.filter
+    )
+    df.to_csv(pipeline.work_dir / "inserts.csv", index=False)
+
+
+if __name__ == "__main__":
+    main()

maphelios-0.8.3/src/maphelios/comparison.py

@@ -0,0 +1,352 @@
+from collections import defaultdict
+from itertools import chain, cycle
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from dna_features_viewer import CircularGraphicRecord
+from matplotlib import color_sequences
+
+
+class Clusters(dict):
+    def __init__(self, clusters, genomes=None):
+        super(Clusters, self).__init__(clusters)
+
+        self.genomes = genomes or {g for g, clust_idx in self.keys()}
+        self.cluster_labels = list(self.keys())
+
+    def __contains__(self, item):
+        return item in self.cluster_labels
+
+    @property
+    def insert_ids(self):
+        insert_ids = {
+            genome: list(
+                chain.from_iterable(
+                    (
+                        insert_ids
+                        for (g, clust_idx), insert_ids in self.items()
+                        if g == genome
+                    )
+                )
+            )
+            for genome in self.genomes
+        }
+        return insert_ids
+
+    @property
+    def insert_labels(self):
+        seq_labels = defaultdict(dict)
+        for g, clust_idx in self.cluster_labels:
+            insert_ids = self.__getitem__((g, clust_idx))
+            # Set it such that only one label is given per cluster
+            for insert_id in insert_ids:
+                seq_labels[g][insert_id] = None
+            seq_labels[g][insert_ids[-1]] = f"Cluster {clust_idx}"
+        return seq_labels
+
+    @property
+    def other_repr(self):
+        other = defaultdict(list)
+        for (g, clust_idx), insert_ids in self.items():
+            other[g].append((clust_idx, insert_ids))
+        return other
+
+    def subset(self, selection):
+        return Clusters(
+            {
+                (g, clust_idx): self.__getitem__((g, clust_idx))
+                for g, clust_idx in selection
+            }
+        )
+
+
+class Comparison(dict):
+
+    def __init__(self, *args, **kwargs):
+        super(Comparison, self).__init__(*args, **kwargs)
+
+        self.insert_ids = {g: mapping.insert_ids for g, mapping in self.items()}
+
+    def get_inserts(
+        self,
+        genomes=None,
+        seq_ids=None,
+        insert_ids=None,
+        insert_type="both",
+        filter_threshold=None,
+        **kwargs,
+    ):
+        if genomes is None:
+            genomes = self.keys()
+
+        return [
+            self.__getitem__(g).get(
+                insert_ids=insert_ids,
+                seq_ids=seq_ids,
+                insert_type=insert_type,
+                filter_threshold=filter_threshold,
+            )
+            for g in genomes
+        ]
+
+    def get_inserts_df(
+        self, genomes=None, insert_type="both", filter_threshold=None, **kwargs
+    ):
+        if genomes is None:
+            genomes = self.keys()
+
+        inserts_dfs = [
+            self.__getitem__(genome)
+            .to_dataframe(insert_type=insert_type, filter_threshold=filter_threshold)
+            .assign(genome=genome)
+            for genome in genomes
+        ]
+
+        if len(inserts_dfs):
+            return pd.concat(inserts_dfs, ignore_index=True)
+
+    def get_insert_presence_df(
+        self, genomes=None, insert_type="both", filter_threshold=None, **kwargs
+    ):
+        if genomes is None:
+            genomes = self.keys()
+
+        dfs = [
+            pd.DataFrame(
+                self.__getitem__(g).get_seq_ids(insert_type, filter_threshold),
+                columns=["insert_ids"],
+            ).assign(genome=g)
+            for g in genomes
+        ]
+
+        all_seq_ids = sorted(
+            set(chain.from_iterable(self.__getitem__(g).seq_ids for g in genomes))
+        )
+
+        df_insert_presence = (
+            pd.concat(dfs, ignore_index=True)
+            .groupby(["insert_ids", "genome"], as_index=False)
+            .agg(num_inserts=pd.NamedAgg("insert_ids", "count"))
+            .pivot(index="insert_ids", columns="genome", values="num_inserts")
+            .reindex(columns=genomes, index=all_seq_ids)
+        )
+
+        return df_insert_presence
+
+    def get_clusters(
+        self,
+        genomes=None,
+        insert_type="both",
+        filter_threshold=None,
+        plain_dict=True,
+        **kwargs,
+    ):
+        if genomes is None:
+            genomes = self.keys()
+
+        if plain_dict:
+            return {
+                g: self.__getitem__(g).get_clusters(insert_type, filter_threshold)
+                for g in genomes
+            }
+        else:
+            return Clusters(
+                {
+                    (g, clust_idx): cluster
+                    for g in genomes
+                    for clust_idx, cluster in enumerate(
+                        self.__getitem__(g).get_clusters(insert_type, filter_threshold)
+                    )
+                },
+                genomes=genomes,
+            )
+
+    def get_labels(
+        self,
+        seq_ids,
+        insert_ids=None,
+        genomes=None,
+        insert_type="both",
+        filter_threshold=None,
+    ):
+        if genomes is None:
+            genomes = self.keys()
+
+        if insert_ids is None:
+            insert_ids = {g: None for g in genomes}
+
+        if seq_ids is not None or insert_ids is not None:
+            return {
+                g: self.__getitem__(g).get_labels(
+                    seq_ids, insert_ids.get(g), genomes, insert_type, filter_threshold
+                )
+                for g in genomes
+            }
+
+    def get_genes_df(
+        self,
+        seq_ids=None,
+        insert_ids=None,
+        insert_type="both",
+        filter_threshold=None,
+        buffer=4000,
+        **kwargs,
+    ):
+        if seq_ids is None:
+            seq_ids = {x: None for x in self.keys()}
+        elif isinstance(seq_ids, (list, tuple)):
+            seq_ids = {x: seq_ids for x in self.keys()}
+
+        if insert_ids is None:
+            insert_ids = {x: None for x in self.keys()}
+        elif isinstance(insert_ids, (list, tuple)):
+            insert_ids = {x: insert_ids for x in self.keys()}
+
+        genomes = set(seq_ids.keys()) | set(insert_ids.keys())
+
+        genes_dfs = [
+            self.__getitem__(g)
+            .genes_to_dataframe(
+                seq_ids=seq_ids.get(g),
+                insert_ids=insert_ids.get(g),
+                insert_type=insert_type,
+                filter_threshold=filter_threshold,
+                buffer=buffer,
+            )
+            .assign(genome=g)
+            for g in genomes
+        ]
+
+        if len(genes_dfs):
+            drop_by = ["start", "end", "type", "insert_idx", "seq_id", "genome"]
+            df_genes = pd.concat(genes_dfs, ignore_index=True).drop_duplicates(
+                subset=drop_by
+            )
+            df_genes.insert(0, "genome", df_genes.pop("genome"))
+            return df_genes
+
+    def get_graphic_features(
+        self,
+        seq_ids=None,
+        insert_ids=None,
+        genomes_order=None,
+        seq_labels=None,
+        show_contig_labels=True,
+        insert_type="both",
+        filter_threshold=None,
+        palette="tab10",
+        **kwargs,
+    ):
+        if seq_ids is None:
+            seq_ids = {x: None for x in self.keys()}
+        elif isinstance(seq_ids, (list, tuple)):
+            seq_ids = {x: seq_ids for x in self.keys()}
+
+        if insert_ids is None:
+            insert_ids = {x: None for x in self.keys()}
+        elif isinstance(insert_ids, (list, tuple)):
+            insert_ids = {x: insert_ids for x in self.keys()}
+
+        if genomes_order is None:
+            genomes_order = set(seq_ids.keys()) | set(insert_ids.keys())
+
+        if seq_labels is None:
+            seq_labels = {x: None for x in self.keys()}
+
+        palette = cycle(color_sequences[palette])
+
+        res = {
+            g: self.__getitem__(g).get_graphic_features(
+                seq_ids=seq_ids.get(g),
+                insert_ids=insert_ids.get(g),
+                insert_type=insert_type,
+                filter_threshold=filter_threshold,
+                contig_labels=show_contig_labels,
+                seq_labels=seq_labels.get(g),
+                col1=col,
+                col2=col,
+                linecolor=col,
+                **kwargs,
+            )
+            for g, col in zip(genomes_order, palette)
+        }
+
+        return res
+
+    def plot(
+        self,
+        seq_ids=None,
+        insert_ids=None,
+        genomes_order=None,
+        seq_labels=None,
+        insert_type="both",
+        filter_threshold=None,
+        feature_kwargs=None,
+        show_contig_labels=True,
+        show_titles=False,
+        palette="tab10",
+        facet_wrap=None,
+        fig=None,
+        **kwargs,
+    ):
+        feature_kwargs = {} if feature_kwargs is None else feature_kwargs
+
+        # Get the graphic feature objects
+        res = self.get_graphic_features(
+            seq_ids,
+            insert_ids,
+            genomes_order,
+            seq_labels,
+            show_contig_labels,
+            insert_type,
+            filter_threshold,
+            palette,
+            **feature_kwargs,
+        )
+
+        # Set all the plotting options based on input
+        if "figsize" not in kwargs:
+            kwargs["figsize"] = (10, 8)
+
+        genome_labels = res.keys()
+        num_genomes = len(genome_labels)
+
+        # Set the number of axes in the figure based on facet_wrap option
+        nrows, ncols = 1, 1
+        if facet_wrap is not None:
+            ncols = min(facet_wrap, num_genomes)
+            nrows = num_genomes // ncols
+
+        # Create figure and axes if not provided
+        if fig is None:
+            fig, axs = plt.subplots(nrows=nrows, ncols=ncols, **kwargs)
+        else:
+            axs = fig.get_axes()
+
+        # Check that axs is iterable even if a single axes object
+        if isinstance(axs, plt.Axes):
+            axs = np.array([axs])
+
+        # Make and label all the plots
+        if facet_wrap is None:
+            features = list(chain.from_iterable([x[1] for x in res.values()]))
+            rec = CircularGraphicRecord(max([x[0] for x in res.values()]), features)
+            _ = rec.plot(axs[0], annotate_inline=False)
+
+            if show_titles:
+                axs[0].set_title(", ".join(list(genome_labels)))
+
+        else:
+            for (label, (seq_len, features)), ax in zip(res.items(), axs.flatten()):
+                rec = CircularGraphicRecord(seq_len, features)
+                _ = rec.plot(ax, annotate_inline=False)
+
+                if show_titles:
+                    ax.set_title(label)
+
+            # Remove redundant axis
+            for ax in axs[num_genomes:]:
+                ax.axis("off")
+
+        return fig