trackplot 0.5.5__tar.gz → 0.5.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trackplot
-Version: 0.5.5
+Version: 0.5.7
 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.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "trackplot"
-version = "0.5.5"
+version = "0.5.7"
 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.7}/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.7}/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.7}/trackplot/file/Bam.py

@@ -27,18 +27,20 @@ def check_junction_exists(ref: List[Junction], dst: Junction, with_strand: bool
     u"""
     判断junction是否存在于included_junctions
     """
-    
-    ref = sorted([Junction.create_junction(x) for x in ref])
-    
+    ref = sorted([Junction.create_junction(x) for x in ref], key=lambda  x: (x.chromosome, x.start, x.end))
     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 i.is_downstream(dst):
             return False
         if i.eq(dst, with_strand):
             return True
-        
+        elif abs(i.start - dst.start) < 2 and abs(i.end - dst.end) < 2:
+            if (not with_strand) or (with_strand and i.strand == dst.strand):
+                # in outer code, this function will 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"
+                )
+
     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
@@ -307,10 +310,11 @@ class Bam(SingleCell):
                         logger.debug(f"{str(k)} is included")
                     else:
                         kept = check_junction_exists(included_junctions, k, with_strand=False)
-                        logger.debug(f"{str(k)} is included, but strand is ignored")
 
                         if not kept:
                             logger.debug(f"{str(k)} is not included")
+                        else:
+                            logger.debug(f"{str(k)} is included, but strand is ignored")
 
                 if kept:
                     if k.strand == "+":

{trackplot-0.5.5 → trackplot-0.5.7}/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.7}/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.7"
+__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,