update v0.5.6, add --show-mean-junction-number to explicit the display logic

Author: ygidtu

docs/command.md

@@ -102,13 +102,15 @@ Options:
     --local-domain TEXT           Load local domain folder and load into
                                   annotation track, download from https://hgdo
                                   wnload.soe.ucsc.edu/gbdb/hg38/uniprot/
+                                  [default: ""]
     --domain-include TEXT         Which domain will be included in annotation
                                   plot
     --domain-exclude TEXT         Which domain will be excluded in annotation
                                   plot
     --remove-empty                Whether to plot empty transcript
     --transcripts-to-show TEXT    Which transcript to show, transcript name or
                                   id in gtf file, eg: transcript1,transcript2
+                                  [default: ""]
     --choose-primary              Whether choose primary transcript to plot.
     --ref-color TEXT              The color of exons  [default: black]
     --intron-scale FLOAT          The scale of intron  [default: 0.5]
@@ -143,6 +145,8 @@ Options:
                                   all  [default: all]
     --included-junctions TEXT     The junction id for including, chr1:1-100
     --show-junction-num           Whether to show the number of junctions
+    --show-mean-junction-num      Whether to show the mean junction count
+                                  averaged across multiple samples.
     --fill-step [pre|post|mid]    Define step if the filling should be a step
                                   function, i.e. constant in between x.  The
                                   value determines where the step will occur:
@@ -286,7 +290,7 @@ Options:
                                   the following 4 columns is the weight of
                                   ATCG.
     --motif-region TEXT           The region of motif to plot in start-end
-                                  format
+                                  format  [default: ""]
     --motif-width FLOAT           The width of ATCG characters  [default: 0.8]
   Layout settings: 
     --n-y-ticks INTEGER RANGE     The number of ticks of y-axis  [x>=0]

docs/installation.md

@@ -163,7 +163,7 @@ trackplot --help
 
 ---
 
-#### 6. for `pipenv` or `poetry` users
+#### 6. for `uv` users
 
 > Install [uv](https://github.com/astral-sh/uv)  
 

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",
 ]
 
 

requirements.txt

@@ -33,7 +33,7 @@ numexpr>=2.11.0
 numpy>=2.3.0
 packaging>=25.0
 pandas>=2.3.0
-pillow>=11.3.0
+pillow>=11.2.1
 platformdirs>=4.3.8
 py-cpuinfo>=9.0.0
 pybigwig>=0.3.24
@@ -56,4 +56,4 @@ typing-extensions>=4.14.0
 tzdata>=2025.2
 urllib3>=2.5.0
 werkzeug>=3.1.3
-xmltodict>=0.14.2
+xmltodict>=1.0.2

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 @@ def __init__(self,
         :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 @@ def __add__(self, other):
             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,23 +171,23 @@ def add_customized_junctions(self, other):
         :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
 
     def transform(self, log_trans: str):
         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 @@ def normalize(self, size_factor: float, format_: str = "normal", read_length: fl
 
         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/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/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 @@ def load(self,
                                     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/file/Junction.py

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