MatplotLibAPI 2.0.2__tar.gz → 3.0.1__tar.gz

matplotlibapi-3.0.1/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-3.0.1/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-2.0.2 → matplotlibapi-3.0.1}/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)

{MatplotLibAPI-2.0.2 → matplotlibapi-3.0.1}/MatplotLibAPI/Pivot.py

@@ -1,3 +1,5 @@
+# Hint for Visual Code Python Interactive window
+# %%
 from typing import List, Optional, Union
 
 import pandas as pd
@@ -7,113 +9,101 @@ import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
 from matplotlib.dates import DateFormatter, MonthLocator
 
-from .Utils import (PIVOTBARS_STYLE_TEMPLATE, PIVOTLINES_STYLE_TEMPLATE,
-                    DynamicFuncFormatter, StyleTemplate, generate_ticks)
 
 
-def plot_pivotbar(data, metric, n_top, title):
-    # Sort the data by metric column in descending order
-    data_sorted = data.sort_values(by=metric, ascending=False)
-
-    # Select the top rows
-    top_rows = data_sorted.head(n_top)
-
-    # Plotting the top 50 data points with tag labels
-    fig, ax = plt.subplots(figsize=(12, 6))
-
-    # Plot the 'Used' data points (where Used == 1) in green
-    used_data = top_rows[top_rows['used'] == 1]
-    ax.bar(used_data.tag, used_data[metric],
-           color='green', label='Used', alpha=0.7)
-
-    # Plot the 'Not Used' data points (where Used == 0) in red
-    not_used_data = top_rows[top_rows['used'] == 0]
-    ax.bar(not_used_data.tag, not_used_data[metric],
-           color='red', label='Not Used', alpha=0.7)
+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('UVs')
-    ax.set_title(f'{title}\nTop {n_top} tags')
-    ax.legend()
+    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 fig
-
-
-def plot_lines(ax: Axes,
-               data: pd.DataFrame,
-               x_col: str,
-               y_col: Union[str, List[str]],
-               style: Optional[StyleTemplate] = None,
-               fig_title: Optional[str] = None,
-               n_top: int = 4,
-               z_col: str = "browser") -> Axes:
-    """
-    This function plots time series lines for the top n elements in the specified dimension.
-
-    Parameters:
-    ax (matplotlib.axes._axes.Axes): The ax to plot on.
-    data (pd.DataFrame): The data to plot.
-    metrics (Union[str, List[str]]): The column name(s) in data to plot.
-    date_col (str): The column name containing the date information.
-    ... (other parameters): Various parameters to customize the plot.
-    date_format (str): The format of the date to display on the x-axis.
-    date_locator (matplotlib.dates.Locator): Locator object to determine the date ticks on the x-axis.
-
-    Returns:
-    ax (matplotlib.axes._axes.Axes): The ax with the plot.
-    """
+    return ax
 
-    # Validate inputs
-    if x_col not in data.columns:
-        raise ValueError(f"'{x_col}' column not found in the data")
-    if not isinstance(y_col, list) and not isinstance(y_col, str):
-        raise TypeError("'metrics' should be a string or a list of strings")
-    if isinstance(y_col, list) and not len(y_col) >= 2:
-        raise ValueError(
-            f"metrics should be 2 of lengths column not found in the data")
-    ax.clear()
-    if fig_title is not None:
-        ax.set_title(fig_title)
-    if style is None:
-        style = PIVOTLINES_STYLE_TEMPLATE
-    ax.figure.set_facecolor(style.fig_background_color)
-    ax.figure.set_edgecolor(style.fig_border)
 
-    display_metric = y_col[0]
-    sort_metric = y_col[1]
+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(
-        z_col)[sort_metric].sum().nlargest(n_top).index.tolist()
-    top_elements_df = data[data[z_col].isin(top_elements)]
+        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[z_col] == element]
-        # Define the line style based on the element name
-        if element == "Chrome":
-            line_style = '-'
-            color = 'green'
-        elif element == "Android Webview":
-            line_style = '--'
-            color = 'green'
-        elif element == "Safari":
-            line_style = '-'
-            color = 'red'
-        elif element == "Safari (in-app)":
-            line_style = '--'
-            color = 'red'
-        else:
-            line_style = '-'
-            color = 'black'
-        y_min = min(y_min, subset[display_metric].min())
-
-        ax.plot(subset[x_col], subset[display_metric], label=element)
+        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_col].min()
-            x_max = data[x_col].max()
+            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())
@@ -126,11 +116,11 @@ def plot_lines(ax: Axes,
     ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
 
     # Set title and labels
-    ax.set_xlabel(x_col)
-    y_max = data[display_metric].dropna().quantile(0.95)
+    ax.set_xlabel(x)
+    y_max = data[y].dropna().quantile(0.95)
 
     ax.set_ylim(y_min, y_max)
-    ax.set_ylabel(display_metric)
+    ax.set_ylabel(y)
     if style.y_formatter is not None:
         ax.yaxis.set_major_formatter(
             DynamicFuncFormatter(style.y_formatter))