marsilea 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

marsilea/plotter/_seaborn.py

@@ -14,10 +14,17 @@ class _SeabornBase(StatsBase):
     hue = None
     data = None
 
-    def __init__(self, data, hue_order=None, palette=None,
-                 orient=None, label=None, legend_kws=None,
-                 group_kws=None, **kwargs):
-
+    def __init__(
+        self,
+        data,
+        hue_order=None,
+        palette=None,
+        orient=None,
+        label=None,
+        legend_kws=None,
+        group_kws=None,
+        **kwargs,
+    ):
         if isinstance(data, Mapping):
             datasets = []
             self.hue = []
@@ -25,8 +32,7 @@ class _SeabornBase(StatsBase):
                 hue_order = data.keys()
             for name in hue_order:
                 self.hue.append(name)
-                datasets.append(
-                    self.data_validator(data[name]))
+                datasets.append(self.data_validator(data[name]))
             if isinstance(palette, Mapping):
                 self.palette = palette
             else:
@@ -35,16 +41,16 @@ class _SeabornBase(StatsBase):
                 else:
                     colors = color_palette(palette, as_cmap=False)
                 self.palette = dict(zip(self.hue, colors))
-            kwargs['palette'] = self.palette
+            kwargs["palette"] = self.palette
             self.set_data(*datasets)
         else:
             data = self.data_validator(data)
             self.set_data(data)
-            kwargs.setdefault('color', 'C0')
+            # kwargs.setdefault('color', 'C0')
             # if (palette is None) and ('color' not in kwargs):
             #     kwargs['palette'] = "dark:C0"
             if palette is not None:
-                kwargs['palette'] = palette
+                kwargs["palette"] = palette
 
         kwargs.pop("x", None)
         kwargs.pop("y", None)
@@ -71,40 +77,45 @@ class _SeabornBase(StatsBase):
             return CatLegend(colors=colors, labels=labels, **options)
 
     def render_ax(self, spec):
-
         ax = spec.ax
         data = spec.data
         gp = spec.group_params
         if gp is None:
             gp = {}
-
+        x, y = "var", "value"
         if self.hue is not None:
-
-            x, y = "var", "value"
             dfs = []
             for d, hue in zip(data, self.hue):
                 df = pd.DataFrame(d)
                 df = df.melt(var_name="var", value_name="value")
-                df['hue'] = hue
+                df["hue"] = hue
                 dfs.append(df)
 
             pdata = pd.concat(dfs)
-            self.kws['hue'] = 'hue'
-            self.kws['hue_order'] = self.hue
+            self.kws["hue"] = "hue"
+            self.kws["hue_order"] = self.hue
             if self.get_orient() == "h":
                 x, y = y, x
-            self.kws['x'] = x
-            self.kws['y'] = y
+            self.kws["x"] = x
+            self.kws["y"] = y
+            options = {**self.kws, **gp}
 
         else:
-            pdata = pd.DataFrame(data)
+            pdata = pd.DataFrame(data).melt(var_name="var", value_name="value")
+            if self.get_orient() == "h":
+                x, y = y, x
+            self.kws["x"] = x
+            self.kws["y"] = y
+            options = {**self.kws, **gp}
+            if options.get("palette") is not None:
+                options["hue"] = "var"
 
         orient = self.get_orient()
         if self.side == "left":
             ax.invert_xaxis()
         # barplot(data=data, orient=orient, ax=ax, **self.kws)
         plotter = getattr(seaborn, self._seaborn_plot)
-        options = {**self.kws, **gp}
+
         plotter(data=pdata, orient=orient, ax=ax, **options)
         ax.set(xlabel=None, ylabel=None)
         leg = ax.get_legend()
@@ -122,13 +133,13 @@ def _seaborn_doc(obj: _SeabornBase):
 
     if cls_name == "Swarm":
         sdata = "np.random.rand(50, 10)"
-        kws = "palette='dark:#DB4D6D', size=2"
-        h_kws = "group_kws={'palette': [f'dark:{c}'for c in colors]}, size=2"
+        kws = "color='#DB4D6D', size=2, dodge=True"
+        h_kws = "group_kws={'color': colors}, size=2"
 
     elif cls_name == "Strip":
         sdata = "np.random.rand(50, 10)"
-        kws = "palette='dark:#DB4D6D', size=2"
-        h_kws = "group_kws={'palette': [f'dark:{c}'for c in colors]}, size=2"
+        kws = "color='#DB4D6D', size=2, dodge=True"
+        h_kws = "group_kws={'color': colors}, size=2"
 
     elif cls_name == "Point":
         hue_data = "{'a': sdata, 'b': sdata * 2}"

marsilea/plotter/_utils.py

@@ -26,6 +26,7 @@ def _auto_format_str(fmt, value):
     matplotlib/cbook.py
     """
     try:
-        return fmt % (value,)
-    except (TypeError, ValueError):
+        fmt = "{:" + fmt + "}"
         return fmt.format(value)
+    except (TypeError, ValueError):
+        return str(value)

marsilea/plotter/arc.py

@@ -15,8 +15,7 @@ class LinkAttrs:
 
 
 class Links:
-    def __init__(self, links, weights=None, width=None,
-                 colors=None, labels=None):
+    def __init__(self, links, weights=None, width=None, colors=None, labels=None):
         self._links = {}
         self._links_attr = {}
 
@@ -34,16 +33,20 @@ class Links:
             self.colors = [colors for _ in links]
         else:
             if len(colors) != len(links):
-                msg = f"Length of colors ({len(colors)}) does not " \
-                      f"match length of links ({len(links)})"
+                msg = (
+                    f"Length of colors ({len(colors)}) does not "
+                    f"match length of links ({len(links)})"
+                )
                 raise ValueError(msg)
             self.colors = colors
 
         self.legend_entries = None
         if labels is not None:
             if len(labels) != len(links):
-                msg = f"Length of labels ({len(labels)}) does not " \
-                      f"match length of links ({len(links)})"
+                msg = (
+                    f"Length of labels ({len(labels)}) does not "
+                    f"match length of links ({len(links)})"
+                )
                 raise ValueError(msg)
             self.legend_entries = dict(zip(labels, colors))
 
@@ -120,7 +123,7 @@ class Arc(StatsBase):
     label_loc : str, optional
         Location of the label. Must be one of the following:
         "left", "right", "top", "bottom", "center".
-    props : dict, optional
+    label_props : dict, optional
         Keyword arguments passed to `matplotlib.text.Text`.
     **kwargs
         Keyword arguments passed to `matplotlib.patches.Arc`.
@@ -148,22 +151,31 @@ class Arc(StatsBase):
 
     render_main = False
 
-    def __init__(self, anchors, links, weights=None, width=None,
-                 colors=None, labels=None, legend_kws=None,
-                 label=None, label_loc=None, props=None,
-                 **kwargs):
+    def __init__(
+        self,
+        anchors,
+        links,
+        weights=None,
+        width=None,
+        colors=None,
+        labels=None,
+        legend_kws=None,
+        label=None,
+        label_loc=None,
+        label_props=None,
+        **kwargs,
+    ):
         if len(np.unique(anchors)) != len(anchors):
             raise ValueError("`anchors` must be unique")
         anchors = self.data_validator(anchors, target="1d")
         self.set_data(anchors)
-        self.links = Links(links, weights=weights, width=width,
-                           colors=colors, labels=labels)
+        self.links = Links(
+            links, weights=weights, width=width, colors=colors, labels=labels
+        )
         self.options = kwargs
         self.legend_kws = {} if legend_kws is None else legend_kws
 
-        self.label = label
-        self.label_loc = label_loc
-        self.props = props
+        self.set_label(label, label_loc, label_props)
 
     def render_ax(self, spec):
         ax = spec.ax
@@ -183,7 +195,6 @@ class Arc(StatsBase):
                 for link in links:
                     link_in_data = anchors_coords.get(link)
                     if link_in_data is not None:
-
                         arc_start = anchors_coords[anchor]
                         arc_end = link_in_data
                         if arc_end < arc_start:
@@ -210,8 +221,7 @@ class Arc(StatsBase):
                             xy = (arc_mid, 0)
                             angle = 0
                         sizes.append(arc_width)
-                        arc = mArc(xy, arc_width, arc_width * 2,
-                                   angle=angle, **options)
+                        arc = mArc(xy, arc_width, arc_width * 2, angle=angle, **options)
                         ax.add_patch(arc)
 
         lim = np.max(sizes)

marsilea/plotter/area.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+from marsilea.plotter.base import StatsBase
+
+
+class Area(StatsBase):
+    """Area plot
+
+    Parameters
+    ----------
+    data : array-like
+        The data to be plotted.
+    color : color-like
+        The color of the area
+    add_outline : bool
+        Whether to add outline to the area
+    alpha : float
+        The transparency of the area
+    linecolor : color-like
+        The color of the outline
+    linewidth : float
+        The width of the outline
+    group_kws : dict
+        The configurations that apply to each group
+    **kwargs :
+        Additional configurations for the area plot, \
+        see :func:`matplotlib.pyplot.fill_between`
+
+    """
+
+    def __init__(self, data, color=None, add_outline=True, alpha=.4,
+                 linecolor=None, linewidth=1,
+                 group_kws=None, label=None, label_loc=None, label_props=None,
+                 **kwargs):
+
+        if color is None:
+            color = "skyblue"
+        if linecolor is None:
+            linecolor = "Slateblue"
+
+        self.color = color
+        self.add_outline = add_outline
+        self.alpha = alpha
+        self.linecolor = linecolor
+        self.linewidth = linewidth
+        self.kws = kwargs
+
+        self.set_data(data)
+        if group_kws is not None:
+            self.set_group_params(group_kws)
+
+    def render_ax(self, spec):
+        ax = spec.ax
+        data = spec.data
+        gp = spec.group_params
+        if gp is None:
+            gp = {}
+
+        fill_options = {'colo': self.color, 'alpha': self.alpha, **self.kws, **gp}
+        line_options = {'color': self.linecolor, 'linewidth': self.linewidth, **gp}
+
+        x = np.arange(len(data))
+        if self.get_orient() == "h":
+            ax.fill_betweenx(x, data, **fill_options)
+            if self.add_outline:
+                ax.plot(data, x, **line_options)
+            ax.set_ylim(-.5, len(data)-.5)
+            if self.side == "left":
+                ax.invert_xaxis()
+        else:
+            ax.fill_between(x, data, **fill_options)
+            if self.add_outline:
+                ax.plot(x, data, **line_options)
+            ax.set_xlim(-.5, len(data)-.5)
+        return ax
+
+
+# TODO: Implement StackArea
+class StackArea(StatsBase):
+    pass

marsilea/plotter/bar.py

@@ -12,16 +12,17 @@ from .base import StatsBase
 from ..utils import ECHARTS16
 
 
-def simple_bar(data,
-               ax: Axes = None,
-               orient="v",
-               width=.8,
-               show_value=True,
-               fmt=None,
-               label_pad=2,
-               text_props=None,
-               **kwargs
-               ):
+def simple_bar(
+    data,
+    ax: Axes = None,
+    orient="v",
+    width=0.8,
+    show_value=True,
+    fmt=None,
+    label_pad=2,
+    text_props=None,
+    **kwargs,
+):
     if ax is None:
         ax = plt.gca()
     if text_props is None:
@@ -29,18 +30,22 @@ def simple_bar(data,
     bar = ax.bar if orient == "v" else ax.barh
     bars = bar(np.arange(0, len(data)) + 0.5, data, width, **kwargs)
     if show_value:
-        ax.bar_label(bars, data, fmt=fmt,
-                     padding=label_pad,
-                     **text_props)
+        ax.bar_label(bars, data, fmt=fmt, padding=label_pad, **text_props)
     return ax
 
 
 class _BarBase(StatsBase):
-
-    def _process_params(self, width=.7, orient=None, show_value=True,
-                        fmt=None, label=None, value_pad=2.,
-                        props=None, **kwargs):
-
+    def _process_params(
+        self,
+        width=0.7,
+        orient=None,
+        show_value=True,
+        fmt=None,
+        label=None,
+        value_pad=2.0,
+        props=None,
+        **kwargs,
+    ):
         self.width = width
         self.orient = orient
         self.show_value = show_value
@@ -86,18 +91,29 @@ class Numbers(_BarBase):
         >>> data = np.random.randint(1, 10, 10)
         >>> _, ax = plt.subplots()
         >>> Numbers(data).render(ax)
-    
+
     """
 
-    def __init__(self, data, width=.8, color="C0", orient=None,
-                 show_value=True, fmt=None, label=None, value_pad=2.,
-                 props=None, **kwargs):
+    def __init__(
+        self,
+        data,
+        width=0.8,
+        color="C0",
+        orient=None,
+        show_value=True,
+        fmt=None,
+        label=None,
+        value_pad=2.0,
+        props=None,
+        **kwargs,
+    ):
         self.set_data(self.data_validator(data, target="1d"))
         self.color = color
         self.bars = None
 
-        self._process_params(width, orient, show_value, fmt, label,
-                             value_pad, props, **kwargs)
+        self._process_params(
+            width, orient, show_value, fmt, label, value_pad, props, **kwargs
+        )
 
     def render_ax(self, spec):
         ax = spec.ax
@@ -108,8 +124,9 @@ class Numbers(_BarBase):
         bar = ax.bar if orient == "v" else ax.barh
         if orient == "h":
             data = data[::-1]
-        self.bars = bar(np.arange(0, lim) + 0.5, data,
-                        self.width, color=self.color, **self.options)
+        self.bars = bar(
+            np.arange(0, lim) + 0.5, data, self.width, color=self.color, **self.options
+        )
 
         if orient == "v":
             ax.set_xlim(0, lim)
@@ -120,9 +137,7 @@ class Numbers(_BarBase):
             ax.invert_xaxis()
 
         if self.show_value:
-            ax.bar_label(self.bars, fmt=self.fmt,
-                         padding=self.value_pad,
-                         **self.props)
+            ax.bar_label(self.bars, fmt=self.fmt, padding=self.value_pad, **self.props)
 
 
 class CenterBar(_BarBase):
@@ -175,10 +190,20 @@ class CenterBar(_BarBase):
 
     """
 
-    def __init__(self, data, names=None, width=.8, colors=None, orient=None,
-                 show_value=True, fmt=None, label=None, value_pad=2.,
-                 props=None, **kwargs):
-
+    def __init__(
+        self,
+        data,
+        names=None,
+        width=0.8,
+        colors=None,
+        orient=None,
+        show_value=True,
+        fmt=None,
+        label=None,
+        value_pad=2.0,
+        props=None,
+        **kwargs,
+    ):
         self.set_data(self.data_validator(data.T, target="2d"))
         if names is None:
             if isinstance(data, pd.DataFrame):
@@ -188,11 +213,11 @@ class CenterBar(_BarBase):
             colors = ["C0", "C1"]
         self.colors = colors
 
-        self._process_params(width, orient, show_value, fmt, label,
-                             value_pad, props, **kwargs)
+        self._process_params(
+            width, orient, show_value, fmt, label, value_pad, props, **kwargs
+        )
 
     def render_ax(self, spec):
-
         ax = spec.ax
         data = spec.data
 
@@ -212,36 +237,28 @@ class CenterBar(_BarBase):
         left_bar, right_bar = data[0], data[1]
         locs = np.arange(0, len(left_bar)) + 0.5
 
-        bar1 = bar(locs, left_bar, self.width,
-                   color=self.colors[0], **self.options)
-        bar2 = bar(locs, -right_bar, self.width,
-                   color=self.colors[1], **self.options)
+        bar1 = bar(locs, left_bar, self.width, color=self.colors[0], **self.options)
+        bar2 = bar(locs, -right_bar, self.width, color=self.colors[1], **self.options)
         line(0, color="black", lw=1)
         if self.names is not None:
             n1, n2 = self.names
             if orient == "h" and spec.is_first:
-                ax.text(.45, 1, n1, ha="right", va="bottom",
-                        transform=ax.transAxes)
-                ax.text(.55, 1, n2, ha="left", va="bottom",
-                        transform=ax.transAxes)
+                ax.text(0.45, 1, n1, ha="right", va="bottom", transform=ax.transAxes)
+                ax.text(0.55, 1, n2, ha="left", va="bottom", transform=ax.transAxes)
             elif orient == "v" and spec.is_last:
-                ax.text(1, .75, n1, ha="left", va="center",
-                        transform=ax.transAxes)
-                ax.text(1, .25, n2, ha="left", va="center",
-                        transform=ax.transAxes)
+                ax.text(1, 0.75, n1, ha="left", va="center", transform=ax.transAxes)
+                ax.text(1, 0.25, n2, ha="left", va="center", transform=ax.transAxes)
 
         lim_value = np.max(data) * 1.05
 
         if orient == "v":
             ax.set_xlim(0, len(left_bar))
             ax.set_ylim(-lim_value, lim_value)
-            ax.yaxis.set_major_formatter(
-                FuncFormatter(lambda x, p: f"{np.abs(x):g}"))
+            ax.yaxis.set_major_formatter(FuncFormatter(lambda x, p: f"{np.abs(x):g}"))
         else:
             ax.set_ylim(0, len(left_bar))
             ax.set_xlim(-lim_value, lim_value)
-            ax.xaxis.set_major_formatter(
-                FuncFormatter(lambda x, p: f"{np.abs(x):g}"))
+            ax.xaxis.set_major_formatter(FuncFormatter(lambda x, p: f"{np.abs(x):g}"))
 
         if self.is_flank:
             ax.invert_yaxis()
@@ -249,12 +266,8 @@ class CenterBar(_BarBase):
         if self.show_value:
             left_label = _format_labels(left_bar, self.fmt)
             right_label = _format_labels(right_bar, self.fmt)
-            ax.bar_label(bar1, left_label,
-                         padding=self.value_pad,
-                         **self.props)
-            ax.bar_label(bar2, right_label,
-                         padding=self.value_pad,
-                         **self.props)
+            ax.bar_label(bar1, left_label, padding=self.value_pad, **self.props)
+            ax.bar_label(bar2, right_label, padding=self.value_pad, **self.props)
 
 
 class StackBar(_BarBase):
@@ -282,7 +295,7 @@ class StackBar(_BarBase):
         The spacing between value and the bar
     props : dict
         See :class:`matplotlib.text.Text`
-    kwargs:
+    kwargs :
         Other keyword arguments passed to :meth:`matplotlib.axes.Axes.bar`
 
 
@@ -299,8 +312,7 @@ class StackBar(_BarBase):
         >>> StackBar(stack_data).render(ax)
 
 
-    You may find the text is too big for a bar to display on, to not display
-    certain value.
+    You may find the text is too big for a bar to display on, to not display certain value.
 
     .. plot::
         :context: close-figs
@@ -309,23 +321,25 @@ class StackBar(_BarBase):
         >>> _, ax = plt.subplots()
         >>> StackBar(stack_data, show_value=True, fmt=fmt).render(ax)
 
-     """
-
-    def __init__(self, data,
-                 items=None,
-                 colors=None,
-                 orient=None,
-                 show_value=False,
-                 value_loc="center",
-                 width=.8,
-                 value_size=6,
-                 fmt=None,
-                 props=None,
-                 label=None,
-                 value_pad=0,
-                 legend_kws=None,
-                 **kwargs,
-                 ):
+    """
+
+    def __init__(
+        self,
+        data,
+        items=None,
+        colors=None,
+        orient=None,
+        show_value=False,
+        value_loc="center",
+        width=0.8,
+        value_size=6,
+        fmt=None,
+        props=None,
+        label=None,
+        value_pad=0,
+        legend_kws=None,
+        **kwargs,
+    ):
         # TODO: Support bare bone numpy array as input
         item_names = None
         if isinstance(data, pd.DataFrame):
@@ -341,8 +355,10 @@ class StackBar(_BarBase):
         else:
             if isinstance(colors, Mapping):
                 if item_names is None:
-                    raise ValueError("Please provide the name of each item "
-                                     "before assigning color.")
+                    raise ValueError(
+                        "Please provide the name of each item "
+                        "before assigning color."
+                    )
                 bar_colors = [colors[name] for name in item_names]
             else:
                 bar_colors = colors
@@ -359,8 +375,9 @@ class StackBar(_BarBase):
         value_props = dict(label_type=value_loc)
         value_props.update(props)
 
-        self._process_params(width, orient, show_value, fmt, label,
-                             value_pad, value_props, **kwargs)
+        self._process_params(
+            width, orient, show_value, fmt, label, value_pad, value_props, **kwargs
+        )
 
         self.value_size = value_size
         self._legend_kws = dict(title=self.label, size=1)
@@ -369,8 +386,9 @@ class StackBar(_BarBase):
 
     def get_legends(self):
         if self.labels is not None:
-            return CatLegend(colors=self.bar_colors, labels=self.labels,
-                             **self._legend_kws)
+            return CatLegend(
+                colors=self.bar_colors, labels=self.labels, **self._legend_kws
+            )
 
     def render_ax(self, spec):
         ax = spec.ax
@@ -399,13 +417,18 @@ class StackBar(_BarBase):
             labels = self.labels[::-1]
         else:
             labels = [None for _ in range(len(data))]
-        colors = self.bar_colors[:len(data)]
+        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)
+            bars = bar(
+                locs,
+                row,
+                self.width,
+                bottom,
+                fc=colors[ix],
+                label=labels[ix],
+                **self.options,
+            )
             bottom += row
 
             if self.show_value:
-                ax.bar_label(bars, fmt=self.fmt, padding=self.value_pad,
-                             **self.props)
+                ax.bar_label(bars, fmt=self.fmt, padding=self.value_pad, **self.props)