MatplotLibAPI 3.1.0__py3-none-any.whl → 3.1.2__py3-none-any.whl

MatplotLibAPI/Bubble.py

@@ -1,13 +1,12 @@
 # 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 typing import Optional
-from .Style import DynamicFuncFormatter, StyleTemplate, generate_ticks, _validate_panda, string_formatter, bmk_formatter, percent_formatter, format_func
 
+from . import DynamicFuncFormatter, StyleTemplate, generate_ticks, string_formatter, bmk_formatter, percent_formatter, format_func,validate_dataframe
 
 BUBBLE_STYLE_TEMPLATE = StyleTemplate(
     format_funcs={"label": string_formatter,
@@ -33,7 +32,7 @@ def plot_bubble(
         ascending: bool = False,
         ax: Optional[Axes] = None):
 
-    _validate_panda(pd_df, cols=[label, x, y, z], sort_by=sort_by)
+    validate_dataframe(pd_df, cols=[label, x, y, z], sort_by=sort_by)
     style.format_funcs = format_func(
         style.format_funcs, label=label, x=x, y=y, z=z)
     if not sort_by:

MatplotLibAPI/Composite.py

@@ -1,12 +1,14 @@
 # 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
-import pandas as pd
+
+from .Network import plot_network, plot_network_components, DEFAULT
 from .Bubble import plot_bubble, BUBBLE_STYLE_TEMPLATE
 from .Table import plot_table
-from typing import Optional, Tuple
-from .Style import StyleTemplate, _validate_panda, format_func
+from . import StyleTemplate, format_func, validate_dataframe
 
 
 def plot_composite_bubble(
@@ -19,13 +21,13 @@ def plot_composite_bubble(
         style: StyleTemplate = BUBBLE_STYLE_TEMPLATE,
         max_values: int = 50,
         center_to_mean: bool = False,
-        filter_by:Optional[str] = None,
+        filter_by: Optional[str] = None,
         sort_by: Optional[str] = None,
         ascending: bool = False,
         table_rows: int = 10,
         figsize: Tuple[float, float] = (19.2, 10.8)) -> Figure:
 
-    _validate_panda(pd_df, cols=[label, x, y, z], sort_by=sort_by)
+    validate_dataframe(pd_df, cols=[label, x, y, z], sort_by=sort_by)
 
     if not sort_by:
         sort_by = z

MatplotLibAPI/Network.py

@@ -13,7 +13,7 @@ from networkx import Graph
 from networkx.classes.graph import Graph
 
 
-from .Style import StyleTemplate, string_formatter, _validate_panda,format_func
+from . import StyleTemplate, string_formatter, format_func,validate_dataframe
 
 NETWORK_STYLE_TEMPLATE = StyleTemplate(
 )
@@ -165,23 +165,22 @@ class Graph(nx.Graph):
 
         return node_size, edges_width, fonts_size
 
-    def subgraphX(self, node_list=None, max_edges: int = DEFAULT["MAX_EDGES"]):
+    def subgraph(self, node_list=None, max_edges: int = DEFAULT["MAX_EDGES"]) -> Graph:
         if node_list is None:
             node_list = self.nodes.sort("weight")[:DEFAULT["MAX_NODES"]]
         connected_subgraph_nodes = list(self.find_connected_subgraph())
         node_list = [
             node for node in node_list if node in connected_subgraph_nodes]
 
-        subgraph = nx.subgraph(
-            self, nbunch=node_list)
+        subgraph = nx.subgraph(self, nbunch=node_list)
         edges = subgraph.top_k_edges(attribute="weight", k=5).keys()
         subgraph = subgraph.edge_subgraph(list(edges)[:max_edges])
-        return subgraph
+        return Graph(subgraph)
 
-    def plotX(self,
-              title: str = "Test",
-              style: StyleTemplate = NETWORK_STYLE_TEMPLATE,
-              ax: Optional[Axes] = None) -> Axes:
+    def plot_network(self,
+                   title: str = "Test",
+                   style: StyleTemplate = NETWORK_STYLE_TEMPLATE,
+                   ax: Optional[Axes] = None) -> Axes:
         """
         Plots the degree distribution of the graph, including a degree rank plot and a degree histogram.
         """
@@ -227,7 +226,7 @@ class Graph(nx.Graph):
 
         return ax
 
-    def analysis(self, node_list: Optional[List] = None,
+    def plot_network_components(self, node_list: Optional[List] = None,
                  scale: int = DEFAULT["GRAPH_SCALE"],
                  node_scale: int = DEFAULT["MAX_NODE_SIZE"],
                  edge_scale: float = DEFAULT["MAX_EDGE_WIDTH"],
@@ -235,13 +234,16 @@ class Graph(nx.Graph):
                  max_edges: int = DEFAULT["MAX_EDGES"],
                  plt_title: Optional[str] = "Top keywords"):
         # node_list=self.nodes_circuits(node_list)
-        g = self.subgraphX(max_edges=max_edges, node_list=node_list)
+        g = self.subgraph(max_edges=max_edges, node_list=node_list)
         connected_components = nx.connected_components(g)
+        axes=[]
         for connected_component in connected_components:
             if len(connected_component) > 5:
-                connected_component_graph = self.subgraphX(max_edges=max_edges,
-                                                           node_list=connected_component)
-                connected_component_graph.plotX()
+                connected_component_graph = self.subgraph(max_edges=max_edges,
+                                                          node_list=connected_component)
+                ax=connected_component_graph.plot_network()
+                axes.append(ax)
+        return axes
 
     def find_connected_subgraph(self):
         logging.info(f'find_connected_subgraph')
@@ -295,7 +297,7 @@ class Graph(nx.Graph):
     def from_pandas_edgelist(df: pd.DataFrame,
                              source: str = "source",
                              target: str = "target",
-                             weight: str = "weight"):
+                             weight: str = "weight") -> Graph:
         """
         Initialize netX instance with a simple dataframe
 
@@ -305,7 +307,6 @@ class Graph(nx.Graph):
         :param weight: Name of edges weight column in df_source.
 
         """
-        G = Graph()
         G = nx.from_pandas_edgelist(
             df, source=source, target=target, edge_attr=weight, create_using=G)
         G = G.find_connected_subgraph()
@@ -323,7 +324,7 @@ class Graph(nx.Graph):
         nx.set_node_attributes(G, node_aggregates, name=weight)
 
         G = G.edge_subgraph(edges=G.top_k_edges(attribute=weight))
-        return G
+        return Graph(G)
 
 
 def plot_network(pd_df: pd.DataFrame,
@@ -333,15 +334,49 @@ def plot_network(pd_df: pd.DataFrame,
                  title: str = "Test",
                  style: StyleTemplate = NETWORK_STYLE_TEMPLATE,
                  sort_by: Optional[str] = None,
-                 ascending: bool = False,
+                 ascending: bool = False, 
+                 node_list: Optional[List] = None,
                  ax: Optional[Axes] = None) -> Axes:
+    if node_list:
+        df = pd_df[(pd_df["source"].isin(node_list)) | (pd_df["target"].isin(node_list))]
+    else:
+        df = pd_df
+    validate_dataframe(df, cols=[source, target, weight], sort_by=sort_by)
 
-    _validate_panda(pd_df, cols=[source, target, weight], sort_by=sort_by)
-    
-    graph = Graph.from_pandas_edgelist(pd_df,
+    graph = Graph.from_pandas_edgelist(df,
                                        source=source,
                                        target=target,
                                        weight=weight)
-    return graph.plotX(title=title,
+    return graph.plot_network(title=title,
                        style=style,
                        ax=ax)
+
+def plot_network_components(pd_df: pd.DataFrame,
+                 source: str = "source",
+                 target: str = "target",
+                 weight: str = "weight",
+                 title: str = "Test",
+                 style: StyleTemplate = NETWORK_STYLE_TEMPLATE,
+                 sort_by: Optional[str] = None,
+                 node_list: Optional[List] = None,
+                 ascending: bool = False,
+                 ax: Optional[List[Axes]] = None) -> List[Axes]:
+    if node_list:
+        df = pd_df[(pd_df["source"].isin(node_list)) | (pd_df["target"].isin(node_list))]
+    else:
+        df = pd_df
+    validate_dataframe(df, cols=[source, target, weight], sort_by=sort_by)
+
+    graph = Graph.from_pandas_edgelist(df,
+                                       source=source,
+                                       target=target,
+                                       weight=weight)
+    connected_components = nx.connected_components(graph)
+    axes=[]
+    for connected_component in connected_components:
+        if len(connected_component) > 5:
+            connected_component_graph = graph.subgraph(node_list=connected_component)
+            ax=connected_component_graph.plot_network()
+            axes.append(ax)
+    return axes
+    

MatplotLibAPI/Pivot.py

@@ -10,15 +10,15 @@ from matplotlib.axes import Axes
 from matplotlib.dates import DateFormatter, MonthLocator
 
 
-
-from .Style import DynamicFuncFormatter, StyleTemplate, generate_ticks, string_formatter, _validate_panda, percent_formatter,format_func
+from . import DynamicFuncFormatter, StyleTemplate, generate_ticks, string_formatter,  percent_formatter, format_func
+from .. import validate_dataframe
 
 PIVOTBARS_STYLE_TEMPLATE = StyleTemplate(
     background_color='black',
     fig_border='darkgrey',
     font_color='white',
     palette='magma',
-    format_funcs={"y": percent_formatter, 
+    format_funcs={"y": percent_formatter,
                   "label": string_formatter}
 )
 PIVOTLINES_STYLE_TEMPLATE = StyleTemplate(
@@ -28,6 +28,7 @@ PIVOTLINES_STYLE_TEMPLATE = StyleTemplate(
     format_funcs={"y": percent_formatter, "label": string_formatter}
 )
 
+
 def plot_pivotbar(pd_df: pd.DataFrame,
                   label: str,
                   x: str,
@@ -39,8 +40,8 @@ def plot_pivotbar(pd_df: pd.DataFrame,
                   ascending: bool = False,
                   ax: Optional[Axes] = None):
 
-    _validate_panda(pd_df, cols=[label, x, y], sort_by=sort_by)
-    style.format_funcs=format_func(style.format_funcs,label=label,x=x,y=y)
+    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)
     pivot_df = pd.pivot_table(pd_df, values=y, index=[
                               x], columns=[label], aggfunc=agg)
     # Reset index to make x a column again

MatplotLibAPI/Table.py

@@ -2,7 +2,8 @@ from typing import List, Optional
 import pandas as pd
 import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
-from .Style import StyleTemplate, _validate_panda, string_formatter
+
+from . import StyleTemplate,  string_formatter,validate_dataframe
 
 TABLE_STYLE_TEMPLATE = StyleTemplate(
     background_color='black',
@@ -21,7 +22,7 @@ def plot_table(pd_df: pd.DataFrame,
                ascending: bool = False,
                ax: Optional[Axes] = None
                ) -> Axes:
-    _validate_panda(pd_df, cols=cols, sort_by=sort_by)
+    validate_dataframe(pd_df, cols=cols, sort_by=sort_by)
     
     if not sort_by:
         sort_by = cols[0]

MatplotLibAPI/Timeserie.py

@@ -1,12 +1,13 @@
 # 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 .Style import DynamicFuncFormatter, StyleTemplate, string_formatter, _validate_panda, bmk_formatter, format_func
-from typing import Optional
+
+from . import DynamicFuncFormatter, StyleTemplate, string_formatter, bmk_formatter, format_func,validate_dataframe
+
 
 TIMESERIE_STYLE_TEMPLATE = StyleTemplate(
     palette='rocket',
@@ -26,7 +27,7 @@ def plot_timeserie(pd_df: pd.DataFrame,
                    ascending: bool = False,
                    ax: Optional[Axes] = None) -> Axes:
 
-    _validate_panda(pd_df, cols=[label, x, y], sort_by=sort_by)
+    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])

MatplotLibAPI/Treemap.py

@@ -1,7 +1,13 @@
-from typing import List, Optional
+# Hint for Visual Code Python Interactive window
+# %%
+from typing import Optional
 import pandas as pd
+from pandas import CategoricalDtype,BooleanDtype
 import plotly.graph_objects as go
-from .Style import DynamicFuncFormatter, StyleTemplate, generate_ticks, string_formatter, _validate_panda, percent_formatter, format_func
+
+from . import StyleTemplate, string_formatter, percent_formatter,validate_dataframe
+
+
 
 TREEMAP_STYLE_TEMPLATE = StyleTemplate(
     background_color='black',
@@ -26,7 +32,7 @@ def plot_treemap(pd_df: pd.DataFrame,
     cols = [path, values]
     if color:
         cols.append(color)
-    _validate_panda(df, cols=cols, sort_by=sort_by)
+    validate_dataframe(pd_df, cols=cols, sort_by=sort_by)
     if not sort_by:
         sort_by = values
     df = pd_df.sort_values(by=sort_by, ascending=ascending)[
@@ -35,21 +41,39 @@ def plot_treemap(pd_df: pd.DataFrame,
             "parents": [""] * len(df),
             "values": df[values],
             "textinfo": "label",
-            "name": title}
+            "name": title,
+            "textfont":
+                {"family": style.font_name,
+                 "size": style.font_size,
+                 "color": style.font_color}
+            }
 
-    if color:
-        df['color'] = df[color]
+    if color and color in pd_df.columns:
+        color_data = pd_df[color]
+        if isinstance(color_data, CategoricalDtype) or pd.api.types.is_object_dtype(color_data):
+            color_data = color_data.astype('category').cat.codes
+        elif isinstance(color_data, BooleanDtype):
+            color_data = color_data.astype(int)
+        data['marker'] = dict(colorscale="Viridis",
+                              colors=color_data.to_list())
+
+    g = go.Treemap(data)
 
     if not fig:
-        fig = go.Figure(data=data)
+        fig = go.Figure(g)
     else:
-        fig.add_trace(go.Treemap(data))
-    
+        fig.add_trace(g)
+
     fig.update_layout(
-        paper_bgcolor=style.background_color,
+        title=title,
         plot_bgcolor=style.background_color,
-        font=dict(color=style.font_color),
-        margin=dict(t=50, l=25, r=25, b=25))
+        paper_bgcolor=style.background_color,
+        font=dict(
+            family=style.font_name,
+            size=style.font_size,
+            color=style.font_color
+        ),
+        showlegend=style.legend if style else True)
 
     # Apply color scale
     fig.update_traces(

MatplotLibAPI/__init__.py

@@ -1,14 +1,310 @@
 
-
-from .Table import plot_table
-from .Timeserie import plot_timeserie
-from .Bubble import plot_bubble
-from .Network import plot_network
-from .Pivot import plot_pivotbar
-from .Treemap import plot_treemap
+from .Treemap import plot_treemap, TREEMAP_STYLE_TEMPLATE
+from .Network import Graph
+from .Table import plot_table, TABLE_STYLE_TEMPLATE
+from .Timeserie import plot_timeserie, TIMESERIE_STYLE_TEMPLATE
 from .Composite import plot_composite_bubble
-from .pdAccessor import MatPlotLibAccessor
-from .Style import StyleTemplate
+from .Bubble import plot_bubble, BUBBLE_STYLE_TEMPLATE
+from typing import List, Optional, Dict, Callable, Union
+from dataclasses import dataclass
+import pandas as pd
+from pandas.api.extensions import register_dataframe_accessor
+import numpy as np
+
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from matplotlib.dates import num2date
+from matplotlib.ticker import FuncFormatter
+import plotly.graph_objects as go
+
+
+# region Utils
+
+def validate_dataframe(pd_df: pd.DataFrame,
+                       cols: List[str],
+                       sort_by: Optional[str] = None):
+    _columns = cols.copy()
+    if sort_by and sort_by not in _columns:
+        _columns.append(sort_by)
+    for col in _columns:
+        if col not in pd_df.columns:
+            raise AttributeError(f"{col} is not a DataFrame's column")
+
+
+def format_func(
+        format_funcs: Optional[Dict[str, Optional[Callable[[Union[int, float, str]], str]]]],
+        label: Optional[str] = None,
+        x: Optional[str] = None,
+        y: Optional[str] = None,
+        z: Optional[str] = None):
+
+    if label and "label" in format_funcs:
+        format_funcs[label] = format_funcs["label"]
+    if x and "x" in format_funcs:
+        format_funcs[x] = format_funcs["x"]
+    if y and "y" in format_funcs:
+        format_funcs[y] = format_funcs["y"]
+    if z and "z" in format_funcs:
+        format_funcs[z] = format_funcs["z"]
+    return format_funcs
+
+# endregion
+
+# region Style
+
+
+MAX_RESULTS = 50
+X_COL = "index"
+Y_COL = "overlap"
+Z_COL = "users"
+FIG_SIZE = (19.2, 10.8)
+BACKGROUND_COLOR = 'black'
+TEXT_COLOR = 'white'
+PALETTE = "Greys_r"
+FONT_SIZE = 14
+
+
+@dataclass
+class StyleTemplate:
+    background_color: str = BACKGROUND_COLOR
+    fig_border: str = BACKGROUND_COLOR
+    font_name: str = 'Arial'
+    font_size: int = FONT_SIZE
+    font_color: str = TEXT_COLOR
+    palette: str = PALETTE
+    legend: bool = True
+    xscale: Optional[str] = None
+    x_ticks: int = 10
+    yscale: Optional[str] = None
+    y_ticks: int = 5
+    format_funcs: Optional[Dict[str, Optional[Callable[[
+        Union[int, float, str]], str]]]] = None
+    col_widths: Optional[List[float]] = None
+
+    @property
+    def font_mapping(self):
+        return {0: self.font_size-3,
+                1: self.font_size-1,
+                2: self.font_size,
+                3: self.font_size+1,
+                4: self.font_size+3}
+
+
+class DynamicFuncFormatter(FuncFormatter):
+    def __init__(self, func_name):
+        super().__init__(func_name)
+
+
+def percent_formatter(val, pos: Optional[int] = None):
+    if val*100 <= 0.1:  # For 0.1%
+        return f"{val*100:.2f}%"
+    elif val*100 <= 1:  # For 1%
+        return f"{val*100:.1f}%"
+    else:
+        return f"{val*100:.0f}%"
+
+
+def bmk_formatter(val, pos: Optional[int] = None):
+    if val >= 1_000_000_000:  # Billions
+        return f"{val / 1_000_000_000:.2f}B"
+    elif val >= 1_000_000:  # Millions
+        return f"{val / 1_000_000:.1f}M"
+    elif val >= 1_000:  # Thousands
+        return f"{val / 1_000:.1f}K"
+    else:
+        return f"{int(val)}"
+
+
+def integer_formatter(value, pos: Optional[int] = None):
+    return f"{int(value)}"
+
+
+def string_formatter(value, pos: Optional[int] = None):
+    return str(value).replace("-", " ").replace("_", " ").title()
+
+
+def yy_mm__formatter(x, pos: Optional[int] = None):
+    return num2date(x).strftime('%Y-%m')
+
+
+def yy_mm_dd__formatter(x, pos: Optional[int] = None):
+    return num2date(x).strftime('%Y-%m-%D')
+
+
+def percent_formatter(x,  pos: Optional[int] = None):
+    return f"{x * 100:.0f}%"
+
+
+def generate_ticks(min_val, max_val, num_ticks="10"):
+    # Identify the type of the input
+    try:
+        min_val = float(min_val)
+        max_val = float(max_val)
+        is_date = False
+    except ValueError:
+        is_date = True
+
+    # Convert string inputs to appropriate numerical or date types
+    num_ticks = int(num_ticks)
+
+    if is_date:
+        min_val = pd.Timestamp(min_val).to_datetime64()
+        max_val = pd.Timestamp(max_val).to_datetime64()
+        data_range = (max_val - min_val).astype('timedelta64[D]').astype(int)
+    else:
+        data_range = max_val - min_val
+
+    # Calculate a nice step size
+    step_size = data_range / (num_ticks - 1)
+
+    # If date, convert back to datetime
+    if is_date:
+        ticks = pd.date_range(
+            start=min_val, periods=num_ticks, freq=f"{step_size}D")
+    else:
+        # Round the step size to a "nice" number
+        exponent = np.floor(np.log10(step_size))
+        fraction = step_size / 10**exponent
+        nice_fraction = round(fraction)
+
+        # Create nice step size
+        nice_step = nice_fraction * 10**exponent
+
+        # Generate the tick marks based on the nice step size
+        ticks = np.arange(min_val, max_val + nice_step, nice_step)
+
+    return ticks
+
+
+# endregion
+
+
+@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) -> 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)
+
+    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) -> 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 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) -> Axes:
+
+        return plot_table(pd_df=self._obj,
+                          cols=cols,
+                          title=title,
+                          style=style,
+                          max_values=max_values,
+                          sort_by=sort_by,
+                          ascending=ascending)
+
+    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) -> 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)
+
+    def plot_network(self,
+                     source: str = "source",
+                     target: str = "target",
+                     weight: str = "weight",
+                     title: Optional[str] = None,
+                     style: StyleTemplate = TIMESERIE_STYLE_TEMPLATE,
+                     max_values: int = 20,
+                     sort_by: Optional[str] = None,
+                     ascending: bool = False) -> Axes:
+
+        graph = Graph.from_pandas_edgelist(df=self._obj,
+                                           source=source,
+                                           target=target,
+                                           weight=weight)
+
+        return graph.plotX(title, style)
+
+    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__ = ["plot_bubble", "plot_timeserie", "plot_table", "plot_network",
-           "plot_pivotbar", "plot_treemap","plot_composite_bubble", "StyleTemplate", "MatPlotLibAccessor"]
+__all__ = ["validate_dataframe", "plot_bubble", "plot_timeserie", "plot_table", "plot_network", "plot_network_components",
+           "plot_pivotbar", "plot_treemap", "plot_composite_bubble", "StyleTemplate", "DataFrameAccessor"]

{MatplotLibAPI-3.1.0.dist-info → MatplotLibAPI-3.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MatplotLibAPI
-Version: 3.1.0
+Version: 3.1.2
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -10,6 +10,14 @@ Requires-Dist: networkx
 Requires-Dist: plotly
 Requires-Dist: seaborn
 Requires-Dist: scikit-learn
+Requires-Dist: kaleido
+Requires-Dist: nbformat
 
 # MatplotLibAPI
-Simple Wrapper
+Simple pandas Dataframe to generate plots:
+Bubble (Scatter plot)
+Network (Graph)
+pivot
+Table
+Timeserie
+Treemap

MatplotLibAPI-3.1.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+MatplotLibAPI/Bubble.py,sha256=zfm5Y2YU824TzvFb_57HeeTgOXgx0oozBRcxqr6g_lo,3829
+MatplotLibAPI/Composite.py,sha256=V5VgYt6cSJkz74XtMoQHHr9VrJXojCFsmxjkqwA0oYc,2834
+MatplotLibAPI/Network.py,sha256=zdu6kVIja0peYLL4mdpw76BijLn6hAmtoKbK_YukZC0,14836
+MatplotLibAPI/Pivot.py,sha256=Bo7ZpkxqoE75e8vpSsKIT5X2Q7lLdfAyy46ox1fARbc,7183
+MatplotLibAPI/Table.py,sha256=hokyBgkiwlA0B8Irx2yPL4xCeZlI-HK0Jln79qjMwZk,1992
+MatplotLibAPI/Timeserie.py,sha256=kl7G5TgIz1MKEBegPE_hHuoPcMCS7-JkCjDyx3wuM8Q,3433
+MatplotLibAPI/Treemap.py,sha256=ImfnPagGQkPwk15Yywroir-FLbBvBzpytEb1Uw7iQi4,2539
+MatplotLibAPI/__init__.py,sha256=FoN0Qa1efBbRDK27vOxdQxT-iRMH4Hqz5WKxMdoSvZc,10430
+MatplotLibAPI-3.1.2.dist-info/LICENSE,sha256=hMErKLb6YZR3lRR5zr-vxeFkvY69QAaafgSpZ5-P1dQ,1067
+MatplotLibAPI-3.1.2.dist-info/METADATA,sha256=uH2EUAne0e9xsrALJ9TUCRnEgfi5P0NIOtsv_4PnVps,462
+MatplotLibAPI-3.1.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+MatplotLibAPI-3.1.2.dist-info/top_level.txt,sha256=MrzbBjDEW48Vb6YhQIqpFYGOhHzQnEIM5Qy2xy2iqew,14
+MatplotLibAPI-3.1.2.dist-info/RECORD,,

MatplotLibAPI/Style.py

@@ -1,171 +0,0 @@
-
-from dataclasses import dataclass
-
-from typing import List, Optional, Union, Dict, Callable
-
-import numpy as np
-import pandas as pd
-
-from matplotlib.dates import num2date
-from matplotlib.ticker import FuncFormatter
-
-# region Panda
-
-
-def _validate_panda(pd_df: pd.DataFrame,
-                    cols: List[str],
-                    sort_by: Optional[str] = None):
-    _columns = cols.copy()
-    if sort_by and sort_by not in _columns:
-        _columns.append(sort_by)
-    for col in _columns:
-        if col not in pd_df.columns:
-            raise AttributeError(f"{col} is not a DataFrame's column")
-
-
-def format_func(
-                format_funcs: Optional[Dict[str, Optional[Callable[[Union[int, float, str]], str]]]],
-                label: Optional[str] = None,
-                x: Optional[str] = None,
-                y: Optional[str] = None,
-                z: Optional[str] = None):
-
-    if label and "label" in format_funcs:
-        format_funcs[label] = format_funcs["label"]
-    if x and "x" in format_funcs:
-        format_funcs[x] = format_funcs["x"]
-    if y and "y" in format_funcs:
-        format_funcs[y] = format_funcs["y"]
-    if z and "z" in format_funcs:
-        format_funcs[z] = format_funcs["z"]
-    return format_funcs
-
-# endregion
-
-# region Style
-
-
-MAX_RESULTS = 50
-X_COL = "index"
-Y_COL = "overlap"
-Z_COL = "users"
-FIG_SIZE = (19.2, 10.8)
-BACKGROUND_COLOR = 'black'
-TEXT_COLOR = 'white'
-PALETTE = "Greys_r"
-FONT_SIZE = 14
-
-
-@dataclass
-class StyleTemplate:
-    background_color: str = BACKGROUND_COLOR
-    fig_border: str = BACKGROUND_COLOR
-    font_name: str = 'Arial'
-    font_size: int = FONT_SIZE
-    font_color: str = TEXT_COLOR
-    palette: str = PALETTE
-    legend: bool = True
-    xscale: Optional[str] = None
-    x_ticks: int = 10
-    yscale: Optional[str] = None
-    y_ticks: int = 5
-    format_funcs: Optional[Dict[str, Optional[Callable[[
-        Union[int, float, str]], str]]]] = None
-    col_widths: Optional[List[float]] = None
-
-    @property
-    def font_mapping(self):
-        return {0: self.font_size-3,
-                1: self.font_size-1,
-                2: self.font_size,
-                3: self.font_size+1,
-                4: self.font_size+3}
-
-
-class DynamicFuncFormatter(FuncFormatter):
-    def __init__(self, func_name):
-        super().__init__(func_name)
-
-
-def percent_formatter(val, pos: Optional[int] = None):
-    if val*100 <= 0.1:  # For 0.1%
-        return f"{val*100:.2f}%"
-    elif val*100 <= 1:  # For 1%
-        return f"{val*100:.1f}%"
-    else:
-        return f"{val*100:.0f}%"
-
-
-def bmk_formatter(val, pos: Optional[int] = None):
-    if val >= 1_000_000_000:  # Billions
-        return f"{val / 1_000_000_000:.2f}B"
-    elif val >= 1_000_000:  # Millions
-        return f"{val / 1_000_000:.1f}M"
-    elif val >= 1_000:  # Thousands
-        return f"{val / 1_000:.1f}K"
-    else:
-        return f"{int(val)}"
-
-
-def integer_formatter(value, pos: Optional[int] = None):
-    return f"{int(value)}"
-
-
-def string_formatter(value, pos: Optional[int] = None):
-    return str(value).replace("-", " ").replace("_", " ").title()
-
-
-def yy_mm__formatter(x, pos: Optional[int] = None):
-    return num2date(x).strftime('%Y-%m')
-
-
-def yy_mm_dd__formatter(x, pos: Optional[int] = None):
-    return num2date(x).strftime('%Y-%m-%D')
-
-
-def percent_formatter(x,  pos: Optional[int] = None):
-    return f"{x * 100:.0f}%"
-
-
-def generate_ticks(min_val, max_val, num_ticks="10"):
-    # Identify the type of the input
-    try:
-        min_val = float(min_val)
-        max_val = float(max_val)
-        is_date = False
-    except ValueError:
-        is_date = True
-
-    # Convert string inputs to appropriate numerical or date types
-    num_ticks = int(num_ticks)
-
-    if is_date:
-        min_val = pd.Timestamp(min_val).to_datetime64()
-        max_val = pd.Timestamp(max_val).to_datetime64()
-        data_range = (max_val - min_val).astype('timedelta64[D]').astype(int)
-    else:
-        data_range = max_val - min_val
-
-    # Calculate a nice step size
-    step_size = data_range / (num_ticks - 1)
-
-    # If date, convert back to datetime
-    if is_date:
-        ticks = pd.date_range(
-            start=min_val, periods=num_ticks, freq=f"{step_size}D")
-    else:
-        # Round the step size to a "nice" number
-        exponent = np.floor(np.log10(step_size))
-        fraction = step_size / 10**exponent
-        nice_fraction = round(fraction)
-
-        # Create nice step size
-        nice_step = nice_fraction * 10**exponent
-
-        # Generate the tick marks based on the nice step size
-        ticks = np.arange(min_val, max_val + nice_step, nice_step)
-
-    return ticks
-
-
-# endregion

MatplotLibAPI/pdAccessor.py

@@ -1,147 +0,0 @@
-
-import logging
-import warnings
-
-from typing import Optional, List
-import pandas as pd
-
-from matplotlib.axes import Axes
-from matplotlib.figure import Figure
-import plotly.graph_objects as go
-from .Style 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 Graph
-from .Treemap import plot_treemap, TREEMAP_STYLE_TEMPLATE
-
-warnings.filterwarnings('ignore')
-logging.getLogger().setLevel(logging.WARNING)
-
-
-@pd.api.extensions.register_dataframe_accessor("mpl")
-class MatPlotLibAccessor:
-
-    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) -> 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)
-
-    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) -> 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 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) -> Axes:
-
-        return plot_table(pd_df=self._obj,
-                          cols=cols,
-                          title=title,
-                          style=style,
-                          max_values=max_values,
-                          sort_by=sort_by,
-                          ascending=ascending)
-
-    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) -> 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)
-
-    def plot_network(self,
-                     source: str = "source",
-                     target: str = "target",
-                     weight: str = "weight",
-                     title: Optional[str] = None,
-                     style: StyleTemplate = TIMESERIE_STYLE_TEMPLATE,
-                     max_values: int = 20,
-                     sort_by: Optional[str] = None,
-                     ascending: bool = False) -> Axes:
-
-        graph = Graph.from_pandas_edgelist(df=self._obj,
-                                           source=source,
-                                           target=target,
-                                           weight=weight)
-
-        return graph.plotX(title, style)
-    
-    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)

MatplotLibAPI-3.1.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-MatplotLibAPI/Bubble.py,sha256=2PIwL0stzFC7knqdMHBBm99DXPXtBJK-xmpxmVlInYw,3830
-MatplotLibAPI/Composite.py,sha256=M_AaBdn9cfMIOGZBg4_twRS9VU9jbgS6cs9E5l3ObOQ,2763
-MatplotLibAPI/Network.py,sha256=fq1-LfDKy3oC5JzqU7IyZudgR2plmziigjpm2TzEA3U,13286
-MatplotLibAPI/Pivot.py,sha256=8jRYdlvw8otrJ1hYBAaKQJoN84xe-YfroXmgRLykMmQ,7162
-MatplotLibAPI/Style.py,sha256=xtw71VWHSQEvts1nJdKR0c_9Rqef6EGkyyvgdTK5M7c,4632
-MatplotLibAPI/Table.py,sha256=Az5uX-ViqzJPTBym4QnUzn5PD5LEsVzQ9WohcSDFcK4,1990
-MatplotLibAPI/Timeserie.py,sha256=HRFHs_WzaZzLmWVVMBKVMP5M3oglsr1R9Ni53X7_HLI,3432
-MatplotLibAPI/Treemap.py,sha256=diCx5270ENBObO3eWlLlpaHWUWcSgMT34vEwWTxTDAE,1799
-MatplotLibAPI/__init__.py,sha256=PDobJg0sw7BjgSQk7p7kkjombghs3D_m-CCk2oeUt_s,506
-MatplotLibAPI/pdAccessor.py,sha256=5duWsURQKgNuwCz1p0ge2GbAXHSHl8e38zJn6NSVAGg,5745
-MatplotLibAPI-3.1.0.dist-info/LICENSE,sha256=hMErKLb6YZR3lRR5zr-vxeFkvY69QAaafgSpZ5-P1dQ,1067
-MatplotLibAPI-3.1.0.dist-info/METADATA,sha256=UvD4nRviP67nS7KnDWa1Dcmt8PygsjCUs6cioLgHQv4,319
-MatplotLibAPI-3.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-MatplotLibAPI-3.1.0.dist-info/top_level.txt,sha256=MrzbBjDEW48Vb6YhQIqpFYGOhHzQnEIM5Qy2xy2iqew,14
-MatplotLibAPI-3.1.0.dist-info/RECORD,,