MatplotLibAPI 3.2.1__tar.gz → 3.2.3__tar.gz

{matplotlibapi-3.2.1 → matplotlibapi-3.2.3}/MatplotLibAPI/Bubble.py

@@ -1,12 +1,13 @@
 # Hint for Visual Code Python Interactive window
 # %%
-from typing import Optional
+from typing import Optional, Tuple
 import pandas as pd
 import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
+from matplotlib.figure import Figure
 import seaborn as sns
 
-from .StyleTemplate import DynamicFuncFormatter, StyleTemplate, generate_ticks, string_formatter, bmk_formatter, percent_formatter, format_func,validate_dataframe
+from .StyleTemplate import DynamicFuncFormatter, StyleTemplate, generate_ticks, string_formatter, bmk_formatter, percent_formatter, format_func, validate_dataframe
 
 BUBBLE_STYLE_TEMPLATE = StyleTemplate(
     format_funcs={"label": string_formatter,
@@ -18,7 +19,7 @@ BUBBLE_STYLE_TEMPLATE = StyleTemplate(
 )
 
 
-def plot_bubble(
+def aplot_bubble(
         pd_df: pd.DataFrame,
         label: str,
         x: str,
@@ -30,6 +31,8 @@ def plot_bubble(
         center_to_mean: bool = False,
         sort_by: Optional[str] = None,
         ascending: bool = False,
+        hline=False,
+        vline=False,
         ax: Optional[Axes] = None):
 
     validate_dataframe(pd_df, cols=[label, x, y, z], sort_by=sort_by)
@@ -92,17 +95,18 @@ def plot_bubble(
                    which='major',
                    colors=style.font_color,
                    labelsize=style.font_size)
-
-    ax.vlines(x=x_mean,
-              ymin=y_min,
-              ymax=y_max,
-              linestyle='--',
-              colors=style.font_color)
-    ax.hlines(y=y_mean,
-              xmin=x_min,
-              xmax=x_max,
-              linestyle='--',
-              colors=style.font_color)
+    if vline:
+        ax.vlines(x=x_mean,
+                ymin=y_min,
+                ymax=y_max,
+                linestyle='--',
+                colors=style.font_color)
+    if hline:
+        ax.hlines(y=y_mean,
+                xmin=x_min,
+                xmax=x_max,
+                linestyle='--',
+                colors=style.font_color)
 
     for index, row in plot_df.iterrows():
         x_value = row[x]
@@ -121,4 +125,41 @@ def plot_bubble(
     return ax
 
 
+def fplot_bubble(
+        pd_df: pd.DataFrame,
+        label: str,
+        x: str,
+        y: str,
+        z: str,
+        title: Optional[str] = "Test",
+        style: StyleTemplate = BUBBLE_STYLE_TEMPLATE,
+        max_values: int = BUBBLE_STYLE_TEMPLATE,
+        center_to_mean: bool = False,
+        sort_by: Optional[str] = None,
+        ascending: bool = False,
+        hline=False,
+        vline=False,
+        figsize: Tuple[float, float] = (19.2, 10.8)) -> Figure:
+
+    fig = plt.figure(figsize=figsize)
+    fig.patch.set_facecolor(style.background_color)
+    ax = fig.add_subplot()
+    ax = aplot_bubble(pd_df=pd_df,
+                        label=label,
+                        x=x,
+                        y=y,
+                        z=z,
+                        title=title,
+                        style=style,
+                        max_values=max_values,
+                        center_to_mean=center_to_mean,
+                        sort_by=sort_by,
+                        ascending=ascending,
+                        hline=hline,
+                        vline=vline,
+                        ax=ax)
+    return fig
+
+
+
 # endregion

{matplotlibapi-3.2.1 → matplotlibapi-3.2.3}/MatplotLibAPI/Composite.py

@@ -1,16 +1,18 @@
 # Hint for Visual Code Python Interactive window
 # %%
-from typing import Optional, Tuple
+from typing import Optional, Tuple,List,Union, Dict
 import pandas as pd
 import matplotlib.pyplot as plt
+from matplotlib.pyplot import GridSpec
 from matplotlib.figure import Figure
+from matplotlib.axes import Axes
 
-from .Network import plot_network, plot_network_components, DEFAULT
-from .Bubble import plot_bubble, BUBBLE_STYLE_TEMPLATE
-from .Table import plot_table
+from .Bubble import aplot_bubble, BUBBLE_STYLE_TEMPLATE
+from .Table import aplot_table
 from .StyleTemplate import StyleTemplate, format_func, validate_dataframe
 
 
+
 def plot_composite_bubble(
         pd_df: pd.DataFrame,
         label: str,
@@ -38,10 +40,10 @@ def plot_composite_bubble(
     style.format_funcs = format_func(
         style.format_funcs, label=label, x=x, y=y, z=z)
     fig = plt.figure(figsize=figsize)
-    fig.patch.set_facecolor("black")
+    fig.patch.set_facecolor(style.background_color)
     grid = plt.GridSpec(2, 2, height_ratios=[2, 1], width_ratios=[1, 1])
     ax = fig.add_subplot(grid[0, 0:])
-    ax = plot_bubble(pd_df=plot_df,
+    ax = aplot_bubble(pd_df=plot_df,
                      label=label,
                      x=x,
                      y=y,
@@ -64,7 +66,7 @@ def plot_composite_bubble(
         style.format_funcs[z] = style.format_funcs["z"]
 
     ax2 = fig.add_subplot(grid[1, 0])
-    ax2 = plot_table(
+    ax2 = aplot_table(
         pd_df=plot_df,
         cols=[label, z, y, x],
         title=f"Top {table_rows}",
@@ -75,10 +77,10 @@ def plot_composite_bubble(
         style=style
     )
     ax3 = fig.add_subplot(grid[1, 1])
-    ax3 = plot_table(
+    ax3 = aplot_table(
         pd_df=plot_df,
         cols=[label, z, y, x],
-        title=f"Worst {table_rows}",
+        title=f"Last {table_rows}",
         ax=ax3,
         sort_by=sort_by,
         ascending=True,
@@ -87,3 +89,4 @@ def plot_composite_bubble(
     )
     fig.tight_layout()
     return fig
+

{matplotlibapi-3.2.1 → matplotlibapi-3.2.3}/MatplotLibAPI/Network.py

@@ -327,7 +327,7 @@ class Graph(nx.Graph):
         return Graph(G)
 
 
-def plot_network(pd_df: pd.DataFrame,
+def aplot_network(pd_df: pd.DataFrame,
                  source: str = "source",
                  target: str = "target",
                  weight: str = "weight",
@@ -351,7 +351,7 @@ def plot_network(pd_df: pd.DataFrame,
                        style=style,
                        ax=ax)
 
-def plot_network_components(pd_df: pd.DataFrame,
+def aplot_network_components(pd_df: pd.DataFrame,
                  source: str = "source",
                  target: str = "target",
                  weight: str = "weight",

{matplotlibapi-3.2.1 → matplotlibapi-3.2.3}/MatplotLibAPI/Table.py

@@ -1,9 +1,10 @@
-from typing import List, Optional
+from typing import List, Optional, Tuple
 import pandas as pd
 import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
+from matplotlib.figure import Figure
 
-from .StyleTemplate import StyleTemplate,  string_formatter,validate_dataframe
+from .StyleTemplate import StyleTemplate,  string_formatter, validate_dataframe
 
 TABLE_STYLE_TEMPLATE = StyleTemplate(
     background_color='black',
@@ -13,7 +14,7 @@ TABLE_STYLE_TEMPLATE = StyleTemplate(
 )
 
 
-def plot_table(pd_df: pd.DataFrame,
+def aplot_table(pd_df: pd.DataFrame,
                cols: List[str],
                title: Optional[str] = None,
                style: StyleTemplate = TABLE_STYLE_TEMPLATE,
@@ -23,7 +24,7 @@ def plot_table(pd_df: pd.DataFrame,
                ax: Optional[Axes] = None
                ) -> Axes:
     validate_dataframe(pd_df, cols=cols, sort_by=sort_by)
-    
+
     if not sort_by:
         sort_by = cols[0]
 
@@ -64,3 +65,27 @@ def plot_table(pd_df: pd.DataFrame,
         ax.set_title(title, color=style.font_color, fontsize=style.font_size*2)
         ax.title.set_position([0.5, 1.05])
     return ax
+
+
+def fplot_table(pd_df: pd.DataFrame,
+               cols: List[str],
+               title: Optional[str] = None,
+               style: StyleTemplate = TABLE_STYLE_TEMPLATE,
+               max_values: int = 20,
+               sort_by: Optional[str] = None,
+               ascending: bool = False,
+               figsize: Tuple[float, float] = (19.2, 10.8)
+               ) -> Figure:
+    fig = plt.figure(figsize=figsize)
+    fig.patch.set_facecolor(style.background_color)
+    ax = fig.add_subplot()
+    ax = aplot_table(pd_df,
+                    cols,
+                    title,
+                    style,
+                    max_values,
+                    sort_by,
+                    ascending,
+                    ax
+                    )
+    return fig

matplotlibapi-3.2.3/MatplotLibAPI/Timeserie.py

@@ -0,0 +1,128 @@
+# Hint for Visual Code Python Interactive window
+# %%
+from typing import Optional, Tuple
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+from matplotlib.axes import Axes
+import seaborn as sns
+
+from .StyleTemplate import DynamicFuncFormatter, StyleTemplate, string_formatter, bmk_formatter, format_func, validate_dataframe
+
+
+TIMESERIE_STYLE_TEMPLATE = StyleTemplate(
+    palette='rocket',
+    format_funcs={"y": bmk_formatter, "label": string_formatter}
+)
+
+# region Line
+
+
+def aplot_timeserie(pd_df: pd.DataFrame,
+                      label: str,
+                      x: str,
+                      y: str,
+                      title: Optional[str] = None,
+                      style: StyleTemplate = TIMESERIE_STYLE_TEMPLATE,
+                      max_values: int = 100,
+                      sort_by: Optional[str] = None,
+                      ascending: bool = False,
+                      std: bool = False,
+                      ax: Optional[Axes] = None) -> Axes:
+
+    validate_dataframe(pd_df, cols=[label, x, y], sort_by=sort_by)
+    style.format_funcs = format_func(style.format_funcs, label=label, x=x, y=y)
+
+    df = pd_df[[label, x, y]].sort_values(by=[label, x])
+    df[x] = pd.to_datetime(df[x])
+    df.set_index(x, inplace=True)
+
+    sns.set_palette(style.palette)
+    # Colors for each group
+    colors = sns.color_palette(n_colors=len(df.columns))
+    if ax is None:
+        ax = plt.gca()
+
+    # Get unique dimension_types
+    label_types = df[label].unique()
+
+    # Colors for each group
+    colors = sns.color_palette(n_colors=len(label_types))
+
+    for label_type, color in zip(label_types, colors):
+        temp_df = df[df[label] == label_type].sort_values(by=x)
+
+        if style.format_funcs.get("label"):
+            label_type = style.format_funcs.get("label")(label_type)
+        if std:
+            ma = temp_df[y].rolling(window=7, min_periods=1).mean()
+            std_dev = temp_df[y].rolling(window=7, min_periods=1).std()
+            # Calculate the last moving average value to include in the legend
+            last_ma_value = ma.iloc[-1]
+            # Dynamically creating the legend label
+            label_str = f"{string_formatter(label_type)} (avg 7d: {style.format_funcs[y](last_ma_value)})"
+            # Plot moving average and include the last MA value in the label for the legend
+            ax.plot(temp_df.index, ma, color=color,
+                    linestyle='--', label=label_str)
+
+            ax.fill_between(temp_df.index, ma - std_dev, ma +
+                            std_dev, color=color, alpha=0.2, label='_nolegend_')
+        else:
+            label_str = f"{string_formatter(label_type)}"
+            # Plot moving average and include the last MA value in the label for the legend
+            ax.plot(temp_df.index, temp_df[y], color=color, label=label_str)
+
+    ax.legend(
+        title=label,
+        fontsize=style.font_size-4,
+        title_fontsize=style.font_size,
+        labelcolor='linecolor',
+        facecolor=style.background_color)
+
+    ax.set_xlabel(string_formatter(x), color=style.font_color)
+    if style.format_funcs.get("x"):
+        ax.xaxis.set_major_formatter(
+            DynamicFuncFormatter(style.format_funcs.get("x")))
+    ax.tick_params(axis='x', colors=style.font_color,
+                   labelrotation=45, labelsize=style.font_size-4)
+
+    ax.set_ylabel(string_formatter(y), color=style.font_color)
+    if style.format_funcs.get("y"):
+        ax.yaxis.set_major_formatter(
+            DynamicFuncFormatter(style.format_funcs.get("y")))
+    ax.tick_params(axis='y', colors=style.font_color,
+                   labelsize=style.font_size-4)
+    ax.set_facecolor(style.background_color)
+    ax.grid(True)
+    if title:
+        ax.set_title(title, color=style.font_color, fontsize=style.font_size+4)
+    return ax
+
+
+def fplot_timeserie(pd_df: pd.DataFrame,
+                       label: str,
+                       x: str,
+                       y: str,
+                       title: Optional[str] = None,
+                       style: StyleTemplate = TIMESERIE_STYLE_TEMPLATE,
+                       max_values: int = 100,
+                       sort_by: Optional[str] = None,
+                       ascending: bool = False,
+                       std: bool = False,
+                       figsize: Tuple[float, float] = (19.2, 10.8)) -> Figure:
+    fig = plt.figure(figsize=figsize)
+    fig.patch.set_facecolor(style.background_color)
+    ax = fig.add_subplot()
+    ax = aplot_timeserie(pd_df=pd_df,
+                           label=label,
+                           x=x,
+                           y=y,
+                           title=title,
+                           style=style,
+                           max_values=max_values,
+                           std=std,
+                           sort_by=sort_by,
+                           ascending=ascending,
+                           ax=ax)
+    return fig
+# endregion

{matplotlibapi-3.2.1 → matplotlibapi-3.2.3}/MatplotLibAPI/Treemap.py

@@ -19,7 +19,7 @@ TREEMAP_STYLE_TEMPLATE = StyleTemplate(
 )
 
 
-def plot_treemap(pd_df: pd.DataFrame,
+def fplot_treemap(pd_df: pd.DataFrame,
                  path: str,
                  values: str,
                  style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,

matplotlibapi-3.2.3/MatplotLibAPI/__init__.py

@@ -0,0 +1,257 @@
+
+from .StyleTemplate import StyleTemplate
+from .Bubble import aplot_bubble, fplot_bubble, BUBBLE_STYLE_TEMPLATE
+from .Composite import plot_composite_bubble
+from .Timeserie import aplot_timeserie, fplot_timeserie, TIMESERIE_STYLE_TEMPLATE
+from .Table import aplot_table, fplot_table, TABLE_STYLE_TEMPLATE
+from .Network import aplot_network, aplot_network_components, NETWORK_STYLE_TEMPLATE
+from .Treemap import fplot_treemap, TREEMAP_STYLE_TEMPLATE
+from typing import List, Optional, Tuple
+import pandas as pd
+from pandas.api.extensions import register_dataframe_accessor
+
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+import plotly.graph_objects as go
+
+
+@register_dataframe_accessor("mpl")
+class DataFrameAccessor:
+
+    def __init__(self, pd_df: pd.DataFrame):
+        self._obj = pd_df
+
+    def aplot_bubble(self,
+                       label: str,
+                       x: str,
+                       y: str,
+                       z: str,
+                       title: Optional[str] = None,
+                       style: StyleTemplate = BUBBLE_STYLE_TEMPLATE,
+                       max_values: int = 50,
+                       center_to_mean: bool = False,
+                       sort_by: Optional[str] = None,
+                       ascending: bool = False,
+                       hline: bool = False,
+                       vline: bool = False,
+                       ax: Optional[Axes] = None) -> Axes:
+
+        return aplot_bubble(pd_df=self._obj,
+                              label=label,
+                              x=x,
+                              y=y,
+                              z=z,
+                              title=title,
+                              style=style,
+                              max_values=max_values,
+                              center_to_mean=center_to_mean,
+                              sort_by=sort_by,
+                              ascending=ascending,
+                              hline=hline,
+                              vline=vline,
+                              ax=ax)
+
+    def fplot_bubble(self,
+                        label: str,
+                        x: str,
+                        y: str,
+                        z: str,
+                        title: Optional[str] = None,
+                        style: StyleTemplate = BUBBLE_STYLE_TEMPLATE,
+                        max_values: int = 50,
+                        center_to_mean: bool = False,
+                        sort_by: Optional[str] = None,
+                        ascending: bool = False,
+                        hline: bool = False,
+                        vline: bool = False,
+                        figsize: Tuple[float, float] = (19.2, 10.8)) -> Figure:
+
+        return fplot_bubble(pd_df=self._obj,
+                               label=label,
+                               x=x,
+                               y=y,
+                               z=z,
+                               title=title,
+                               style=style,
+                               max_values=max_values,
+                               center_to_mean=center_to_mean,
+                               sort_by=sort_by,
+                               ascending=ascending,
+                               hline=hline,
+                               vline=vline,
+                               figsize=figsize)
+
+    def fplot_composite_bubble(self,
+                              label: str,
+                              x: str,
+                              y: str,
+                              z: str,
+                              title: Optional[str] = None,
+                              style: StyleTemplate = BUBBLE_STYLE_TEMPLATE,
+                              max_values: int = 100,
+                              center_to_mean: bool = False,
+                              sort_by: Optional[str] = None,
+                              ascending: bool = False) -> Figure:
+
+        return plot_composite_bubble(pd_df=self._obj,
+                                     label=label,
+                                     x=x,
+                                     y=y,
+                                     z=z,
+                                     title=title,
+                                     style=style,
+                                     max_values=max_values,
+                                     center_to_mean=center_to_mean,
+                                     sort_by=sort_by,
+                                     ascending=ascending)
+
+    def aplot_table_ax(self,
+                      cols: List[str],
+                      title: Optional[str] = None,
+                      style: StyleTemplate = TABLE_STYLE_TEMPLATE,
+                      max_values: int = 20,
+                      sort_by: Optional[str] = None,
+                      ascending: bool = False,
+                      ax: Optional[Axes] = None) -> Axes:
+
+        return aplot_table(pd_df=self._obj,
+                             cols=cols,
+                             title=title,
+                             style=style,
+                             max_values=max_values,
+                             sort_by=sort_by,
+                             ascending=ascending,
+                             ax=ax)
+
+    def fplot_table(self,
+                       cols: List[str],
+                       title: Optional[str] = None,
+                       style: StyleTemplate = TABLE_STYLE_TEMPLATE,
+                       max_values: int = 20,
+                       sort_by: Optional[str] = None,
+                       ascending: bool = False,
+                       figsize: Tuple[float, float] = (19.2, 10.8)) -> Axes:
+
+        return fplot_table(pd_df=self._obj,
+                              cols=cols,
+                              title=title,
+                              style=style,
+                              max_values=max_values,
+                              sort_by=sort_by,
+                              ascending=ascending,
+                              figsize=figsize)
+
+    def aplot_timeserie(self,
+                          label: str,
+                          x: str,
+                          y: str,
+                          title: Optional[str] = None,
+                          style: StyleTemplate = TIMESERIE_STYLE_TEMPLATE,
+                          max_values: int = 100,
+                          sort_by: Optional[str] = None,
+                          ascending: bool = False,
+                          std: bool = False,
+                          ax: Optional[Axes] = None) -> Axes:
+
+        return aplot_timeserie(pd_df=self._obj,
+                                 label=label,
+                                 x=x,
+                                 y=y,
+                                 title=title,
+                                 style=style,
+                                 max_values=max_values,
+                                 sort_by=sort_by,
+                                 ascending=ascending,
+                                 std=std,
+                                 ax=ax)
+
+    def fplot_timeserie(self,
+                           label: str,
+                           x: str,
+                           y: str,
+                           title: Optional[str] = None,
+                           style: StyleTemplate = TIMESERIE_STYLE_TEMPLATE,
+                           max_values: int = 100,
+                           sort_by: Optional[str] = None,
+                           ascending: bool = False,
+                           std: bool = False,
+                           figsize: Tuple[float, float] = (19.2, 10.8)) -> Axes:
+
+        return fplot_timeserie(pd_df=self._obj,
+                                  label=label,
+                                  x=x,
+                                  y=y,
+                                  title=title,
+                                  style=style,
+                                  max_values=max_values,
+                                  sort_by=sort_by,
+                                  ascending=ascending,
+                                  std=std,
+                                  figsize=figsize)
+
+    def aplot_network(self,
+                     source: str = "source",
+                     target: str = "target",
+                     weight: str = "weight",
+                     title: Optional[str] = None,
+                     style: StyleTemplate = NETWORK_STYLE_TEMPLATE,
+                     sort_by: Optional[str] = None,
+                     ascending: bool = False,
+                     node_list: Optional[List] = None,
+                     ax: Optional[Axes] = None) -> Axes:
+
+        return aplot_network(df=self._obj,
+                            source=source,
+                            target=target,
+                            weight=weight,
+                            title=title,
+                            style=style,
+                            sort_by=sort_by,
+                            ascending=ascending,
+                            node_list=node_list,
+                            ax=ax)
+
+    def aplot_network_components(self,
+                                source: str = "source",
+                                target: str = "target",
+                                weight: str = "weight",
+                                title: Optional[str] = None,
+                                style: StyleTemplate = NETWORK_STYLE_TEMPLATE,
+                                sort_by: Optional[str] = None,
+                                ascending: bool = False,
+                                node_list: Optional[List] = None,
+                                ax: Optional[Axes] = None) -> Axes:
+
+        return aplot_network_components(df=self._obj,
+                                       source=source,
+                                       target=target,
+                                       weight=weight,
+                                       title=title,
+                                       style=style,
+                                       sort_by=sort_by,
+                                       ascending=ascending,
+                                       node_list=node_list,
+                                       ax=ax)
+
+    def fplot_treemap(self,
+                     path: str,
+                     values: str,
+                     style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
+                     title: Optional[str] = None,
+                     color: Optional[str] = None,
+                     max_values: int = 100,
+                     sort_by: Optional[str] = None,
+                     ascending: bool = False) -> go.Figure:
+        return fplot_treemap(pd_df=self._obj,
+                            path=path,
+                            values=values,
+                            title=title,
+                            style=style,
+                            color=color,
+                            max_values=max_values,
+                            sort_by=sort_by,
+                            ascending=ascending)
+
+
+__all__ = ["validate_dataframe", "aplot_bubble", "aplot_timeserie", "aplot_table", "aplot_network", "aplot_network_components",
+           "plot_pivotbar", "fplot_treemap", "plot_composite_bubble", "StyleTemplate", "DataFrameAccessor"]

{matplotlibapi-3.2.1 → matplotlibapi-3.2.3/MatplotLibAPI.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MatplotLibAPI
-Version: 3.2.1
+Version: 3.2.3
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE

{matplotlibapi-3.2.1/MatplotLibAPI.egg-info → matplotlibapi-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MatplotLibAPI
-Version: 3.2.1
+Version: 3.2.3
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE

{matplotlibapi-3.2.1 → matplotlibapi-3.2.3}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "MatplotLibAPI"
-version="v3.2.1"
+version="v3.2.3"
 readme = "README.md"
 requires-python=">=3.7"
 dependencies = ["pandas","matplotlib","networkx","plotly","seaborn","scikit-learn","kaleido","nbformat"]

matplotlibapi-3.2.1/MatplotLibAPI/Timeserie.py

@@ -1,97 +0,0 @@
-# Hint for Visual Code Python Interactive window
-# %%
-from typing import Optional
-import pandas as pd
-import matplotlib.pyplot as plt
-from matplotlib.axes import Axes
-import seaborn as sns
-
-from .StyleTemplate import DynamicFuncFormatter, StyleTemplate, string_formatter, bmk_formatter, format_func,validate_dataframe
-
-
-TIMESERIE_STYLE_TEMPLATE = StyleTemplate(
-    palette='rocket',
-    format_funcs={"y": bmk_formatter, "label": string_formatter}
-)
-
-# region Line
-
-def plot_timeserie(pd_df: pd.DataFrame,
-                   label: str,
-                   x: str,
-                   y: str,
-                   title: Optional[str] = None,
-                   style: StyleTemplate = TIMESERIE_STYLE_TEMPLATE,
-                   max_values: int = 100,
-                   sort_by: Optional[str] = None,
-                   ascending: bool = False,
-                   ax: Optional[Axes] = None) -> Axes:
-
-    validate_dataframe(pd_df, cols=[label, x, y], sort_by=sort_by)
-    style.format_funcs = format_func(style.format_funcs, label=label, x=x, y=y)
-
-    df = pd_df[[label, x, y]].sort_values(by=[label, x])
-    df[x] = pd.to_datetime(df[x])
-    df.set_index(x, inplace=True)
-
-    sns.set_palette(style.palette)
-    # Colors for each group
-    colors = sns.color_palette(n_colors=len(df.columns))
-    if ax is None:
-        ax = plt.gca()
-
-    # Get unique dimension_types
-    label_types = df[label].unique()
-
-    # Colors for each group
-    colors = sns.color_palette(n_colors=len(label_types))
-
-    for label_type, color in zip(label_types, colors):
-        temp_df = df[df[label] == label_type].sort_values(by=x)
-
-        if style.format_funcs.get("label"):
-            label_type = style.format_funcs.get("label")(label_type)
-
-        ma = temp_df[y].rolling(window=7, min_periods=1).mean()
-        std_dev = temp_df[y].rolling(window=7, min_periods=1).std()
-
-        # Calculate the last moving average value to include in the legend
-        last_ma_value = ma.iloc[-1]
-
-        # Dynamically creating the legend label
-        label_str = f"{string_formatter(label_type)} (avg 7d: {style.format_funcs[y](last_ma_value)})"
-
-        # Plot moving average and include the last MA value in the label for the legend
-        plt.plot(temp_df.index, ma, color=color,
-                 linestyle='--', label=label_str)
-        plt.fill_between(temp_df.index, ma - std_dev, ma +
-                         std_dev, color=color, alpha=0.2, label='_nolegend_')
-
-    ax.legend(
-        title=label,
-        fontsize=style.font_size-4,
-        title_fontsize=style.font_size,
-        labelcolor='linecolor',
-        facecolor=style.background_color)
-
-    ax.set_xlabel(string_formatter(x), color=style.font_color)
-    if style.format_funcs.get("x"):
-        ax.xaxis.set_major_formatter(
-            DynamicFuncFormatter(style.format_funcs.get("x")))
-    ax.tick_params(axis='x', colors=style.font_color,
-                   labelrotation=45, labelsize=style.font_size-4)
-
-    ax.set_ylabel(string_formatter(y), color=style.font_color)
-    if style.format_funcs.get("y"):
-        ax.yaxis.set_major_formatter(
-            DynamicFuncFormatter(style.format_funcs.get("y")))
-    ax.tick_params(axis='y', colors=style.font_color,
-                   labelsize=style.font_size-4)
-    ax.set_facecolor(style.background_color)
-    ax.grid(True)
-    if title:
-        ax.set_title(title, color=style.font_color, fontsize=style.font_size+4)
-    return ax
-
-
-# endregion

matplotlibapi-3.2.1/MatplotLibAPI/__init__.py

@@ -1,181 +0,0 @@
-
-from .StyleTemplate import StyleTemplate
-from .Bubble import plot_bubble, BUBBLE_STYLE_TEMPLATE
-from .Composite import plot_composite_bubble
-from .Timeserie import plot_timeserie, TIMESERIE_STYLE_TEMPLATE
-from .Table import plot_table, TABLE_STYLE_TEMPLATE
-from .Network import plot_network, plot_network_components, NETWORK_STYLE_TEMPLATE
-from .Treemap import plot_treemap, TREEMAP_STYLE_TEMPLATE
-from typing import List, Optional
-import pandas as pd
-from pandas.api.extensions import register_dataframe_accessor
-
-from matplotlib.axes import Axes
-from matplotlib.figure import Figure
-import plotly.graph_objects as go
-
-
-@register_dataframe_accessor("mpl")
-class DataFrameAccessor:
-
-    def __init__(self, pd_df: pd.DataFrame):
-        self._obj = pd_df
-
-    def plot_bubble(self,
-                    label: str,
-                    x: str,
-                    y: str,
-                    z: str,
-                    title: Optional[str] = None,
-                    style: StyleTemplate = BUBBLE_STYLE_TEMPLATE,
-                    max_values: int = 50,
-                    center_to_mean: bool = False,
-                    sort_by: Optional[str] = None,
-                    ascending: bool = False,
-                    ax: Optional[Axes] = None) -> Axes:
-
-        return plot_bubble(pd_df=self._obj,
-                           label=label,
-                           x=x,
-                           y=y,
-                           z=z,
-                           title=title,
-                           style=style,
-                           max_values=max_values,
-                           center_to_mean=center_to_mean,
-                           sort_by=sort_by,
-                           ascending=ascending,
-                           ax=ax)
-
-    def plot_composite_bubble(self,
-                              label: str,
-                              x: str,
-                              y: str,
-                              z: str,
-                              title: Optional[str] = None,
-                              style: StyleTemplate = BUBBLE_STYLE_TEMPLATE,
-                              max_values: int = 100,
-                              center_to_mean: bool = False,
-                              sort_by: Optional[str] = None,
-                              ascending: bool = False,
-                              ax: Optional[Axes] = None) -> Figure:
-
-        return plot_composite_bubble(pd_df=self._obj,
-                                     label=label,
-                                     x=x,
-                                     y=y,
-                                     z=z,
-                                     title=title,
-                                     style=style,
-                                     max_values=max_values,
-                                     center_to_mean=center_to_mean,
-                                     sort_by=sort_by,
-                                     ascending=ascending,
-                                     ax=ax)
-
-    def plot_table(self,
-                   cols: List[str],
-                   title: Optional[str] = None,
-                   style: StyleTemplate = TABLE_STYLE_TEMPLATE,
-                   max_values: int = 20,
-                   sort_by: Optional[str] = None,
-                   ascending: bool = False,
-                   ax: Optional[Axes] = None) -> Axes:
-
-        return plot_table(pd_df=self._obj,
-                          cols=cols,
-                          title=title,
-                          style=style,
-                          max_values=max_values,
-                          sort_by=sort_by,
-                          ascending=ascending,
-                          ax=ax)
-
-    def plot_timeserie(self,
-                       label: str,
-                       x: str,
-                       y: str,
-                       title: Optional[str] = None,
-                       style: StyleTemplate = TIMESERIE_STYLE_TEMPLATE,
-                       max_values: int = 100,
-                       sort_by: Optional[str] = None,
-                       ascending: bool = False,
-                       ax: Optional[Axes] = None) -> Axes:
-
-        return plot_timeserie(pd_df=self._obj,
-                              label=label,
-                              x=x,
-                              y=y,
-                              title=title,
-                              style=style,
-                              max_values=max_values,
-                              sort_by=sort_by,
-                              ascending=ascending,
-                              ax=ax)
-
-    def plot_network(self,
-                     source: str = "source",
-                     target: str = "target",
-                     weight: str = "weight",
-                     title: Optional[str] = None,
-                     style: StyleTemplate = NETWORK_STYLE_TEMPLATE,
-                     sort_by: Optional[str] = None,
-                     ascending: bool = False,
-                     node_list: Optional[List] = None,
-                     ax: Optional[Axes] = None) -> Axes:
-
-        return plot_network(df=self._obj,
-                            source=source,
-                            target=target,
-                            weight=weight,
-                            title=title,
-                            style=style,
-                            sort_by=sort_by,
-                            ascending=ascending,
-                            node_list=node_list,
-                            ax=ax)
-
-    def plot_network_components(self,
-                                source: str = "source",
-                                target: str = "target",
-                                weight: str = "weight",
-                                title: Optional[str] = None,
-                                style: StyleTemplate = NETWORK_STYLE_TEMPLATE,
-                                sort_by: Optional[str] = None,
-                                ascending: bool = False,
-                                node_list: Optional[List] = None,
-                                ax: Optional[Axes] = None) -> Axes:
-
-        return plot_network_components(df=self._obj,
-                                       source=source,
-                                       target=target,
-                                       weight=weight,
-                                       title=title,
-                                       style=style,
-                                       sort_by=sort_by,
-                                       ascending=ascending,
-                                       node_list=node_list,
-                                       ax=ax)
-
-    def plot_treemap(self,
-                     path: str,
-                     values: str,
-                     style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
-                     title: Optional[str] = None,
-                     color: Optional[str] = None,
-                     max_values: int = 100,
-                     sort_by: Optional[str] = None,
-                     ascending: bool = False) -> go.Figure:
-        return plot_treemap(pd_df=self._obj,
-                            path=path,
-                            values=values,
-                            title=title,
-                            style=style,
-                            color=color,
-                            max_values=max_values,
-                            sort_by=sort_by,
-                            ascending=ascending)
-
-
-__all__ = ["validate_dataframe", "plot_bubble", "plot_timeserie", "plot_table", "plot_network", "plot_network_components",
-           "plot_pivotbar", "plot_treemap", "plot_composite_bubble", "StyleTemplate", "DataFrameAccessor"]