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

MatplotLibAPI/Bubble.py

@@ -1,108 +1,127 @@
+# Hint for Visual Code Python Interactive window
+# %%
 
-
-from typing import List, Optional, Union
-
-import numpy as np
 import pandas as pd
-import seaborn as sns
-from sklearn.preprocessing import StandardScaler
-
+import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
-
-from .Utils import (BUBBLE_STYLE_TEMPLATE, DynamicFuncFormatter,
-                    StyleTemplate, generate_ticks)
-
-# region Bubble
-
-
-def plot_bubble(ax: Axes,
-                data: pd.DataFrame,
-                x_col: str,
-                y_col: Union[str, List[str]],
-                fig_title: Optional[str] = None,
-                style: Optional[StyleTemplate] = None,
-                legend: bool = False,
-                z_col: str = "uniques",
-                hue_col: str = "uniques_quintile",
-                l_col: str = "dimension",
-                normalize_x: bool = True,
-                sizes: tuple = (20, 2000), **kwargs) -> Axes:
-
-    # Clear the axis before plotting
-    ax.clear()
-
-    # Start formatting
-    if fig_title is not None:
-        ax.set_title(fig_title)
-    if style is None:
-        style = BUBBLE_STYLE_TEMPLATE
-    ax.figure.set_facecolor(style.fig_background_color)
-    ax.figure.set_edgecolor(style.fig_border)
-    if normalize_x:
-        # Step 1: Standardize the data to have mean=0 and variance=1
-        scaler = StandardScaler()
-        scaled_data = scaler.fit_transform(data[[x_col]])
-
-        # Step 2: Find a scaling factor to confine data within [-100, 100]
-        scale_factor = 100 / np.max(np.abs(scaled_data))
-
-        # Apply scaling factor
-        scaled_data *= scale_factor
-
-        # Round to the nearest integer
-        data[f"{x_col}"] = np.round(scaled_data).astype(int)
-
-    if type(y_col) == list:
-        y_col = y_col[0]
-
-    g = sns.scatterplot(data=data,
-                        x=x_col,
-                        y=y_col,
-                        size=z_col,
-                        hue=hue_col,
-                        palette=style.palette,
-                        legend=legend,
-                        sizes=sizes,
-                        ax=ax)
-
-    g.set(yscale="log")
-
-    g.axes.xaxis.grid(True, "minor", linewidth=.25)
-    g.axes.yaxis.grid(True, "minor", linewidth=.25)
-
-    g.axes.axvline(x=0, linestyle='--')
-
-    y_min = data[y_col].min()
-    y_max = data[y_col].max()
-    if style.y_formatter is not None:
-        g.axes.yaxis.set_major_formatter(
-            DynamicFuncFormatter(style.y_formatter))
-        g.set_yticks(generate_ticks(y_min, y_max, num_ticks=style.y_ticks))
-    else:
-        ylabels = ['{:,.0f}%'.format(y) for y in g.get_yticks()*100]
-        g.set_yticklabels(ylabels)
-
-    y_mean = data[y_col].mean()
-
-    if style.x_formatter is not None:
-        x_min = data[x_col].min()
-        x_max = data[x_col].max()
-        g.xaxis.set_major_formatter(
-            DynamicFuncFormatter(style.x_formatter))
-        g.set_xticks(generate_ticks(x_min, x_max, num_ticks=style.x_ticks))
-
-    g.axes.xaxis.grid(True, "minor", linewidth=.25)
-    g.axes.yaxis.grid(True, "minor", linewidth=.25)
-    g.hlines(y=y_mean, xmin=x_min, xmax=x_max,
-             linestyle='--', colors=style.font_color)
-
-    for index, row in data.iterrows():
-        x = row[x_col]
-        y = row[y_col[0] if type(y_col) == List else y_col]
-        s = row[l_col]
-        g.text(x, y, s, horizontalalignment='center',
-               fontsize=style.font_size*row[hue_col], color=style.font_color)
-
+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

@@ -1,109 +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
+from .Bubble import plot_bubble, BUBBLE_STYLE_TEMPLATE
 from .Table import plot_table
-from typing import Callable, Dict, Optional, List
-from matplotlib.axes import Axes
-
-
-def plot_composite(data: pd.DataFrame,
-                   sort_column: str,
-                   mappings: Dict[str, Callable],
-                   num_rows: int = 10,
-                   font_size: int = 12,
-                   fig_title: str = 'Bubble Plot',
-                   fig_background_color: str = 'skyblue',
-                   fig_border: str = 'steelblue',
-                   font_name: str = 'Arial',
-                   font_color: str = 'black') -> None:
-
-    data['uniques_quintile'] = pd.qcut(data['uniques'], 5, labels=False)
-    text_size_mapping = {0: 8, 1: 9, 2: 10, 3: 12, 4: 14}
-    data["font_size"] = data['uniques_quintile'].map(text_size_mapping)
-
-    data['audience_quintile'] = pd.qcut(data['audience'], 5, labels=False)
-    data['INDEX_quintile'] = pd.qcut(data['INDEX'], 5, labels=False)
-    # Adjust font size for better readability
-    plt.rc('font', size=font_size)
-
-    fig = plt.figure("Graph", figsize=(10, 10))
-
-    axgrid = fig.add_gridspec(5, 4)
-
-    ax0 = fig.add_subplot(axgrid[0:3, :])
-    plot_bubble(ax=ax0,
-                data=data,
-                font_size=font_size,
-                fig_background_color=fig_background_color,
-                fig_border=fig_border,
-                font_name=font_name)
-    ax0.set_title(fig_title)  # Add title
-    ax0.set_axis_off()
-
-    ax1 = fig.add_subplot(axgrid[3:, :2])
-    top_10 = data.sort_values(by="INDEX", ascending=False).head(10)
-
-    plot_table(ax=ax1,
-               data=top_10,
-               mappings=mappings,
-               sort_column=sort_column,
-               num_rows=num_rows,
-               fig_background_color=fig_background_color,
-               fig_border=fig_border,
-               font_name=font_name,
-               font_size=font_size,
-               font_color=font_color)
-    ax1.set_title('Top Items')  # Add title
-    ax1.set_axis_off()
-
-    ax2 = fig.add_subplot(axgrid[3:, 2:])
-    worst_10 = data.sort_values(by="INDEX").head(10)
-    plot_table(ax=ax2,
-               data=worst_10,
-               mappings=mappings,
-               sort_column=sort_column,
-               num_rows=num_rows,
-               fig_background_color=fig_background_color,
-               fig_border=fig_border,
-               font_name=font_name,
-               font_size=font_size,
-               sort_ascending=True)
-    ax2.set_title('Worst Items')  # Add title
-    ax2.set_axis_off()
-
-    fig.tight_layout()
-
-
-def plot_composite_12(plot_func1, plot_func2, plot_func3,
-                      data1, data2, data3,
-                      metrics1, metrics2, metrics3,
-                      highlights: Optional[List[str]] = None,
-                      font_size: int = 12,
-                      fig_title: str = 'Bubble Plot',
-                      fig_background_color: str = 'skyblue',
-                      fig_border: str = 'steelblue',
-                      font_name: str = 'Arial',
-                      font_color: str = 'black') -> None:
-
-    # Create a new figure and define the grid
-    fig = plt.figure(fig_title, figsize=(10, 10))
-    axgrid = fig.add_gridspec(5, 4)
-
-    # Create individual axes based on the grid
-    ax0 = fig.add_subplot(axgrid[0:3, :])
-    ax1 = fig.add_subplot(axgrid[3:, :2])
-    ax2 = fig.add_subplot(axgrid[3:, 2:])
-
-    # Call the individual plot functions with the respective axes and data
-    plot_func1(ax=ax0, data=data1, metrics=metrics1, highlights=highlights, font_size=font_size, fig_background_color=fig_background_color,
-               fig_border=fig_border, font_name=font_name, font_color=font_color)
-    plot_func2(ax=ax1, data=data2, metrics=metrics2, highlights=highlights, font_size=font_size, fig_background_color=fig_background_color,
-               fig_border=fig_border, font_name=font_name, font_color=font_color)
-    plot_func3(ax=ax2, data=data3, metrics=metrics3, highlights=highlights, font_size=font_size, fig_background_color=fig_background_color,
-               fig_border=fig_border, font_name=font_name, font_color=font_color)
-
-    fig.suptitle(fig_title, fontsize=16)
+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

@@ -4,19 +4,27 @@ 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": 12,
+           "MAX_FONT_SIZE": 20,
            "MIN_FONT_SIZE": 8
            }
 
@@ -25,7 +33,7 @@ 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):
+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]
@@ -160,8 +168,9 @@ class Graph(nx.Graph):
     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]
+        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)
@@ -169,30 +178,39 @@ class Graph(nx.Graph):
         subgraph = subgraph.edge_subgraph(list(edges)[:max_edges])
         return subgraph
 
-    def plotX(self):
+    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)
-
-        fig, ax = plt.subplots()
+        sns.set_palette(style.palette)
+        if ax is None:
+            ax = plt.gca()
 
         node_sizes, edge_widths, font_sizes = self.layout(
-            DEFAULT["MAX_NODE_SIZE"], DEFAULT["MAX_EDGE_WIDTH"], 14)
+            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=list(node_sizes.values()),
-                               cmap=plt.cm.Blues)
+                               node_color=node_sizes,
+                               cmap=plt.cm.get_cmap(style.palette))
         # edges
         nx.draw_networkx_edges(self,
                                pos,
                                ax=ax,
-                               alpha=0.4,
+                               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():
@@ -201,16 +219,13 @@ class Graph(nx.Graph):
                 pos,
                 ax=ax,
                 font_size=font_size,
-                labels={n: n for n in nodes},
-                alpha=0.4)
-
-        ax.set_title(self.name)
+                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()
 
-
-
-        fig.tight_layout()
-        return fig
+        return ax
 
     def analysis(self, node_list: Optional[List] = None,
                  scale: int = DEFAULT["GRAPH_SCALE"],
@@ -242,12 +257,14 @@ class Graph(nx.Graph):
             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')
+                    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.
@@ -275,10 +292,10 @@ class Graph(nx.Graph):
         return top_list
 
     @staticmethod
-    def from_pandas_edgelist(df,
-                             source: Optional[str] = "source",
-                             target: Optional[str] = "target",
-                             weight: Optional[str] = "weight"):
+    def from_pandas_edgelist(df: pd.DataFrame,
+                             source: str = "source",
+                             target: str = "target",
+                             weight: str = "weight"):
         """
         Initialize netX instance with a simple dataframe
 
@@ -291,7 +308,7 @@ class Graph(nx.Graph):
         G = Graph()
         G = nx.from_pandas_edgelist(
             df, source=source, target=target, edge_attr=weight, create_using=G)
-        G=G.find_connected_subgraph()
+        G = G.find_connected_subgraph()
 
         edge_aggregates = G.top_k_edges(attribute=weight, k=10)
         node_aggregates = {}
@@ -308,11 +325,23 @@ class Graph(nx.Graph):
         G = G.edge_subgraph(edges=G.top_k_edges(attribute=weight))
         return G
 
-def plot_network(data:pd.DataFrame):
-    graph = Graph.from_pandas_edgelist(data)
-    graph = graph.subgraphX()
-    return graph.analysis()
-
-
-
 
+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)