marsilea 0.3.0rc2__tar.gz → 0.3.2__tar.gz

{marsilea-0.3.0rc2 → marsilea-0.3.2}/.github/workflows/build.yaml

@@ -57,14 +57,14 @@ jobs:
       - name: Publish to test.ipynb pypi
         env:
           FLIT_INDEX_URL: https://test.ipynb.pypi.org/legacy/
-          FLIT_USERNAME: ${{ secrets.PYPI_USERNAME }}
-          FLIT_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+          FLIT_USERNAME: __token__
+          FLIT_PASSWORD: ${{ secrets.PYPI_TOKEN }}
         run: flit publish || exit 0
 
       - name: Publish to pypi
         if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/v')
         env:
           FLIT_INDEX_URL: https://upload.pypi.org/legacy/
-          FLIT_USERNAME: ${{ secrets.PYPI_USERNAME }}
-          FLIT_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+          FLIT_USERNAME: __token__
+          FLIT_PASSWORD: ${{ secrets.PYPI_TOKEN }}
         run: flit publish

{marsilea-0.3.0rc2 → marsilea-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: marsilea
-Version: 0.3.0rc2
+Version: 0.3.2
 Summary: Create x-layout visualization
 Author: Zhihang Zheng
 Author-email: Mr-Milk <yb97643@um.edu.mo>

{marsilea-0.3.0rc2 → marsilea-0.3.2}/examples/plot_seqalign.py

@@ -1,6 +1,6 @@
 """
-DNA Sequence Alignment Plot
-===========================
+Sequence Alignment Plot
+=======================
 """
 from collections import Counter
 import numpy as np

{marsilea-0.3.0rc2 → marsilea-0.3.2}/marsilea/__init__.py

@@ -1,6 +1,6 @@
 """Create x-layout visualization"""
 
-__version__ = "0.3.0rc2"
+__version__ = "0.3.2"
 
 from ._deform import Deformation
 from .base import WhiteBoard, ClusterBoard

{marsilea-0.3.0rc2 → marsilea-0.3.2}/marsilea/_deform.py

@@ -1,3 +1,5 @@
+from typing import Mapping
+
 import numpy as np
 
 from .dendrogram import Dendrogram, GroupDendrogram
@@ -25,9 +27,13 @@ class Deformation:
 
     row_breakpoints = None
     col_breakpoints = None
+    row_split_order = None
+    col_split_order = None
 
     row_dendrogram = None
     col_dendrogram = None
+    row_linkage = None  # User supplied linkage
+    col_linkage = None
 
     row_reorder_index = None
     col_reorder_index = None
@@ -73,17 +79,20 @@ class Deformation:
         self.data_col_reindex = reindex
         self._col_clustered = False
 
-    def set_cluster(self, col=None, row=None, use_meta=True, **kwargs):
+    def set_cluster(self, col=None, row=None, use_meta=True,
+                    linkage=None, **kwargs):
         if col is not None:
             self.is_col_cluster = col
             self.col_cluster_kws = kwargs
             self._col_clustered = False
             self._use_col_meta = use_meta
+            self.col_linkage = linkage
         if row is not None:
             self.is_row_cluster = row
             self.row_cluster_kws = kwargs
             self._row_clustered = False
             self._use_row_meta = use_meta
+            self.row_linkage = linkage
 
     def get_data(self):
         data = self.data
@@ -93,17 +102,23 @@ class Deformation:
             data = data[:, self.data_col_reindex]
         return data
 
-    def set_split_row(self, breakpoints=None):
+    def set_split_row(self, breakpoints=None, order=None):
         if breakpoints is not None:
             self.is_row_split = True
             self.row_breakpoints = [0, *np.sort(np.asarray(breakpoints)),
                                     self._nrow]
+            if order is None:
+                order = np.arange(len(breakpoints) + 1)
+            self.row_split_order = order
 
-    def set_split_col(self, breakpoints=None):
+    def set_split_col(self, breakpoints=None, order=None):
         if breakpoints is not None:
             self.is_col_split = True
             self.col_breakpoints = [0, *np.sort(np.asarray(breakpoints)),
                                     self._ncol]
+            if order is None:
+                order = np.arange(len(breakpoints) + 1)
+            self.col_split_order = order
 
     @property
     def row_ratios(self):
@@ -169,11 +184,24 @@ class Deformation:
             return self.split_by_col(data)
         return data
 
+    _linkage_check_msg = ("If you want to specific linkage when splitting, "
+                          "it must be a dict-like object, "
+                          "with keys as group names and values as linkage")
+
     def cluster_row(self):
         row_data = self.split_by_row(self.get_data())
         if self.is_row_split:
-            dens = [Dendrogram(
-                chunk, **self.row_cluster_kws) for chunk in row_data]
+            if not (isinstance(self.row_linkage, Mapping) or (self.row_linkage is None)):
+                raise TypeError(self._linkage_check_msg)
+            dens = []
+            for chunk, k in zip(row_data, self.row_split_order):
+                linkage = None
+                if self.row_linkage is not None:
+                    linkage = self.row_linkage.get(k)
+                    if linkage is None:
+                        raise KeyError(f"Linkage for group {k} is not specified")
+                dens.append(Dendrogram(chunk, linkage=linkage, key=k, **self.row_cluster_kws))
+
             dg = GroupDendrogram(dens, **self.row_cluster_kws)
             if self._use_row_meta:
                 self.row_chunk_index = dg.reorder_index
@@ -181,15 +209,23 @@ class Deformation:
                 self.row_chunk_index = np.arange(len(dens))
             self.row_reorder_index = [d.reorder_index for d in dens]
         else:
-            dg = Dendrogram(row_data, **self.row_cluster_kws)
+            dg = Dendrogram(row_data, linkage=self.row_linkage, **self.row_cluster_kws)
             self.row_reorder_index = dg.reorder_index
         self.row_dendrogram = dg
 
     def cluster_col(self):
         col_data = self.split_by_col(self.get_data())
         if self.is_col_split:
-            dens = [Dendrogram(
-                chunk.T, **self.col_cluster_kws) for chunk in col_data]
+            if not (isinstance(self.col_linkage, Mapping) or (self.col_linkage is None)):
+                raise TypeError(self._linkage_check_msg)
+            dens = []
+            for chunk, k in zip(col_data, self.col_split_order):
+                linkage = None
+                if self.col_linkage is not None:
+                    linkage = self.col_linkage.get(k)
+                    if linkage is None:
+                        raise KeyError(f"Linkage for group {k} is not specified")
+                dens.append(Dendrogram(chunk.T, linkage=linkage, key=k, **self.col_cluster_kws))
             dg = GroupDendrogram(dens, **self.col_cluster_kws)
             if self._use_col_meta:
                 self.col_chunk_index = dg.reorder_index
@@ -197,7 +233,7 @@ class Deformation:
                 self.col_chunk_index = np.arange(len(dens))
             self.col_reorder_index = [d.reorder_index for d in dens]
         else:
-            dg = Dendrogram(col_data.T, **self.col_cluster_kws)
+            dg = Dendrogram(col_data.T, linkage=self.col_linkage, **self.col_cluster_kws)
             self.col_reorder_index = dg.reorder_index
         self.col_dendrogram = dg
 
@@ -340,6 +376,20 @@ class Deformation:
         self._run_cluster()
         return self.col_dendrogram
 
+    def get_row_linkage(self):
+        if self.row_dendrogram is not None:
+            if self.is_row_split:
+                return {x.key: x.Z for x in self.row_dendrogram.orig_dens}
+            else:
+                return self.row_dendrogram.Z
+
+    def get_col_linkage(self):
+        if self.col_dendrogram is not None:
+            if self.is_col_split:
+                return {x.key: x.Z for x in self.col_dendrogram.orig_dens}
+            else:
+                return self.col_dendrogram.Z
+
     @property
     def is_split(self):
         return self.is_row_split | self.is_col_split

{marsilea-0.3.0rc2 → marsilea-0.3.2}/marsilea/base.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
 
-import numpy as np
 import warnings
 from copy import deepcopy
+from numbers import Number
+from typing import List, Dict
+from uuid import uuid4
+
+import numpy as np
 from legendkit.layout import vstack, hstack
 from matplotlib import pyplot as plt
 from matplotlib.artist import Artist
 from matplotlib.colors import is_color_like
 from matplotlib.figure import Figure
-from numbers import Number
-from typing import List, Dict
-from uuid import uuid4
 
 from ._deform import Deformation
 from .dendrogram import Dendrogram
@@ -26,14 +27,13 @@ def reorder_index(arr, order=None):
     for ix, a in enumerate(arr):
         indices[a].append(ix)
 
+    if order is None:
+        order = sorted(uniq)
+
     final_index = []
-    if order is not None:
-        for it in order:
-            final_index += indices[it]
-    else:
-        for it in indices.values():
-            final_index += it
-    return final_index
+    for it in order:
+        final_index += indices[it]
+    return final_index, order
 
 
 def get_breakpoints(arr):
@@ -521,11 +521,11 @@ class ClusterBoard(WhiteBoard):
         self._cluster_data = cluster_data
         self._deform = Deformation(cluster_data)
 
-    def add_dendrogram(self, side, method=None, metric=None,
+    def add_dendrogram(self, side, method=None, metric=None, linkage=None,
                        add_meta=True, add_base=True, add_divider=True,
                        meta_color=None, linewidth=None, colors=None,
                        divider_style="--", meta_ratio=.2,
-                       show=True, name=None, size=0.5, pad=0.):
+                       show=True, name=None, size=0.5, pad=0., get_meta_center=None):
         """Run cluster and add dendrogram
 
         .. note::
@@ -542,11 +542,17 @@ class ClusterBoard(WhiteBoard):
             See scipy's :meth:`linkage <scipy.cluster.hierarchy.linkage>`
         metric : str
             See scipy's :meth:`linkage <scipy.cluster.hierarchy.linkage>`
-        add_meta : bool
+        linkage : ndarray
+            Precomputed linkage matrix.
+            See scipy's :meth:`linkage <scipy.cluster.hierarchy.linkage>` for
+            specific format.
+        add_meta : None | bool
+            By default, add_meta is set to False if the linkage is provided, otherwise True.
             If the data is split, a meta dendrogram can be drawn for data
             chunks. The mean value of the data chunk is used to calculate
             linkage matrix for meta dendrogram.
-        add_base : bool
+        add_base : None | bool
+            By default, add_meta is set to False if the linkage is provided, otherwise True.
             Draw the base dendrogram for each data chunk. You can turn this
             off if the base dendrogram is too crowded.
         add_divider : bool
@@ -571,6 +577,11 @@ class ClusterBoard(WhiteBoard):
             The name of the dendrogram axes
         size : float
         pad : float
+        get_meta_center: callable
+            A function to calculate the centroid of data. It should accept a 2D numpy
+            array as input and return a 1D numpy array of the same length as the number
+            of columns in the input, representing the centroid. The default will use the
+            mean values.
 
         Examples
         --------
@@ -638,46 +649,50 @@ class ClusterBoard(WhiteBoard):
             den_options['pos'] = "row"
             self._row_den.append(den_options)
             deform.set_cluster(row=True, method=method, metric=metric,
-                               use_meta=add_meta)
+                               linkage=linkage, use_meta=add_meta,
+                               get_meta_center=get_meta_center)
         else:
             den_options['pos'] = "col"
             self._col_den.append(den_options)
             deform.set_cluster(col=True, method=method, metric=metric,
-                               use_meta=add_meta)
-
+                               linkage=linkage, use_meta=add_meta,
+                               get_meta_center=get_meta_center)
+        
     def hsplit(self, cut=None, labels=None, order=None, spacing=0.01):
         if self._split_row:
             raise SplitTwice(axis="horizontally")
         self._split_row = True
 
-        self._deform.hspace = spacing
+        deform = self.get_deform()
+        deform.hspace = spacing
         if cut is not None:
-            self._deform.set_split_row(breakpoints=cut)
+            deform.set_split_row(breakpoints=cut)
         else:
             labels = np.asarray(labels)
 
-            reindex = reorder_index(labels, order=order)
-            self._deform.set_data_row_reindex(reindex)
+            reindex, order = reorder_index(labels, order=order)
+            deform.set_data_row_reindex(reindex)
 
             breakpoints = get_breakpoints(labels[reindex])
-            self._deform.set_split_row(breakpoints=breakpoints)
+            deform.set_split_row(breakpoints=breakpoints, order=order)
 
     def vsplit(self, cut=None, labels=None, order=None, spacing=0.01):
         if self._split_col:
             raise SplitTwice(axis="vertically")
         self._split_col = True
 
-        self._deform.wspace = spacing
+        deform = self.get_deform()
+        deform.wspace = spacing
         if cut is not None:
-            self._deform.set_split_col(breakpoints=cut)
+            deform.set_split_col(breakpoints=cut)
         else:
             labels = np.asarray(labels)
 
-            reindex = reorder_index(labels, order=order)
-            self._deform.set_data_col_reindex(reindex)
+            reindex, order = reorder_index(labels, order=order)
+            deform.set_data_col_reindex(reindex)
 
             breakpoints = get_breakpoints(labels[reindex])
-            self._deform.set_split_col(breakpoints=breakpoints)
+            deform.set_split_col(breakpoints=breakpoints, order=order)
 
     def _setup_axes(self):
         deform = self.get_deform()
@@ -768,6 +783,12 @@ class ClusterBoard(WhiteBoard):
     def get_deform(self):
         return self._deform
 
+    def get_row_linkage(self):
+        return self._deform.get_row_linkage()
+
+    def get_col_linkage(self):
+        return self._deform.get_col_linkage()
+
     @property
     def row_cluster(self):
         return len(self._row_den) > 0

{marsilea-0.3.0rc2 → marsilea-0.3.2}/marsilea/dataset.py

@@ -16,6 +16,7 @@ def load_data(name, cache=True):
                 (TCGA, PanCancer Atlas)
     - 'mouse_embryo': Spatial mapping of mouse embryo at E12.5
     - 'seq_align': Sequence alignment data
+    - 'les_miserables': Characters in Les Miserables
 
     Parameters
     ----------

{marsilea-0.3.0rc2 → marsilea-0.3.2}/marsilea/dendrogram.py

@@ -3,7 +3,7 @@ from itertools import cycle
 from matplotlib.collections import LineCollection
 from matplotlib.colors import is_color_like
 from matplotlib.lines import Line2D
-from scipy.cluster.hierarchy import linkage, dendrogram
+from scipy.cluster.hierarchy import linkage as scipy_linkage, dendrogram
 from typing import List, Sequence
 
 
@@ -15,7 +15,12 @@ class _DendrogramBase:
                  data,
                  method=None,
                  metric=None,
+                 linkage=None,
+                 get_meta_center=None,
+                 key=None,
                  ):
+        self.key = key
+        self.data = data
         if method is None:
             method = "single"
         if metric is None:
@@ -29,7 +34,10 @@ class _DendrogramBase:
             self._reorder_index = np.array([0])
             self.is_singleton = True
         else:
-            self.Z = linkage(data, method=method, metric=metric)
+            if linkage is not None:
+                self.Z = linkage
+            else:
+                self.Z = scipy_linkage(data, method=method, metric=metric)
             self._plot_data = dendrogram(self.Z, no_plot=True)
 
             self.x_coords = np.asarray(self._plot_data['icoord']) / 5
@@ -59,8 +67,22 @@ class _DendrogramBase:
         self.ylim = np.array([0, self.max_dependent_coord * 1.05])
         self._render_xlim = self.xlim
         self._render_ylim = self.ylim
+
         # Should be lazy eval
-        self._center = np.mean(data, axis=0)
+        # TODO: Allow center to be calculated differently
+        if get_meta_center is None:
+            self._center = np.mean(data, axis=0)
+        elif callable(get_meta_center):
+            # Ensure the centroid function returns a numpy array of correct shape
+            centroid = get_meta_center(data)
+            if isinstance(centroid, np.ndarray) and centroid.shape == data.shape[1:]:
+                self._center = centroid
+            else:
+                raise ValueError(
+                    "The get_meta_center must return a numpy array with shape "
+                    "matching the number of features in the data.")
+        else:
+            raise TypeError("The get_meta_center must be a callable function or None.")
 
     @property
     def xrange(self):
@@ -143,9 +165,13 @@ class Dendrogram(_DendrogramBase):
     def __init__(self,
                  data: np.ndarray,
                  method=None,
-                 metric=None
+                 metric=None,
+                 linkage=None,
+                 get_meta_center=None,
+                 key=None,
                  ):
-        super().__init__(data, method=method, metric=metric)
+        super().__init__(data, method=method, metric=metric, key=key,
+                         linkage=linkage, get_meta_center=get_meta_center)
 
     # here we left an empty **kwargs to align api with GroupDendrogram
     def draw(self, ax, orient="top",
@@ -223,10 +249,14 @@ class GroupDendrogram(_DendrogramBase):
     def __init__(self,
                  dens: List[Dendrogram],
                  method=None,
-                 metric=None
+                 metric=None,
+                 get_meta_center=None,
+                 key=None,
+                 **kwargs,
                  ):
         data = np.vstack([d.center for d in dens])
-        super().__init__(data, method=method, metric=metric)
+        super().__init__(data, method=method, metric=metric,
+                         get_meta_center=get_meta_center, key=key)
         self.orig_dens = np.asarray(dens)
         self.dens = np.asarray(dens)[self.reorder_index]
         self.n = len(self.dens)

{marsilea-0.3.0rc2 → marsilea-0.3.2}/marsilea/plotter/arc.py

@@ -210,8 +210,8 @@ class Arc(StatsBase):
                             xy = (arc_mid, 0)
                             angle = 0
                         sizes.append(arc_width)
-                        arc = mArc(xy, arc_width, arc_width * 2, angle,
-                                   **options)
+                        arc = mArc(xy, arc_width, arc_width * 2,
+                                   angle=angle, **options)
                         ax.add_patch(arc)
 
         lim = np.max(sizes)

{marsilea-0.3.0rc2 → marsilea-0.3.2}/marsilea/plotter/bar.py

@@ -387,6 +387,10 @@ class StackBar(_BarBase):
         if self.side == "left":
             ax.invert_xaxis()
 
+        # Hanlde data
+        if orient == "h":
+            data = data[:, ::-1]
+
         locs = np.arange(0, lim) + 0.5
         bottom = np.zeros(lim)
 
@@ -395,8 +399,8 @@ class StackBar(_BarBase):
             labels = self.labels[::-1]
         else:
             labels = [None for _ in range(len(data))]
-        colors = self.bar_colors[:len(data)][::-1]
-        for ix, row in enumerate(data[::-1]):
+        colors = self.bar_colors[:len(data)]
+        for ix, row in enumerate(data):
             bars = bar(locs, row, self.width, bottom,
                        fc=colors[ix],
                        label=labels[ix], **self.options)

{marsilea-0.3.0rc2 → marsilea-0.3.2}/marsilea/plotter/text.py

@@ -668,7 +668,8 @@ class Labels(_LabelBase):
         coords = self.get_axes_coords(data)
         params = self.get_text_params()
         if self.texts_size is not None:
-            offset_ratio = self.padding / 72 / self.texts_size
+            padding_px = self.padding / 72
+            offset_ratio = padding_px / (self.texts_size + padding_px)
         else:
             offset_ratio = 0
 
@@ -834,6 +835,7 @@ class _ChunkBase(_LabelBase):
 
     def __init__(self, texts,
                  fill_colors=None,
+                 align=None,
                  props=None, padding=2, bordercolor=None,
                  borderwidth=None, borderstyle=None,
                  **options):
@@ -841,6 +843,7 @@ class _ChunkBase(_LabelBase):
         n = len(texts)
         self.n = n
         self.texts = texts
+        self.align = align
         self.padding = padding
 
         if is_color_like(fill_colors):
@@ -876,6 +879,21 @@ class _ChunkBase(_LabelBase):
         super().__init__()
         self._sort_params(**options)
 
+    align_pos = {
+        'right': 1,
+        'left': 0,
+        'top': 1,
+        'bottom': 0,
+        'center': 0.5
+    }
+
+    default_align = {
+        "right": "left",
+        "left": "right",
+        "top": "bottom",
+        "bottom": "top"
+    }
+
     default_rotation = {
         "right": -90,
         "left": 90,
@@ -883,9 +901,31 @@ class _ChunkBase(_LabelBase):
         "bottom": 0,
     }
 
+    def get_alignment(self, ha, va, rotation):
+        if rotation in {90, -90}:
+            ha, va = va, ha  # swap the alignment
+        align_x, align_y = self.align_pos[ha], self.align_pos[va]
+        return align_x, align_y
+
+    def _align_compact(self, align):
+        """Make align keyword compatible to any side"""
+        if self.is_flank:
+            checker = {"top": "right", "bottom": "left"}
+        else:
+            checker = {"right": "top", "left": "bottom"}
+        return checker.get(align, align)
+
     def get_text_params(self) -> TextParams:
-        p = TextParams(va="center", ha="center",
-                       rotation=self.default_rotation[self.side])
+        if self.align is None:
+            self.align = self.default_align[self.side]
+
+        self.align = self._align_compact(self.align)
+        va, ha = self.align, 'center'
+        if self.is_flank:
+            va, ha = ha, va
+
+        rotation = self.default_rotation[self.side]
+        p = TextParams(rotation=rotation, va=va, ha=ha)
         p.update_params(self._user_params)
         return p
 
@@ -893,6 +933,23 @@ class _ChunkBase(_LabelBase):
                 borderwidth, borderstyle, props):
 
         params = self.get_text_params()
+        if self.texts_size is not None:
+            padding_px = self.padding / 72
+            offset_ratio = padding_px / (self.texts_size + padding_px)
+        else:
+            offset_ratio = 0
+
+        if self.align == "center":
+            const = .5
+        elif self.align in ["right", "top"]:
+            const = 1 - offset_ratio / 2
+        else:
+            const = offset_ratio / 2  # self.text_pad / (1 + self.text_pad) / 2
+
+        # adjust the text alignment based on the alignment position and rotation
+        c = .5
+        x, y = (const, c) if self.is_flank else (c, const)
+
         fill_colors = [] if fill_colors is None else fill_colors
         border_colors = [] if border_colors is None else border_colors
         borderwidth = [] if borderwidth is None else borderwidth
@@ -915,7 +972,8 @@ class _ChunkBase(_LabelBase):
 
             if prop is not None:
                 fontdict.update(prop)
-            ax.text(0.5, 0.5, t, fontdict=fontdict, transform=ax.transAxes)
+
+            ax.text(x, y, t, fontdict=fontdict, transform=ax.transAxes)
 
 
 class Chunk(_ChunkBase):
@@ -968,12 +1026,19 @@ class Chunk(_ChunkBase):
 
     def __init__(self, texts,
                  fill_colors=None,
+                 *,
+                 align=None,
                  props=None, padding=8, bordercolor=None,
                  borderwidth=None, borderstyle=None,
                  **options):
 
-        super().__init__(texts, fill_colors, props, padding, bordercolor,
-                         borderwidth, borderstyle, **options)
+        super().__init__(texts, fill_colors=fill_colors,
+                         align=align,
+                         props=props, padding=padding,
+                         bordercolor=bordercolor,
+                         borderwidth=borderwidth,
+                         borderstyle=borderstyle,
+                         **options)
 
     def render(self, axes):
 
@@ -1057,11 +1122,12 @@ class FixedChunk(_ChunkBase):
 
     """
 
-    def __init__(self, texts, fill_colors=None, ratio=None,
+    def __init__(self, texts, fill_colors=None, *,
+                 align=None, ratio=None,
                  props=None, padding=8, bordercolor=None,
                  borderwidth=None, borderstyle=None,
                  **options):
-        super().__init__(texts, fill_colors, props, padding, bordercolor,
+        super().__init__(texts, align, fill_colors, props, padding, bordercolor,
                          borderwidth, borderstyle, **options)
         if ratio is not None:
             self.set_split_regroup(ratio)

{marsilea-0.3.0rc2 → marsilea-0.3.2}/readthedocs.yaml

@@ -9,5 +9,4 @@ python:
   install:
     - requirements: docs/requirements.txt
     - method: pip
-      path: .
-  system_packages: true
+      path: .