trackplot 0.5.5__tar.gz → 0.5.6__tar.gz

{trackplot-0.5.5/trackplot.egg-info → trackplot-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trackplot
-Version: 0.5.5
+Version: 0.5.6
 Summary: The trackplot is a tool for visualizing various next-generation sequencing (NGS) data, including DNA-seq, RNA-seq, single-cell RNA-seq and full-length sequencing datasets. https://sashimi.readthedocs.io/
 Author-email: ygidtu <ygidtu@gmail.com>
 License-Expression: BSD-3-Clause
@@ -23,7 +23,7 @@ Requires-Dist: pysam>=0.23.3
 Requires-Dist: requests>=2.32.4
 Requires-Dist: scipy>=1.15.3
 Requires-Dist: seaborn>=0.13.2
-Requires-Dist: xmltodict>=0.14.2
+Requires-Dist: xmltodict>=0.15.0
 Dynamic: license-file
 
 # trackplot

{trackplot-0.5.5 → trackplot-0.5.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "trackplot"
-version = "0.5.5"
+version = "0.5.6"
 description = "The trackplot is a tool for visualizing various next-generation sequencing (NGS) data, including DNA-seq, RNA-seq, single-cell RNA-seq and full-length sequencing datasets. https://sashimi.readthedocs.io/"
 authors = [
     { name = "ygidtu", email = "ygidtu@gmail.com" }
@@ -25,7 +25,7 @@ dependencies = [
     "requests>=2.32.4",
     "scipy>=1.15.3",
     "seaborn>=0.13.2",
-    "xmltodict>=0.14.2",
+    "xmltodict>=0.15.0",
 ]
 
 

{trackplot-0.5.5 → trackplot-0.5.6}/trackplot/base/ReadDepth.py

@@ -21,13 +21,13 @@ class ReadDepth(object):
     """
 
     __slots__ = [
-        "_junction_dict_plus_", "_junction_dict_minus_",
-        "_minus_", "_plus_", "_number_of_merged_",
+        "__junction_dict__plus___", "__junction_dict__minus__",
+        "__minus__", "__plus__", "__number_of_merged__",
         "strand_aware", "site_plus", "site_minus",
     ]
 
     def __init__(self,
-                 wiggle: np.array,
+                 wiggle: np.ndarray,
                  site_plus: Optional[np.array] = None,
                  site_minus: Optional[np.array] = None,
                  minus: Optional[np.array] = None,
@@ -45,58 +45,65 @@ class ReadDepth(object):
         :param junction_dict_plus: these splice junction from plus strand
         :param junction_dict_minus: these splice junction from minus strand
         """
-        self._plus_ = wiggle
+        self.__plus__ = wiggle
         self.strand_aware = strand_aware
-        self._minus_ = abs(minus) if minus is not None else minus
-        self._junction_dict_plus_ = junction_dict_plus
-        self._junction_dict_minus_ = junction_dict_minus
+        self.__minus__ = abs(minus) if minus is not None else minus
+        self.__junction_dict__plus___ = junction_dict_plus
+        self.__junction_dict__minus__ = junction_dict_minus
         self.site_plus = site_plus
         self.site_minus = site_minus * -1 if site_minus is not None else site_minus
 
-        self._number_of_merged_ = 1
+        self.__number_of_merged__ = 1
 
     @property
     def plus(self) -> Optional[np.array]:
-        if self._plus_ is not None and self._number_of_merged_ > 0:
-            return self._plus_ / self._number_of_merged_
-        return self._plus_
+        if self.__plus__ is not None and self.__number_of_merged__ > 0:
+            return self.__plus__ / self.__number_of_merged__
+        return self.__plus__
 
     @property
     def minus(self) -> Optional[np.array]:
-        if self._minus_ is not None and self._number_of_merged_ > 0:
-            return self._minus_ / self._number_of_merged_
-        return self._minus_
+        if self.__minus__ is not None and self.__number_of_merged__ > 0:
+            return self.__minus__ / self.__number_of_merged__
+        return self.__minus__
 
     @property
-    def wiggle(self) -> np.array:
-        if (self._plus_ is None or not self._plus_.any()) and self._minus_ is not None:
+    def wiggle(self) -> np.ndarray:
+        if (self.__plus__ is None or not self.__plus__.any()) and self.__minus__ is not None:
             return self.minus
 
-        if self._plus_ is not None and self._minus_ is not None:
+        if self.__plus__ is not None and self.__minus__ is not None:
             return self.plus + self.minus
 
         return self.plus
 
     @property
-    def junctions_plus(self) -> dict:
-        if self._number_of_merged_ > 1:
-            return {k: v / self._number_of_merged_ for k, v in self._junction_dict_plus_.items()}
-        return self._junction_dict_plus_
+    def mean_junctions_plus(self) -> dict:
+        if self.__number_of_merged__ > 1:
+            return {k: v / self.__number_of_merged__ for k, v in self.__junction_dict__plus___.items()}
+        return self.__junction_dict__plus___
 
     @property
-    def junctions_minus(self) -> dict:
-        if self._number_of_merged_ > 1:
-            return {k: v / self._number_of_merged_ for k, v in self._junction_dict_minus_.items()}
-        return self._junction_dict_minus_
+    def mean_junctions_minus(self) -> dict:
+        if self.__number_of_merged__ > 1:
+            return {k: v / self.__number_of_merged__ for k, v in self.__junction_dict__minus__.items()}
+        return self.__junction_dict__minus__
 
-    @property
-    def junctions_dict(self) -> dict:
+    def junctions_dict(self, show_mean_jxn_number: bool = False) -> dict:
         res = {}
-        if self._junction_dict_plus_:
-            res.update(self.junctions_plus)
 
-        if self._junction_dict_minus_:
-            res.update(self.junctions_minus)
+        if show_mean_jxn_number:
+            if self.__junction_dict__plus___:
+                res.update(self.mean_junctions_plus)
+
+            if self.__junction_dict__minus__:
+                res.update(self.mean_junctions_minus)
+        else:
+            if self.__junction_dict__plus___:
+                res.update(self.__junction_dict__plus___)
+
+            if self.__junction_dict__minus__:
+                res.update(self.__junction_dict__minus__)
         return res
 
     @property
@@ -117,27 +124,27 @@ class ReadDepth(object):
             if len(self.wiggle) == len(other.wiggle):
                 junc_plus, junc_minus = {}, {}
 
-                for i in [self._junction_dict_plus_, other._junction_dict_plus_]:
+                for i in [self.__junction_dict__plus___, other.__junction_dict__plus___]:
                     if i:
                         junc_plus.update(i)
-                for i in [self._junction_dict_minus_, other._junction_dict_minus_]:
+                for i in [self.__junction_dict__minus__, other.__junction_dict__minus__]:
                     if i:
                         junc_minus.update(i)
 
                 minus = None
-                if self._minus_ is not None and other._minus_ is not None:
-                    minus = self._minus_ + other._minus_
-                elif self._minus_ is None and other._minus_ is not None:
+                if self.__minus__ is not None and other.__minus__ is not None:
+                    minus = self.__minus__ + other.__minus__
+                elif self.__minus__ is None and other.__minus__ is not None:
                     minus = other.minus
-                elif self._minus_ is not None and other._minus_ is None:
-                    minus = self._minus_
+                elif self.__minus__ is not None and other.__minus__ is None:
+                    minus = self.__minus__
 
                 merged = ReadDepth(
-                    self._plus_ + other._plus_, minus=minus,
+                    self.__plus__ + other.__plus__, minus=minus,
                     junction_dict_plus=junc_plus,
                     junction_dict_minus=junc_minus
                 )
-                merged._number_of_merged_ = self._number_of_merged_ + other._number_of_merged_
+                merged.__number_of_merged__ = self.__number_of_merged__ + other.__number_of_merged__
                 return merged
             else:
                 raise ValueError(f"ReadDepth objects are not equal length: {len(self.wiggle)} != {len(other.wiggle)}")
@@ -164,11 +171,11 @@ class ReadDepth(object):
         :return:
         """
 
-        for k, v in other._junction_dict_plus_:
-            self._junction_dict_plus_[k] = v + self._junction_dict_plus_.get(k, 0)
+        for k, v in other.__junction_dict__plus___:
+            self.__junction_dict__plus___[k] = v + self.__junction_dict__plus___.get(k, 0)
 
-        for k, v in other._junction_dict_minus_:
-            self._junction_dict_minus_[k] = v + self._junction_dict_minus_.get(k, 0)
+        for k, v in other.__junction_dict__minus__:
+            self.__junction_dict__minus__[k] = v + self.__junction_dict__minus__.get(k, 0)
 
         return self.junctions_dict
 
@@ -176,11 +183,11 @@ class ReadDepth(object):
         funcs = {"10": np.log10, "2": np.log2, "zscore": zscore, "e": np.log}
 
         if log_trans in funcs.keys():
-            if self._plus_ is not None:
-                self._plus_ = funcs[log_trans](self._plus_ + 1)
+            if self.__plus__ is not None:
+                self.__plus__ = funcs[log_trans](self.__plus__ + 1)
 
             if self.minus is not None:
-                self._minus_ = funcs[log_trans](self._minus_ + 1)
+                self.__minus__ = funcs[log_trans](self.__minus__ + 1)
 
     def normalize(self, size_factor: float, format_: str = "normal", read_length: float = 0):
         u"""
@@ -192,35 +199,35 @@ class ReadDepth(object):
 
         if format_ == "rpkm" and read_length > 0:
             # for rpkm the size_factor is total reads
-            self._plus_ = np.divide(
-                self._plus_,
+            self.__plus__ = np.divide(
+                self.__plus__,
                 np.multiply(
-                    (np.sum(self._plus_ != 0) - read_length + 1) / 1e3,
+                    (np.sum(self.__plus__ != 0) - read_length + 1) / 1e3,
                     size_factor / 1e6
                 )
             )
-            if self._minus_ is not None:
-                self._minus_ = np.divide(
-                    self._minus_,
+            if self.__minus__ is not None:
+                self.__minus__ = np.divide(
+                    self.__minus__,
                     np.multiply(
-                        (np.sum(self._minus_ != 0) - read_length + 1) / 1e3,
+                        (np.sum(self.__minus__ != 0) - read_length + 1) / 1e3,
                         size_factor / 1e6
                     )
                 )
             elif format_ == "cpm" and read_length > 0:
                 # for cpm the size_factor is total reads
-                self._plus_ = np.divide(self._plus_, np.divide(size_factor, 1e6))
-                if self._minus_ is not None:
-                    self._minus_ = np.divide(self._minus_, np.divide(size_factor, 1e6))
+                self.__plus__ = np.divide(self.__plus__, np.divide(size_factor, 1e6))
+                if self.__minus__ is not None:
+                    self.__minus__ = np.divide(self.__minus__, np.divide(size_factor, 1e6))
         elif format_ == "cpm" and read_length > 0:
             # for cpm the size_factor is total reads
-            self._plus_ = np.divide(self._plus_, np.divide(size_factor, 1e6))
-            if self._minus_ is not None:
-                self._minus_ = np.divide(self._minus_, np.divide(size_factor, 1e6))
+            self.__plus__ = np.divide(self.__plus__, np.divide(size_factor, 1e6))
+            if self.__minus__ is not None:
+                self.__minus__ = np.divide(self.__minus__, np.divide(size_factor, 1e6))
         elif size_factor is not None and size_factor > 0 and format_ == "atac":
-            self._plus_ = np.divide(self._plus_, size_factor)  # * 100
-            if self._minus_ is not None:
-                self._minus_ = np.divide(self._minus_, size_factor)
+            self.__plus__ = np.divide(self.__plus__, size_factor)  # * 100
+            if self.__minus__ is not None:
+                self.__minus__ = np.divide(self.__minus__, size_factor)
 
 
 if __name__ == '__main__':

{trackplot-0.5.5 → trackplot-0.5.6}/trackplot/cli.py

@@ -315,6 +315,8 @@ def process_file_list(infile: str, category: str = "density"):
                  help="The junction id for including, chr1:1-100", show_default=True)
 @optgroup.option("--show-junction-num", type=click.BOOL, is_flag=True, show_default=True,
                  help="Whether to show the number of junctions")
+@optgroup.option("--show-mean-junction-num", type=click.BOOL, is_flag=True, show_default=True,
+                 help="Whether to show the mean junction count averaged across multiple samples.")
 @optgroup.option("--fill-step", type=click.Choice(["pre", "post", "mid"]), default="post", show_default=True,
                  help="""
                  Define step if the filling should be a step function, i.e. constant in between x. 
@@ -523,8 +525,6 @@ def main(**kwargs):
 
     size_factors = {}
 
-    # add annotation
-    # print(kwargs.keys())
     for key in kwargs.keys():
         if key in IMAGE_TYPE and kwargs[key] and os.path.exists(kwargs[key]):
             if key == "annotation":
@@ -573,6 +573,7 @@ def main(**kwargs):
                                           color=sc_colors.get(group, f.color),
                                           font_size=kwargs["font_size"],
                                           show_junction_number=kwargs["show_junction_num"],
+                                          show_mean_jxn_number=kwargs["show_mean_junction_num"],
                                           n_y_ticks=kwargs["n_y_ticks"],
                                           show_y_label=not kwargs["hide_y_label"],
                                           show_site_plot=kwargs["show_site"],
@@ -591,6 +592,7 @@ def main(**kwargs):
                                       color=f.color,
                                       font_size=kwargs["font_size"],
                                       show_junction_number=kwargs["show_junction_num"],
+                                      show_mean_jxn_number=kwargs["show_mean_junction_num"],
                                       n_y_ticks=kwargs["n_y_ticks"],
                                       show_y_label=not kwargs["hide_y_label"],
                                       show_site_plot=kwargs["show_site"],

{trackplot-0.5.5 → trackplot-0.5.6}/trackplot/file/Bam.py

@@ -32,7 +32,9 @@ def check_junction_exists(ref: List[Junction], dst: Junction, with_strand: bool
     
     for i in ref:
         if abs(i.start - dst.start) < 2 and abs(i.end - dst.end) < 2:
-            logger.warning(f"1 bp mismatch between {i} (from bam file) and {dst} (user input), please check the coordinates")
+            if not with_strand:
+                # in outer code, this function will called twice, with with_strand = True and False. therefore, only print log once is enough
+                logger.warning(f"1 bp mismatch between {i} (from bam file) and {dst} (user input), please check the coordinates")
         
         if i.is_downstream(dst):
             return False
@@ -269,7 +271,8 @@ class Bam(SingleCell):
                                     logger.info(region)
                                     logger.info(cigar_string)
                                     logger.info(start, i)
-                                    exit(err)
+                                    logger.error(err)
+                                    exit(1)
 
                     # remove the deletion.
                     if cigar not in (1, 4, 5):  # I, S, H

{trackplot-0.5.5 → trackplot-0.5.6}/trackplot/file/Junction.py

@@ -5,7 +5,6 @@ u"""
 Handle the customized junction
 """
 import os
-import re
 from typing import Dict
 
 from trackplot.base.Junction import Junction

{trackplot-0.5.5 → trackplot-0.5.6}/trackplot/plot.py

@@ -30,8 +30,8 @@ logging.getLogger('matplotlib.font_manager').setLevel(logging.ERROR)
 faulthandler.enable()
 
 
-__version__ = "0.5.5"
-__author__ = "ygidtu & Ran Zhou"
+__version__ = "0.5.6"
+__author__ = "Yiming Zhang & Ran Zhou"
 __email__ = "ygidtu@gmail.com"
 
 
@@ -572,6 +572,7 @@ class Plot(object):
                     color="blue",
                     font_size: int = 8,
                     show_junction_number: bool = True,
+                    show_mean_jxn_number: bool = False,
                     junction_number_font_size: int = 5,
                     n_y_ticks: int = 4,
                     show_y_label: bool = True,
@@ -601,6 +602,7 @@ class Plot(object):
         :param library: should be one of [frf: "fr-firststrand", frs:"fr-secondstrand", fru:"fr-unstrand"], default: fru
         :param font_size: the font size for ticks, y-axis label and title
         :param show_junction_number: whether to show the number of junctions
+        :param show_mean_jxn_number:
         :param n_y_ticks: number of y ticks
         :param junction_number_font_size:
         :param color: color for this density plot
@@ -652,6 +654,7 @@ class Plot(object):
             self.plots.append(info)
             self.params[info] = {
                 "show_junction_number": show_junction_number,
+                "show_mean_jxn_number": show_mean_jxn_number,
                 "junction_number_font_size": junction_number_font_size,
                 "color": color,
                 "font_size": font_size,

{trackplot-0.5.5 → trackplot-0.5.6}/trackplot/plot_func.py

@@ -5,10 +5,10 @@ This script contains the functions to draw different images
 Modified by AD 2025/01/13
 """
 import itertools # AD - for cumulative sum of graph_coords
-#import gzip
+import gzip
 import math
 from copy import deepcopy
-#from decimal import Decimal
+
 from typing import Dict, List, Optional, Union, Tuple, Set
 
 import matplotlib as mpl
@@ -27,7 +27,6 @@ from matplotlib.textpath import TextPath
 from matplotlib.transforms import Affine2D
 from scipy.cluster.hierarchy import dendrogram, linkage
 from scipy.stats import gaussian_kde, zscore
-from scipy.stats import beta # AD
 
 from trackplot.anno.theme import Theme
 from trackplot.base.GenomicLoci import GenomicLoci
@@ -126,7 +125,7 @@ def __merge_exons__(exons: List[List[int]]):
 
 
 def init_graph_coords(region: GenomicLoci, exons: Optional[List[List[int]]] = None, exon_scale=1,
-                      intron_scale=0.5) -> np.array:
+                      intron_scale=0.5) -> np.ndarray:
     u"""
     init the default
     :param region: the plot region
@@ -169,7 +168,7 @@ def init_graph_coords(region: GenomicLoci, exons: Optional[List[List[int]]] = No
                 exons = exons[:-1]
             exons[0][0] = max(exons[0][0], region.start)
             exons[-1][1] = min(exons[-1][1], region.end)
-            last_interval = region.end - exons[-1][1]
+
             for i, e in enumerate(exons):
                 exons[i][0] -= region.start
                 exons[i][1] -= region.start
@@ -184,7 +183,7 @@ def init_graph_coords(region: GenomicLoci, exons: Optional[List[List[int]]] = No
                 step = intron_scale / interval
                 for i in range(exons[e-1][1], exons[e][0]):
                     steps[i] = step
-                interval = exons[e][0] - exons[e-1][1] - 2
+
             if last_interval := len(region) - exons[-1][1] - 1:
                 step = intron_scale / last_interval
                 for i in range(exons[1][1] +1, len(region)):
@@ -204,7 +203,7 @@ def init_graph_coords(region: GenomicLoci, exons: Optional[List[List[int]]] = No
     return graph_coords
 
 def set_x_ticks(
-        ax: mpl.axes.Axes,
+        ax,
         region: GenomicLoci,
         graph_coords: Optional[Union[Dict, np.ndarray]] = None,
         sequence: Optional[Dict[int, str]] = None,
@@ -263,7 +262,7 @@ def set_x_ticks(
 
 
 def set_y_ticks(
-        ax: mpl.axes.Axes,
+        ax,
         label: str,
         graph_coords: Union[Dict, np.array],
         max_used_y_val: Union[int, float],
@@ -274,7 +273,6 @@ def set_y_ticks(
         font_size: int = 5,
         show_y_label: bool = True,
         set_label_only: bool = False,
-        y_axis_skip_zero: bool = True,
         **kwargs
 ):
     u"""
@@ -355,7 +353,7 @@ def set_y_ticks(
 
 
 def set_focus(
-        ax: mpl.axes.Axes,
+        ax,
         graph_coords: Union[Dict, np.array],
         focus: Dict[int, int]
 ):
@@ -372,7 +370,7 @@ def set_focus(
 
 
 def set_indicator_lines(
-        ax: mpl.axes.Axes,
+        ax,
         graph_coords: Union[Dict, np.array],
         sites: Dict[int, str],
         min_y_used: Union[int, float] = 0,
@@ -399,7 +397,7 @@ def set_indicator_lines(
 
 
 def plot_stroke(
-        ax: mpl.axes.Axes,
+        ax,
         data: List[Stroke],
         graph_coords: Optional[Union[Dict, np.ndarray]] = None,
         font_size: int = 5,
@@ -425,7 +423,7 @@ def plot_stroke(
 
 
 def plot_annotation(
-        ax: mpl.axes.Axes,
+        ax,
         obj: Annotation,
         graph_coords: Optional[Union[Dict, np.ndarray]] = None,
         font_size: int = 5,
@@ -650,7 +648,7 @@ def plot_annotation(
 
 
 def plot_density(
-        ax: mpl.axes.Axes,
+        ax,
         obj: Optional[File] = None,
         data: Optional[ReadDepth] = None,
         region: Optional[GenomicLoci] = None,
@@ -658,6 +656,7 @@ def plot_density(
         color="blue",
         font_size: int = 8,
         show_junction_number: bool = True,
+        show_mean_jxn_number: bool = False,
         junction_number_font_size: int = 12,
         n_y_ticks: int = 4,
         distance_between_label_axis: float = .1,
@@ -665,34 +664,11 @@ def plot_density(
         y_label: str = "",
         theme: str = "ticks_blank",
         max_used_y_val: Optional[float] = None,
-        min_used_y_val: Optional[float] = None,
         raster: bool = False,
         fill_step: str = "post",
         **kwargs
 ):
-    u"""
-    draw density plot
-    :param ax: mpl.axes.Axes
-    :param data: File
-    :param data: ReadDepth
-    :param region: GenomicLoci
-    :param graph_coords:
-    :param font_size: the font size for ticks, y-axis label and title
-    :param show_junction_number: whether to show the number of junctions
-    :param distance_between_label_axis: distance between y-axis label and y-axis ticks
-    :param n_y_ticks: number of y ticks
-    :param junction_number_font_size:
-    :param obj: Bam or Bigwig object
-    :param color: color for this density plot
-    :param show_y_label: whether to show y-axis label
-    :param y_label: the text of y-axis title
-    :param theme: the theme name
-    :param max_used_y_val: used to set same max y-axis
-    :param raster:
-    :param fill_step:
-    :param kwargs:
-    :return:
-    """
+    u""" draw density plot """
     # max_used_y_val is None
     # distance_between_label_axis: 0
     if obj:
@@ -711,21 +687,21 @@ def plot_density(
         data = obj.data
 
     try:
-        jxns = data.junctions_dict
+        jxns = data.junctions_dict(show_mean_jxn_number)
     except AttributeError:
         # depth do not have junctions
         jxns = {}
-    
+
     # AD - convert junction counts to log scale early if requested
+    jxn_number_log_transformed = False
     if obj.log_trans and obj.log_trans.isdigit() and int(obj.log_trans) > 0: # in ["2", "10"]:
-
+        jxn_number_log_transformed = True
         y_label += f" (log{obj.log_trans})"
         denominator = np.log(int(obj.log_trans))
         for k, v in jxns.items():
             jxns[k] = np.log1p(v)  / denominator
 
     min_used_y_val = 0 # AD
-    fixed_min_used_y = True #  AD
     fixed_max_used_y, fixed_min_used_y = max_used_y_val is not None, min_used_y_val is not None
     if max_used_y_val is None:
         if isinstance(data, dict):
@@ -792,15 +768,11 @@ def plot_density(
             add two new variables to make it clear which one is index, which one is genomic site 
             """
             ss1, ss2 = graph_coords[ss1_idx], graph_coords[ss2_idx]
-            # AD = keep junction arcs on top
-            jxn_on_top = True
-
             # draw junction on bottom 
             if kwargs.get("density_by_strand"):
                 jxn_on_top = jxn.strand == "+"
             else:
                 jxn_on_top = jxn_idx % 2 == 0
-                #jxn_on_top = True # AD - keep all junctions on same strand
                 if abs(min_used_y_val) < max_used_y_val:
                     min_used_y_val = -max_used_y_val
             
@@ -846,9 +818,15 @@ def plot_density(
             if show_junction_number:
                 midpt = cubic_bezier(pts, .5)
 
+                val = jxns[jxn]
+                if jxn_number_log_transformed or show_mean_jxn_number:
+                    val = round(val, 2)
+                else:
+                    val = int(val)
+
                 t = ax.text(
                     midpt[0], midpt[1],
-                    '{0}'.format(round(jxns[jxn], 2)),
+                    '{0}'.format(val),
                     fontsize=junction_number_font_size,
                     ha='center', va='center',
                     backgroundcolor='w'
@@ -893,7 +871,7 @@ def plot_density(
 
 
 def plot_site_plot(
-        ax: mpl.axes.Axes,
+        ax,
         obj: File,
         graph_coords: Optional[Union[Dict, np.ndarray]] = None,
         color="blue",
@@ -975,8 +953,8 @@ def plot_site_plot(
 
 
 def plot_heatmap(
-        ax: mpl.axes.Axes,
-        cbar_ax: mpl.axes.Axes,
+        ax,
+        cbar_ax,
         data: Dict[str, ReadDepth],
         graph_coords: Optional[Union[Dict, np.ndarray]] = None,
         color="viridis",
@@ -1067,8 +1045,8 @@ def plot_heatmap(
 
 
 def plot_hic(
-        ax: mpl.axes.Axes,
-        cbar_ax: mpl.axes.Axes,
+        ax,
+        cbar_ax,
         obj: List[HiCTrack],
         show_legend: bool = True,
         graph_coords: Optional[Union[Dict, np.ndarray]] = None,
@@ -1142,7 +1120,7 @@ def plot_hic(
 
 
 def plot_line(
-        ax: mpl.axes.Axes,
+        ax,
         data: Dict[str, ReadDepth],
         graph_coords: Union[Dict, np.ndarray],
         font_size: int = 8,
@@ -1222,7 +1200,7 @@ def plot_line(
 
 
 def plot_igv_like(
-        ax: mpl.axes.Axes,
+        ax,
         obj: Dict[str, ReadSegment],
         graph_coords: Optional[Union[Dict, np.ndarray]] = None,
         y_label: str = "",
@@ -1356,7 +1334,7 @@ def plot_igv_like(
     )
 
 
-def plot_links(ax: mpl.axes.Axes,
+def plot_links(ax,
                data: List[Stroke],
                graph_coords: Optional[Union[Dict, np.ndarray]] = None,
                max_y: int = -10, **kwargs):
@@ -1394,7 +1372,7 @@ def make_text_elements(text, x=0.0, y=0.0, width=1.0, height=1.0,
     return PathPatch(tp, facecolor=color, edgecolor=edgecolor)
 
 
-def plot_motif(ax: mpl.axes.Axes,
+def plot_motif(ax,
                obj,  # list of weighted text
                graph_coords: Optional[Union[Dict, np.ndarray]] = None,
                width: float = 0.8,

{trackplot-0.5.5 → trackplot-0.5.6/trackplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trackplot
-Version: 0.5.5
+Version: 0.5.6
 Summary: The trackplot is a tool for visualizing various next-generation sequencing (NGS) data, including DNA-seq, RNA-seq, single-cell RNA-seq and full-length sequencing datasets. https://sashimi.readthedocs.io/
 Author-email: ygidtu <ygidtu@gmail.com>
 License-Expression: BSD-3-Clause
@@ -23,7 +23,7 @@ Requires-Dist: pysam>=0.23.3
 Requires-Dist: requests>=2.32.4
 Requires-Dist: scipy>=1.15.3
 Requires-Dist: seaborn>=0.13.2
-Requires-Dist: xmltodict>=0.14.2
+Requires-Dist: xmltodict>=0.15.0
 Dynamic: license-file
 
 # trackplot