MatplotLibAPI 1.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

MatplotLibAPI/Bubble.py

@@ -0,0 +1,127 @@
+# Hint for Visual Code Python Interactive window
+# %%
+
+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
+
+
+BUBBLE_STYLE_TEMPLATE = StyleTemplate(
+    format_funcs={"label": string_formatter,
+                  "x": bmk_formatter,
+                  "y": percent_formatter,
+                  "label": string_formatter,
+                  "z": bmk_formatter},
+    yscale="log",
+    y_ticks=8,
+    x_ticks=8
+)
+
+
+def plot_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,
+        ax: Optional[Axes] = None):
+
+    _validate_panda(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:
+        sort_by = z
+
+    plot_df = pd_df[[label, x, y, z]].sort_values(
+        by=sort_by, ascending=ascending).head(max_values)
+    if center_to_mean:
+        x_col_mean = plot_df[x].mean()
+        plot_df[x] = plot_df[x] - x_col_mean
+    plot_df['quintile'] = pd.qcut(
+        plot_df[z], 5, labels=False)
+
+    # styling
+
+    plot_df["fontsize"] = plot_df['quintile'].map(style.font_mapping)
+
+    if not ax:
+        ax = plt.gca()
+
+    ax = sns.scatterplot(
+        data=plot_df,
+        x=x,
+        y=y,
+        size=z,
+        hue='quintile',
+        sizes=(100, 2000),
+        legend=False,
+        palette=sns.color_palette(style.palette, as_cmap=True),
+        edgecolor=style.background_color,
+        ax=ax)
+    ax.set_facecolor(style.background_color)
+    if style.xscale:
+        ax.set(xscale=style.xscale)
+    if style.yscale:
+        ax.set(yscale=style.yscale)
+
+    x_min = pd_df[x].min()
+    x_max = pd_df[x].max()
+    x_mean = pd_df[x].mean()
+    ax.set_xticks(generate_ticks(x_min, x_max, num_ticks=style.x_ticks))
+    ax.xaxis.grid(True, "major", linewidth=.5, color=style.font_color)
+    if style.format_funcs.get("x"):
+        ax.xaxis.set_major_formatter(
+            DynamicFuncFormatter(style.format_funcs.get("x")))
+
+    y_min = pd_df[y].min()
+    y_max = pd_df[y].max()
+    y_mean = pd_df[y].mean()
+    ax.set_yticks(generate_ticks(y_min, y_max, num_ticks=style.y_ticks))
+    ax.yaxis.grid(True, "major", linewidth=.5, 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='both',
+                   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)
+
+    for index, row in plot_df.iterrows():
+        x_value = row[x]
+        y_value = row[y]
+        s_value = str(row[label])
+        if style.format_funcs.get("label"):
+            s_value = style.format_funcs.get("label")(s_value)
+        fs = row["fontsize"]
+        ax.text(x_value,
+                y_value,
+                s_value,
+                horizontalalignment='center',
+                fontdict={'color': style.font_color, 'fontsize': fs})
+    if title:
+        ax.set_title(title, color=style.font_color, fontsize=style.font_size*2)
+    return ax
+
+
+# endregion

MatplotLibAPI/Composite.py

@@ -0,0 +1,78 @@
+# Hint for Visual Code Python Interactive window
+# %%
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+import pandas as pd
+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
+
+
+def plot_composite_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 = 50,
+        center_to_mean: bool = False,
+        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)
+    style.format_funcs=format_func(style.format_funcs,label=label,x=x,y=y)
+    fig = plt.figure(figsize=figsize)
+    fig.patch.set_facecolor("black")
+    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=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,
+                     ax=ax)
+
+    if "label" in style.format_funcs:
+        style.format_funcs[label] = style.format_funcs["label"]
+    if "x" in style.format_funcs:
+        style.format_funcs[x] = style.format_funcs["x"]
+    if "y" in style.format_funcs:
+        style.format_funcs[y] = style.format_funcs["y"]
+    if "z" in style.format_funcs:
+        style.format_funcs[z] = style.format_funcs["z"]
+
+    ax2 = fig.add_subplot(grid[1, 0])
+    ax2 = plot_table(
+        pd_df=pd_df,
+        cols=[label, z, y, x],
+        title=f"Top {table_rows}",
+        ax=ax2,
+        sort_by=sort_by,
+        ascending=False,
+        max_values=table_rows,
+        style=style
+    )
+    ax3 = fig.add_subplot(grid[1, 1])
+    ax3 = plot_table(
+        pd_df=pd_df,
+        cols=[label, z, y, x],
+        title=f"Worst {table_rows}",
+        ax=ax3,
+        sort_by=sort_by,
+        ascending=True,
+        max_values=table_rows,
+        style=style
+    )
+    fig.tight_layout()
+    return fig

MatplotLibAPI/Network.py

@@ -0,0 +1,347 @@
+import logging
+from collections import defaultdict
+from collections.abc import Iterable
+from typing import Any, Dict, List, Optional, Tuple
+
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+import seaborn as sns
+import networkx as nx
+import numpy as np
+import pandas as pd
+from networkx import Graph
+from networkx.classes.graph import Graph
+
+
+from .Style import StyleTemplate, string_formatter, _validate_panda,format_func
+
+NETWORK_STYLE_TEMPLATE = StyleTemplate(
+)
+
+DEFAULT = {"MAX_EDGES": 100,
+           "MAX_NODES": 30,
+           "MIN_NODE_SIZE": 100,
+           "MAX_NODE_SIZE": 2000,
+           "MAX_EDGE_WIDTH": 10,
+           "GRAPH_SCALE": 2,
+           "MAX_FONT_SIZE": 20,
+           "MIN_FONT_SIZE": 8
+           }
+
+
+def softmax(x):
+    return (np.exp(x - np.max(x)) / np.exp(x - np.max(x)).sum())
+
+
+def scale_weights(weights, scale_min=0, scale_max=1):
+    deciles = np.percentile(weights, [10, 20, 30, 40, 50, 60, 70, 80, 90])
+    outs = np.searchsorted(deciles, weights)
+    return [out * (scale_max-scale_min)/len(deciles)+scale_min for out in outs]
+
+
+class NodeView(nx.classes.reportviews.NodeView):
+    def sort(self,
+             attribute: Optional[str] = 'weight',
+             reverse: Optional[bool] = True):
+        # Sort the nodes based on the specified attribute
+        sorted_nodes = sorted(self,
+                              key=lambda node: self[node][attribute],
+                              reverse=reverse)
+        return sorted_nodes
+
+    def filter(self, attribute: str, value: str):
+        # Filter the nodes based on the specified attribute and value
+        filtered_nodes = [
+            node for node in self if attribute in self[node] and self[node][attribute] == value]
+        return filtered_nodes
+
+
+class AdjacencyView(nx.classes.coreviews.AdjacencyView):
+    def sort(self,
+             attribute: Optional[str] = 'weight',
+             reverse: Optional[bool] = True):
+        # Sort the nodes based on the specified attribute
+        sorted_nodes = sorted(self,
+                              key=lambda node: self[node][attribute],
+                              reverse=reverse)
+        return sorted_nodes
+
+    def filter(self, attribute: str, value: str):
+        # Filter the nodes based on the specified attribute and value
+        filtered_nodes = [
+            node for node in self if attribute in self[node] and self[node][attribute] == value]
+        return filtered_nodes
+
+
+class EdgeView(nx.classes.reportviews.EdgeView):
+    def sort(self,
+             reverse: Optional[bool] = True,
+             attribute: Optional[str] = 'weight'):
+        sorted_edges = sorted(self(data=True),
+                              key=lambda t: t[2].get(attribute, 1),
+                              reverse=reverse)
+        return {(u, v): _ for u, v, _ in sorted_edges}
+
+    def filter(self, attribute: str, value: str):
+        # Filter the edges based on the specified attribute and value
+        filtered_edges = [
+            edge for edge in self if attribute in self[edge] and self[edge][attribute] == value]
+        return [(edge[0], edge[1]) for edge in filtered_edges]
+
+
+class Graph(nx.Graph):
+    """
+    Custom graph class based on NetworkX's Graph class.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._scale = 1.0
+
+    @property
+    def scale(self) -> float:
+        return self._scale
+
+    @scale.setter
+    def scale(self, value: float):
+        self._scale = value
+
+    @property
+    def nodes(self):
+        return NodeView(self)
+
+    @nodes.setter
+    def scale(self, value: NodeView):
+        self.nodes = value
+
+    @property
+    def edges(self):
+        return EdgeView(self)
+
+    @property
+    def adjacency(self):
+        return AdjacencyView(list(self))
+
+    def edge_subgraph(self, edges: Iterable) -> Graph:
+        return nx.edge_subgraph(self, edges)
+
+    def layout(self,
+               max_node_size: int = DEFAULT["MAX_NODES"],
+               min_node_size: int = DEFAULT["MAX_NODES"],
+               max_edge_width: int = DEFAULT["MAX_EDGE_WIDTH"],
+               max_font_size: int = DEFAULT["MAX_FONT_SIZE"],
+               min_font_size: int = DEFAULT["MIN_FONT_SIZE"]):
+        """
+        Calculates the sizes for nodes, edges, and fonts based on node weights and edge weights.
+
+        Parameters:
+        - max_node_size (int): Maximum size for nodes (default: 300).
+        - max_edge_width (int): Maximum width for edges (default: 10).
+        - max_font_size (int): Maximum font size for node labels (default: 18).
+
+        Returns:
+        - Tuple[List[int], List[int], Dict[int, List[str]]]: A tuple containing the node sizes, edge widths,
+          and font sizes for node labels.
+        """
+        # Normalize and scale nodes' weights within the desired range of edge widths
+        node_weights = [data.get('weight', 1)
+                        for node, data in self.nodes(data=True)]
+        node_size = scale_weights(
+            weights=node_weights, scale_max=max_node_size, scale_min=min_node_size)
+
+        # Normalize and scale edges' weights within the desired range of edge widths
+        edge_weights = [data.get('weight', 0)
+                        for _, _, data in self.edges(data=True)]
+        edges_width = scale_weights(
+            weights=edge_weights, scale_max=max_edge_width)
+
+        # Scale the normalized node weights within the desired range of font sizes
+        node_size_dict = dict(zip(self.nodes, scale_weights(
+            weights=node_weights, scale_max=max_font_size, scale_min=min_font_size)))
+        fonts_size = defaultdict(list)
+        for node, width in node_size_dict.items():
+            fonts_size[int(width)].append(node)
+        fonts_size = dict(fonts_size)
+
+        return node_size, edges_width, fonts_size
+
+    def subgraphX(self, node_list=None, max_edges: int = DEFAULT["MAX_EDGES"]):
+        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)
+        edges = subgraph.top_k_edges(attribute="weight", k=5).keys()
+        subgraph = subgraph.edge_subgraph(list(edges)[:max_edges])
+        return subgraph
+
+    def plotX(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.
+        """
+        degree_sequence = sorted([d for n, d in self.degree()], reverse=True)
+        dmax = max(degree_sequence)
+        sns.set_palette(style.palette)
+        if ax is None:
+            ax = plt.gca()
+
+        node_sizes, edge_widths, font_sizes = self.layout(
+            min_node_size=DEFAULT["MIN_NODE_SIZE"]/5,
+            max_node_size=DEFAULT["MAX_NODE_SIZE"],
+            max_edge_width=DEFAULT["MAX_EDGE_WIDTH"],
+            min_font_size=style.font_mapping.get(0),
+            max_font_size=style.font_mapping.get(4))
+        pos = nx.spring_layout(self, k=1)
+        # nodes
+        nx.draw_networkx_nodes(self,
+                               pos,
+                               ax=ax,
+                               node_size=list(node_sizes),
+                               node_color=node_sizes,
+                               cmap=plt.cm.get_cmap(style.palette))
+        # edges
+        nx.draw_networkx_edges(self,
+                               pos,
+                               ax=ax,
+                               edge_color=style.font_color,
+                               edge_cmap=plt.cm.get_cmap(style.palette),
+                               width=edge_widths)
+        # labels
+        for font_size, nodes in font_sizes.items():
+            nx.draw_networkx_labels(
+                self,
+                pos,
+                ax=ax,
+                font_size=font_size,
+                font_color=style.font_color,
+                labels={n: string_formatter(n) for n in nodes})
+        ax.set_facecolor(style.background_color)
+        ax.set_title(title, color=style.font_color, fontsize=style.font_size*2)
+        ax.set_axis_off()
+
+        return ax
+
+    def analysis(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"],
+                 max_nodes: int = DEFAULT["MAX_NODES"],
+                 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)
+        connected_components = nx.connected_components(g)
+        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()
+
+    def find_connected_subgraph(self):
+        logging.info(f'find_connected_subgraph')
+        # Copy the original graph to avoid modifying it
+        H = self.copy()
+
+        # Flag to keep track of whether any node with degree < 2 was removed
+        removed_node = True
+
+        while removed_node:
+            removed_node = False
+            # Iterate over the nodes
+            for node in list(H.nodes):
+                if H.degree(node) < 2:
+                    # Remove the node and its incident edges
+                    logging.info(
+                        f'Removing the {node} node and its incident edges')
+                    H.remove_node(node)
+                    removed_node = True
+                    break
+
+        return H
+
+    def top_k_edges(self, attribute: str, reverse: bool = True, k: int = 5) -> Dict[Any, List[Tuple[Any, Dict]]]:
+        """
+        Returns the top k edges per node based on the given attribute.
+
+        Parameters:
+        attribute (str): The attribute name to be used for sorting.
+        reverse (bool): Flag indicating whether to sort in reverse order (default: True).
+        k (int): Number of top edges to return per node.
+
+        Returns:
+        Dict[Any, List[Tuple[Any, Dict]]]: A dictionary where the key is a node
+        and the value is a list of top k edges for that node. Each edge is represented
+        as a tuple where the first element is the adjacent node and the second element
+        is a dictionary of edge attributes.
+        """
+        top_list = {}
+        for node in self.nodes:
+            edges = self.edges(node, data=True)
+            edges_sorted = sorted(edges, key=lambda x: x[2].get(
+                attribute, 0), reverse=reverse)
+            top_k_edges = edges_sorted[:k]
+            for u, v, data in top_k_edges:
+                edge_key = (u, v)
+                top_list[edge_key] = data[attribute]
+        return top_list
+
+    @staticmethod
+    def from_pandas_edgelist(df: pd.DataFrame,
+                             source: str = "source",
+                             target: str = "target",
+                             weight: str = "weight"):
+        """
+        Initialize netX instance with a simple dataframe
+
+        :param df_source: DataFrame containing network data.
+        :param source: Name of source nodes column in df_source.
+        :param target: Name of target nodes column in df_source.
+        :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()
+
+        edge_aggregates = G.top_k_edges(attribute=weight, k=10)
+        node_aggregates = {}
+        for (u, v), weight_value in edge_aggregates.items():
+            if u not in node_aggregates:
+                node_aggregates[u] = 0
+            if v not in node_aggregates:
+                node_aggregates[v] = 0
+            node_aggregates[u] += weight_value
+            node_aggregates[v] += weight_value
+
+        nx.set_node_attributes(G, node_aggregates, name=weight)
+
+        G = G.edge_subgraph(edges=G.top_k_edges(attribute=weight))
+        return G
+
+
+def plot_network(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,
+                 ascending: bool = False,
+                 ax: Optional[Axes] = None) -> Axes:
+
+    _validate_panda(pd_df, cols=[source, target, weight], sort_by=sort_by)
+    
+    graph = Graph.from_pandas_edgelist(pd_df,
+                                       source=source,
+                                       target=target,
+                                       weight=weight)
+    return graph.plotX(title=title,
+                       style=style,
+                       ax=ax)

MatplotLibAPI/Pivot.py

@@ -0,0 +1,214 @@
+# Hint for Visual Code Python Interactive window
+# %%
+from typing import List, Optional, Union
+
+import pandas as pd
+
+import matplotlib.dates as mdates
+import matplotlib.pyplot as plt
+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
+
+PIVOTBARS_STYLE_TEMPLATE = StyleTemplate(
+    background_color='black',
+    fig_border='darkgrey',
+    font_color='white',
+    palette='magma',
+    format_funcs={"y": percent_formatter, 
+                  "label": string_formatter}
+)
+PIVOTLINES_STYLE_TEMPLATE = StyleTemplate(
+    background_color='white',
+    fig_border='lightgrey',
+    palette='viridis',
+    format_funcs={"y": percent_formatter, "label": string_formatter}
+)
+
+def plot_pivotbar(pd_df: pd.DataFrame,
+                  label: str,
+                  x: str,
+                  y: str,
+                  agg: str = "sum",
+                  style: StyleTemplate = PIVOTBARS_STYLE_TEMPLATE,
+                  title: Optional[str] = None,
+                  sort_by: Optional[str] = None,
+                  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)
+    pivot_df = pd.pivot_table(pd_df, values=y, index=[
+                              x], columns=[label], aggfunc=agg)
+    # Reset index to make x a column again
+    pivot_df = pivot_df.reset_index()
+
+    if not ax:
+        ax = plt.gca()
+
+    # Plot each label's data
+    for column in pivot_df.columns[1:]:
+        _label = column
+        if style.format_funcs.get(column):
+            _label = style.format_funcs[column](column)
+        ax.bar(x=pivot_df[x],
+               height=pivot_df[column],
+               label=_label, alpha=0.7)
+
+    # Set labels and title
+    ax.set_ylabel(string_formatter(y))
+    ax.set_xlabel(string_formatter(x))
+    if title:
+        ax.set_title(f'{title}')
+    ax.legend(fontsize=style.font_size-2,
+              title_fontsize=style.font_size+2,
+              labelcolor='linecolor',
+              facecolor=style.background_color)
+
+    ax.tick_params(axis='x', rotation=90)
+    return ax
+
+
+def plot_lines(
+    data: pd.DataFrame,
+    label: str,
+    x: str,
+    y: Union[str, List[str]],
+    title: Optional[str] = None,
+    style: Optional[StyleTemplate] = PIVOTBARS_STYLE_TEMPLATE,
+    max_values: int = 4,
+    sort_by: Optional[str] = None,
+    ascending: bool = False,
+    ax: Optional[Axes] = None
+) -> Axes:
+
+    if title is not None:
+        ax.set_title(title)
+    ax.figure.set_facecolor(style.background_color)
+    ax.figure.set_edgecolor(style.fig_border)
+    # Get the top n elements in the specified z
+    top_elements = data.groupby(
+        label)[y].sum().nlargest(max_values).index.tolist()
+    top_elements_df = data[data[label].isin(top_elements)]
+    y_min = 0
+    # Plot the time series lines for each of the top elements
+    for element in top_elements:
+        subset = top_elements_df[top_elements_df[label] == element]
+        y_min = min(y_min, subset[y].min())
+        ax.plot(subset[x], subset[y], label=element)
+
+    # Set x-axis date format and locator
+        if style.x_formatter is not None:
+            x_min = data[x].min()
+            x_max = data[x].max()
+
+            if style.x_formatter == "year_month_formatter":
+                ax.xaxis.set_major_locator(plt.matplotlib.dates.MonthLocator())
+            else:
+                ax.xaxis.set_major_formatter(
+                    DynamicFuncFormatter(style.x_formatter))
+                ax.set_xticks(generate_ticks(
+                    x_min, x_max, num_ticks=style.x_ticks))
+
+    ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
+
+    # Set title and labels
+    ax.set_xlabel(x)
+    y_max = data[y].dropna().quantile(0.95)
+
+    ax.set_ylim(y_min, y_max)
+    ax.set_ylabel(y)
+    if style.y_formatter is not None:
+        ax.yaxis.set_major_formatter(
+            DynamicFuncFormatter(style.y_formatter))
+        ax.set_yticks(generate_ticks(
+            y_min, y_max, num_ticks=style.y_ticks))
+    else:
+        ylabels = ['{:,.0f}%'.format(y) for y in ax.get_yticks()*100]
+        ax.yaxis.set_yticklabels(ylabels)
+
+    # Add legend and grid
+    ax.legend()
+    ax.grid(True)
+
+    return ax
+
+
+def plot_bars(ax: Axes,
+              data: pd.DataFrame,
+              x_col: str,
+              y_col: Union[str, List[str]],
+              style: Optional[StyleTemplate] = None,
+              fig_title: Optional[str] = None,
+              z_col: str = "browser",
+              n=5,
+              agg_func: str = 'sum') -> Axes:
+
+    # Validate inputs
+
+    if not isinstance(y_col, list):
+        y_col = [y_col, y_col]  # Ensure y_col is a list
+
+    # Clear axis
+    ax.clear()
+    if style is None:
+        style = PIVOTBARS_STYLE_TEMPLATE
+
+    # Copying the da
+    df_plot = data.copy()
+
+    if df_plot.index.name != x_col:
+        df_plot.set_index(x_col, inplace=True)
+        print(df_plot.head())
+
+    # Set x-axis date format and locator
+    if style.x_formatter is not None:
+        if style.x_formatter == "year_month_formatter":
+            # Ensure the x_col is in datetime format
+            if not pd.api.types.is_datetime64_any_dtype(df_plot.index):
+                df_plot[x_col] = pd.to_datetime(df_plot[x_col])
+            df_plot.index = df_plot.index.to_pydatetime()
+            # Plot the data first
+            df_plot.plot(kind='bar', stacked=True, ax=ax)
+
+            ax.xaxis.set_major_locator(MonthLocator())
+            ax.xaxis.set_major_formatter(DateFormatter('%Y-%m'))
+
+            # Convert the Pandas datetime64 objects to strings in 'Year-Month' format
+            formatted_dates = df_plot.index.strftime('%Y-%m')
+            # Find the index positions where the day is the first of the month
+            first_of_month_positions = [
+                i for i, date in enumerate(df_plot.index) if date.day == 1]
+
+            # Set x-ticks at the first of the month positions
+            ax.set_xticks(first_of_month_positions)
+            ax.set_xticklabels([formatted_dates[i]
+                               for i in first_of_month_positions], rotation=45)
+
+            # Remove the blank space at the beginning
+            ax.set_xlim(left=0, right=len(df_plot.index) - 1)
+
+        else:
+            x_min = df_plot[x_col].min()
+            x_max = df_plot[x_col].max()
+            df_plot.plot(kind='bar', stacked=True, ax=ax)
+            ax.xaxis.set_major_formatter(
+                DynamicFuncFormatter(style.x_formatter))
+            ax.set_xticks(generate_ticks(
+                x_min, x_max, num_ticks=style.x_ticks))
+    else:
+        df_plot.plot(kind='bar', stacked=True, ax=ax)
+
+    # Apply custom y_formatter if provided
+    if style and style.y_formatter is not None:
+        ax.yaxis.set_major_formatter(DynamicFuncFormatter(style.y_formatter))
+
+    # Set title and labels
+    ax.set_title(fig_title if fig_title else "")
+    ax.set_xlabel(x_col)
+    ax.set_ylabel(y_col[0])
+
+    return ax

MatplotLibAPI/Style.py

@@ -0,0 +1,171 @@
+
+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/Table.py

@@ -0,0 +1,65 @@
+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
+
+TABLE_STYLE_TEMPLATE = StyleTemplate(
+    background_color='black',
+    fig_border='darkgrey',
+    font_color='white',
+    palette='magma'
+)
+
+
+def plot_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,
+               ax: Optional[Axes] = None
+               ) -> Axes:
+    _validate_panda(pd_df, cols=cols, sort_by=sort_by)
+    
+    if not sort_by:
+        sort_by = cols[0]
+
+    plot_df = pd_df[cols].sort_values(
+        by=sort_by, ascending=ascending).head(max_values)
+
+    col_labels = cols
+
+    if style.format_funcs:
+        for col, func in style.format_funcs.items():
+            if col in plot_df.columns:
+                plot_df[col] = plot_df[col].apply(func)
+
+    def format_table(table):
+        table.auto_set_font_size(False)
+        table.set_fontsize(style.font_size)
+        table.scale(1.2, 1.2)
+
+        for key, cell in table.get_celld().items():
+            cell.set_fontsize(style.font_size)
+            cell.set_facecolor(style.background_color)
+            cell.get_text().set_color(style.font_color)
+
+    if ax is None:
+        ax = plt.gca()
+
+    table_plot = ax.table(
+        cellText=plot_df.values,
+        colLabels=[string_formatter(colLabel) for colLabel in col_labels],
+        cellLoc='center',
+        colWidths=style.col_widths,
+        bbox=[0, -0.3, 1, 1.3])
+    format_table(table_plot)
+    ax.set_facecolor(style.background_color)
+    ax.set_axis_off()
+    ax.grid(False)
+    if title:
+        ax.set_title(title, color=style.font_color, fontsize=style.font_size*2)
+        ax.title.set_position([0.5, 1.05])
+    return ax

MatplotLibAPI/Timeserie.py

@@ -0,0 +1,97 @@
+# Hint for Visual Code Python Interactive window
+# %%
+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
+
+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,
+                   sort_by: Optional[str] = None,
+                   ascending: bool = False,
+                   ax: Optional[Axes] = None) -> Axes:
+
+    _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)
+
+
+    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/__init__.py

@@ -0,0 +1,13 @@
+
+
+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 .Composite import plot_composite_bubble
+from .pdAccessor import MatPlotLibAccessor
+from .Style import StyleTemplate
+
+__all__ = ["plot_bubble", "plot_timeserie", "plot_table", "plot_network",
+           "plot_pivotbar", "plot_composite_bubble", "StyleTemplate", "MatPlotLibAccessor"]

MatplotLibAPI/pdAccessor.py

@@ -0,0 +1,125 @@
+
+import logging
+import warnings
+from typing import Optional, List
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+import pandas as pd
+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)
+
+
+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: str = "Test",
+                    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_bubble_composite(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) -> 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 = 20,
+                  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)

{MatplotLibAPI-1.0.dist-info → MatplotLibAPI-3.0.0.dist-info}/METADATA

@@ -1,13 +1,11 @@
 Metadata-Version: 2.1
 Name: MatplotLibAPI
-Version: 1.0
+Version: 3.0.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pandas
 Requires-Dist: matplotlib
 Requires-Dist: seaborn
-Requires-Dist: json
-Requires-Dist: logging
 Requires-Dist: scikit-learn
 
 # MatplotLibAPI

MatplotLibAPI-3.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+MatplotLibAPI/Bubble.py,sha256=aYw8qcYF_cXJzAU7tIi5Cn7Y-sRfR8Cvm5RivMvVd5E,3860
+MatplotLibAPI/Composite.py,sha256=1qP_9TEz58EDA-oEev21WfJh2mxAEVVkRqYsysvMw7E,2478
+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=KOAK6cewddQWLFOFy98Db3BTNjWfv9TfJlPiJDybK84,3386
+MatplotLibAPI/__init__.py,sha256=-i49Ta56gER88f6R_BDOo-JiLc5UUGvxHg2aHdJv0PQ,457
+MatplotLibAPI/pdAccessor.py,sha256=OT03Z8V7ijWux0984IIuQegyobCSg_bhyGhtdejVs9I,4765
+MatplotLibAPI-3.0.0.dist-info/LICENSE,sha256=hMErKLb6YZR3lRR5zr-vxeFkvY69QAaafgSpZ5-P1dQ,1067
+MatplotLibAPI-3.0.0.dist-info/METADATA,sha256=TOXB7fkQGBvJKUd5q-T4k1Il0OUmwLW40Q5iQ2_RQxk,250
+MatplotLibAPI-3.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+MatplotLibAPI-3.0.0.dist-info/top_level.txt,sha256=MrzbBjDEW48Vb6YhQIqpFYGOhHzQnEIM5Qy2xy2iqew,14
+MatplotLibAPI-3.0.0.dist-info/RECORD,,

{MatplotLibAPI-1.0.dist-info → MatplotLibAPI-3.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

MatplotLibAPI-3.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+MatplotLibAPI

MatplotLibAPI-1.0.dist-info/RECORD

@@ -1,5 +0,0 @@
-MatplotLibAPI-1.0.dist-info/LICENSE,sha256=hMErKLb6YZR3lRR5zr-vxeFkvY69QAaafgSpZ5-P1dQ,1067
-MatplotLibAPI-1.0.dist-info/METADATA,sha256=sdyXoT7TW1GNPfgrKSHF-Wfk2vO1zW58AFkI0rEkk0g,291
-MatplotLibAPI-1.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-MatplotLibAPI-1.0.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-MatplotLibAPI-1.0.dist-info/RECORD,,

MatplotLibAPI-1.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-