coolbox 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

coolbox/__init__.py

@@ -1 +1 @@
-__version__ = '0.3.7'
+__version__ = '0.3.9'

coolbox/cli.py

@@ -250,7 +250,6 @@ class CLI(object):
     def print_source(self):
         """Print the browser composing code."""
         print(self.source())
-        return self
 
     def gen_notebook(self, notebook_path, notes=True, figsave=True):
         """Generate The notebook contain codes for run coolbox browser.
@@ -288,7 +287,6 @@ class CLI(object):
             )
         nb['cells'] = cells
         nbf.write(nb, notebook_path)
-        return self
 
     def run_jupyter(self, jupyter_args="--ip=0.0.0.0"):
         """Create a notebook according to command line, then start a jupyter process.

coolbox/core/browser/base.py

@@ -43,8 +43,9 @@ class Browser(object):
         dpi : int, optional
             The dpi of frame's image.
 
-        img_format : str, optional
-            Frame image format, default svg.
+        img_format : {'svg', 'png'}
+            Image format for browser display, default svg.
+            NOTE: This argument not for saving image.
         """
 
         self.dpi = dpi
@@ -251,6 +252,8 @@ class Browser(object):
     def save(self, path, dpi=None):
         """
         Save current frame's image to file.
+        The suffix of the path will changing the saving format.
+        For example: `bsr.save("fig.png")` will save file to 'png' format.
         """
         c_fig = self.frame.show()
         dpi = dpi or self.dpi

coolbox/core/coverage/__init__.py

@@ -3,7 +3,7 @@ from .vlines import Vlines, VlinesFromFile
 from .hlines import HLines
 
 from .base import track_to_coverage
-from ..track.bed import TAD
+from ..track.tad import TAD
 from ..track.hist import Hist, BigWig, BedGraph
 from ..track.arcs import Arcs, Pairs, BEDPE, HiCPeaks
 

coolbox/core/coverage/highlights.py

@@ -87,9 +87,9 @@ class HighLightsFromFile(Coverage, _Highlights):
             "file": file_,
             "color": "bed_rgb",
             "alpha": 0.1,
-            "border_line": True,
+            "border_line": False,
             "border_line_style": "dashed",
-            "border_line_width": 0,
+            "border_line_width": 2,
             "border_line_color": "#000000",
             "border_line_alpha": 0.8,
         }
@@ -168,9 +168,9 @@ class HighLights(Coverage, _Highlights):
             "highlight_regions": highlight_regions,
             "color": HighLights.DEFAULT_COLOR,
             "alpha": 0.25,
-            "border_line": True,
+            "border_line": False,
             "border_line_style": "dashed",
-            "border_line_width": 0,
+            "border_line_width": 2,
             "border_line_color": "#000000",
             "border_line_alpha": 0.8,
         }

coolbox/core/frame/frame.py

@@ -137,8 +137,18 @@ class Frame(FrameBase):
         heights = []
         for track in self.tracks.values():
             if hasattr(track, 'get_track_height'):
-                frame_width = self.properties['width'] * self.properties['width_ratios'][1]
-                height = track.get_track_height(frame_width)
+                # The actual width is given by multiplying:
+                # - the actual width in units cm/inch
+                # - the fraction of the figure not covered by margins
+                # - the fraction of the grid allotted to the middle column
+                margins = self.properties["margins"]
+                margins_fraction = margins["right"] - margins["left"]
+                frame_width = (
+                    self.properties["width"]
+                    * self.properties["width_ratios"][1]
+                    * margins_fraction
+                )
+                height = track.get_track_height(frame_width, self.current_range)
                 heights.append(height)
             elif 'height' in track.properties:
                 heights.append(track.properties['height'])
@@ -146,7 +156,7 @@ class Frame(FrameBase):
                 heights.append(default_height)
         return heights
 
-    def plot(self, *args):
+    def plot(self, *args, close_fig=True):
         """
         Plot all tracks.
 
@@ -186,8 +196,7 @@ class Frame(FrameBase):
         grids = matplotlib.gridspec.GridSpec(
             len(tracks_height), 3,
             height_ratios=tracks_height,
-            width_ratios=self.properties['width_ratios'],
-            wspace=0.01)
+            width_ratios=self.properties['width_ratios'])
 
         axis_list = []
         for idx, track in enumerate(self.tracks.values()):
@@ -231,7 +240,8 @@ class Frame(FrameBase):
                             bottom=margins['bottom'],
                             top=margins['top'])
 
-        plt.close()
+        if close_fig:
+            plt.close()
 
         return fig
 

coolbox/core/track/__init__.py

@@ -3,7 +3,8 @@ from .bam import BAM
 from .gtf import GTF
 from .ideogram import Ideogram
 from .pseudo import Spacer, HLine, XAxis, ChromName
-from .bed import BedBase, BED, TAD  # no all-in class/function
+from .bed import BedBase, BED  # no all-in class/function
+from .tad import TAD
 from .hicmat import HicMatBase, Cool, DotHiC, HiCDiff, Selfish, HiCMat
 from .hist import HistBase, BedGraph, BigWig, ABCompartment, DiScore, InsuScore, Virtual4C, BAMCov, SNP, Hist
 from .arcs import ArcsBase, Pairs, BEDPE, HiCPeaks, Arcs

coolbox/core/track/arcs/plot.py

@@ -103,8 +103,12 @@ class PlotContacts(object):
             center = (start + end) / 2
             ax.plot([center], [diameter])
             arc = Arc(
-                (center, 0), diameter,
-                height, 0, 0, 180,
+                xy=(center, 0), 
+                width=diameter,
+                height=height, 
+                angle=0, 
+                theta1=0, 
+                theta2=180,
                 color=color,
                 alpha=alpha,
                 lw=line_width,

coolbox/core/track/bed/__init__.py

@@ -1,3 +1,2 @@
 from .bed import BedBase
 from .bed import BED
-from .tad import TAD

coolbox/core/track/bed/base.py

@@ -1,28 +1,24 @@
+from typing import Union
+
 import pandas as pd
+import matplotlib
 
-from coolbox.utilities import (
-    get_logger
-)
+from coolbox.utilities import get_logger
+from coolbox.utilities.bed import build_bed_index
 from coolbox.utilities.genome import GenomeRange
-
 from coolbox.core.track.base import Track
-from .plot import PlotBed
 
 log = get_logger(__name__)
 
 
-class BedBase(Track, PlotBed):
+class BedBase(Track):
     """
     BED Base track.
 
     Parameters
     ----------
-    style : {'gene', 'tad'}
-
-    gene_style: {'flybase', 'normal'}
-
-    display : {'stacked', 'interlaced', 'collapsed'}, optional
-        Display mode. (Default: 'stacked')
+    file: str
+        The file path of `.bed` file.
 
     color : str, optional
         Track color, 'bed_rgb' for auto specify color according to bed record.
@@ -31,86 +27,32 @@ class BedBase(Track, PlotBed):
     border_color : str, optional
         Border_color of gene. (Default: 'black')
 
-    fontsize : int, optional
-        Font size. (Default: BED.DEFAULT_FONTSIZE)
-
-    labels : {True, False, 'auto'}, optional
-        Draw bed name or not. 'auto' for automate decision according to density.
-        (Default: 'auto')
-
-    interval_height : int, optional
-        The height of the interval. (Default: 100)
-
-    num_rows : int, optional
-        Set the max interval rows. (Default: unlimited interval rows)
-
     max_value : float, optional
         Max score. (Default: inf)
 
     min_value : float, optional
         Min score. (Default: -inf)
 
-    border_style: str, optional
-        Border style of tad. (Default: 'solid')
-
-    border_width: int, optional
-        Border width of tad. (Default: '2.0')
-
-    show_score : bool
-        Show bed score or not.
-        default False.
-
-    score_font_size : {'auto', int}
-        Score text font size.
-        default 'auto'
-
-    score_font_color : str
-        Score text color.
-        default '#000000'
-
-    score_height_ratio : float
-        (text tag height) / (TAD height). used for adjust the position of Score text.
-        default 0.5
-
-    border_only : bool
-        Only show border, default False
-
     """
 
-    STYLE_GENE = "gene"
-    STYLE_TAD = "tad"
-
     COLOR = "#1f78b4"
 
     DEFAULT_PROPERTIES = {
-        'style': STYLE_GENE,
-        # gene
-        'gene_style': 'flybase',
-        'display': 'stacked',
         'color': "bed_rgb",
         'border_color': "#1f78b4",
-        'fontsize': 12,
-        'interval_height': 100,
-        'num_rows': None,
-        'labels': 'off',
         'min_score': '-inf',
         'max_score': 'inf',
         'bed_type': None,
-        # tad
-        'border_style': "--",
-        'border_width': 2.0,
-        "show_score": False,
-        "score_font_size": 'auto',
-        "score_font_color": "#000000",
-        "score_height_ratio": 0.4,
-        "border_only": False,
     }
 
-    def __init__(self, **kwargs):
+    def __init__(self, file, **kwargs):
         properties = BedBase.DEFAULT_PROPERTIES.copy()
-        properties.update(kwargs)
+        properties.update({
+            'file': file,
+            **kwargs
+        })
         super().__init__(properties)
-        self.init_for_plot()
+        self.bgz_file = build_bed_index(file)
 
     def fetch_data(self, gr: GenomeRange, **kwargs) -> pd.DataFrame:
         """
@@ -128,17 +70,83 @@ class BedBase(Track, PlotBed):
             The table can be in bed6/bed9/bed12 format and the trailing columns can be omited.
 
         """
-        raise NotImplementedError
-
-    def plot(self, ax, gr: GenomeRange, **kwargs):
-        self.ax = ax
-        ov_intervals: pd.DataFrame = self.fetch_plot_data(gr, **kwargs)
-
-        style = self.properties['style']
-        if style == self.STYLE_TAD:
-            self.plot_tads(ax, gr, ov_intervals)
-        elif style == self.STYLE_GENE:
-            self.plot_genes(ax, gr, ov_intervals)
+        return self.fetch_intervals(self.bgz_file, gr)
+
+    def init_colormap(self):
+        self.colormap = None
+        if not matplotlib.colors.is_color_like(self.properties['color']) and self.properties['color'] != 'bed_rgb':
+            if self.properties['color'] not in matplotlib.cm.datad:
+                log.debug("*WARNING* color: '{}' for Track {} is not valid. Color has "
+                          "been set to {}".format(self.properties['color'], self.properties['name'],
+                                                    self.COLOR))
+                self.properties['color'] = self.COLOR
+            else:
+                self.colormap = self.properties['color']
+
+    def set_colormap(self, df):
+        """As min_score and max_score change every plot, we compute them for every plot"""
+        props = self.properties
+        min_score, max_score = props['min_score'], props['max_score']
+        has_score_col = props['bed_type'] in ('bed6', 'bed9', 'bed12')
+        if has_score_col and (df.shape[0] > 0):
+            min_score = (min_score != 'inf') or df['score'].min()
+            max_score = (max_score != '-inf') or df['score'].max()
+        min_score, max_score = float(min_score), float(max_score)
+        # set colormap
+        if self.colormap is not None:
+            norm = matplotlib.colors.Normalize(vmin=min_score, vmax=max_score)
+            cmap = matplotlib.cm.get_cmap(props['color'])
+            self.colormap = matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap)
+        if props['color'] == 'bed_rgb' and props['bed_type'] not in ['bed12', 'bed9']:
+            log.debug("*WARNING* Color set to 'bed_rgb', but bed file does not have the rgb field. The color has "
+                      "been set to {}".format(self.COLOR))
+            self.properties['color'] = self.COLOR
+            self.colormap = None
+
+    def get_rgb_and_edge_color(self, bed):
+        # TODO need simplification
+        props = self.properties
+        rgb = props['color']
+        edgecolor = props['border_color']
+
+        if self.colormap:
+            # translate value field (in the example above is 0 or 0.2686...) into a color
+            rgb = self.colormap.to_rgba(bed.score)
+
+        # for tad coverage
+        if props.get('border_only', 'no') == 'yes':
+            rgb = 'none'
+        elif props['color'] == 'bed_rgb':
+            # if rgb is set in the bed line, this overrides the previously
+            # defined colormap
+            if props['bed_type'] in ['bed9', 'bed12'] and len(bed.rgb) == 3:
+                try:
+                    rgb = [float(x) / 255 for x in bed.rgb]
+                    if 'border_color' in props:
+                        edgecolor = props['border_color']
+                    else:
+                        edgecolor = props['color']
+                except IndexError:
+                    rgb = self.COLOR
+            else:
+                rgb = self.COLOR
+        return rgb, edgecolor
+
+    @staticmethod
+    def infer_bed_type(df: pd.DataFrame) -> Union[str, None]:
+        #  bed_type of dataframe are store in dataframe's __dict__ in FetchBed.fetch_intervals
+        if 'bed_type' in df.__dict__:
+            bed_type = df.bed_type
         else:
-            raise ValueError("style not supportted, should be one of 'gene' 'tad' ")
-        self.plot_label()
+            bed_types = {
+                12: 'bed12',
+                9: 'bed9',
+                6: 'bed6',
+                3: 'bed3'
+            }
+            num_col = len(df.columns)
+            bed_type = bed_types[num_col] if num_col in bed_types else 'bed3'
+            if bed_type == 'bed3' and num_col < 3:
+                raise ValueError(f"Invalid dataframe for bed3 with columns: {df.columns}")
+        return bed_type
+

coolbox/core/track/bed/bed.py

@@ -3,39 +3,60 @@ from coolbox.utilities import (
     get_logger
 )
 from coolbox.utilities.genome import GenomeRange
-from coolbox.utilities.bed import build_bed_index
 from .base import BedBase
+from .plot import PlotGenes
 
 log = get_logger(__name__)
 
 
-class BED(BedBase, FetchBed):
+class BED(BedBase, PlotGenes, FetchBed):
     """
     Bed Track for plotting 1d intervals data from .bed file.
     The input bed file can be bed3/bed6/bed9/bed12
 
     Parameters
     ----------
-    file: str
-        The file path of `.bed` file.
+    gene_style: {'flybase', 'normal'}
 
+    display : {'stacked', 'interlaced', 'collapsed'}, optional
+        Display mode. (Default: 'stacked')
 
+    fontsize : int, optional
+        Font size. (Default: BED.DEFAULT_FONTSIZE)
+
+    labels : {True, False, 'auto'}, optional
+        Draw bed name or not. 'auto' for automate decision according to density.
+        (Default: 'auto')
+
+    interval_height : int, optional
+        The height of the interval. (Default: 100)
+
+    num_rows : int, optional
+        Set the max interval rows. (Default: unlimited interval rows)
+
+    row_height : float
+        Height of a row. default 0.5
     """
 
     DEFAULT_PROPERTIES = {
-        'labels': "on",
+        'labels': 'auto',
+        'height': 'auto',
+        'gene_style': 'flybase',
+        'display': 'stacked',
+        'fontsize': 12,
+        'interval_height': 100,
+        'num_rows': None,
+        'row_height': 0.5,
     }
 
     def __init__(self, file, **kwargs):
         properties = BED.DEFAULT_PROPERTIES.copy()
-        properties.update({
-            'file': file,
-            **kwargs
-        })
-        super().__init__(**properties)
-        self.bgz_file = build_bed_index(file)
-
-    def fetch_data(self, gr: GenomeRange, **kwargs):
-        return self.fetch_intervals(self.bgz_file, gr)
-
-
+        properties.update(kwargs)
+        super().__init__(file, **properties)
+        PlotGenes.__init__(self)
+
+    def plot(self, ax, gr: GenomeRange, **kwargs):
+        self.ax = ax
+        ov_intervals: pd.DataFrame = self.fetch_plot_data(gr, **kwargs)
+        self.plot_genes(ax, gr, ov_intervals)
+        self.plot_label()

coolbox/core/track/bed/fetch.py

@@ -34,7 +34,7 @@ class FetchBed(object):
         try:
             bed_iterator = ReadBed(query_bed(bgz_file, gr.chrom, gr.start, gr.end))
         except StopIteration:
-            log.info(f"No records in the range {str(gr)}")
+            log.debug(f"No records in the range {str(gr)}")
             return [], None
 
         intervals = [bed for bed in bed_iterator]