MatplotLibAPI 1.0__tar.gz → 2.0.2__tar.gz

MatplotLibAPI-2.0.2/MatplotLibAPI/Bubble.py

@@ -0,0 +1,108 @@
+
+
+from typing import List, Optional, Union
+
+import numpy as np
+import pandas as pd
+import seaborn as sns
+from sklearn.preprocessing import StandardScaler
+
+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)
+
+    return ax
+
+# endregion

MatplotLibAPI-2.0.2/MatplotLibAPI/Composite.py

@@ -0,0 +1,109 @@
+# Hint for Visual Code Python Interactive window
+# %%
+import matplotlib.pyplot as plt
+import pandas as pd
+from .Bubble import plot_bubble
+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)
+    fig.tight_layout()
+    return fig

MatplotLibAPI-2.0.2/MatplotLibAPI/Network.py

@@ -0,0 +1,318 @@
+import logging
+from collections import defaultdict
+from collections.abc import Iterable
+from typing import Any, Dict, List, Optional, Tuple
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+import pandas as pd
+from networkx import Graph
+from networkx.classes.graph import Graph
+
+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,
+           "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):
+        """
+        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()
+
+        node_sizes, edge_widths, font_sizes = self.layout(
+            DEFAULT["MAX_NODE_SIZE"], DEFAULT["MAX_EDGE_WIDTH"], 14)
+        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)
+        # edges
+        nx.draw_networkx_edges(self,
+                               pos,
+                               ax=ax,
+                               alpha=0.4,
+                               width=edge_widths)
+        # labels
+        for font_size, nodes in font_sizes.items():
+            nx.draw_networkx_labels(
+                self,
+                pos,
+                ax=ax,
+                font_size=font_size,
+                labels={n: n for n in nodes},
+                alpha=0.4)
+
+        ax.set_title(self.name)
+        ax.set_axis_off()
+
+
+
+        fig.tight_layout()
+        return fig
+
+    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,
+                             source: Optional[str] = "source",
+                             target: Optional[str] = "target",
+                             weight: Optional[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(data:pd.DataFrame):
+    graph = Graph.from_pandas_edgelist(data)
+    graph = graph.subgraphX()
+    return graph.analysis()
+
+
+
+

MatplotLibAPI-2.0.2/MatplotLibAPI/Pivot.py

@@ -0,0 +1,224 @@
+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 .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)
+
+    # Set labels and title
+    ax.set_ylabel('UVs')
+    ax.set_title(f'{title}\nTop {n_top} tags')
+    ax.legend()
+
+    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.
+    """
+
+    # 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]
+    # 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)]
+    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)
+
+    # 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()
+
+            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_col)
+    y_max = data[display_metric].dropna().quantile(0.95)
+
+    ax.set_ylim(y_min, y_max)
+    ax.set_ylabel(display_metric)
+    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-2.0.2/MatplotLibAPI/Table.py

@@ -0,0 +1,70 @@
+import logging
+from typing import List, Optional, Dict, Callable
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+
+
+def plot_table(ax: Axes,
+               data: pd.DataFrame,
+               mappings: Dict[str, Callable[[pd.Series], pd.Series]],
+               sort_column: str = "INDEX",
+               sort_ascending: bool = False,
+               num_rows: int = None,
+               fig_background_color: str = 'black',
+               fig_border: str = 'white',
+               font_name: str = 'Arial',
+               font_size: int = 10,
+               font_color="black",
+               fig_title: Optional[str] = None,
+               col_widths: Optional[List[float]] = None) -> Axes:
+    """
+    Plots a table using Matplotlib in the provided axis.
+
+    Parameters:
+        ax (Axes): The Matplotlib axis to plot the table in.
+        data (pd.DataFrame): The pandas DataFrame containing the table data.
+        mappings (dict): Dictionary mapping column names to functions that transform the column data.
+        sort_column (str, optional): Column to sort the data by. Default is "INDEX".
+        sort_ascending (bool, optional): Whether to sort in ascending order. Default is False.
+        num_rows (int, optional): Number of rows to display. Default is 10.
+        fig_background_color (str, optional): Background color of the figure. Default is 'skyblue'.
+        fig_border (str, optional): Border color of the figure. Default is 'steelblue'.
+        font_name (str, optional): Font name for the table cells. Default is 'Arial'.
+        font_size (int, optional): Font size for the table cells. Default is 10.
+        col_widths (list, optional): List of relative column widths. Default is None.
+
+    Returns:
+        Axes: The Matplotlib axis with the plotted table.
+    """
+
+    if num_rows is None:
+        num_rows = len(data.index)
+    cols = list(mappings.keys())
+    plot_data = data[cols].copy().sort_values(
+        by=sort_column, ascending=sort_ascending).head(num_rows).reset_index(drop=True)
+
+    for col, func in mappings.items():
+        plot_data[col] = plot_data[col].apply(func)
+    if fig_title is not None:
+        ax.text(0.5, 1.05,
+                fig_title,
+                va='top',
+                ha='center',
+                fontsize=font_size*1.5,
+                fontname=font_name,
+                color=font_color,
+                transform=ax.transAxes)
+    table = ax.table(cellText=plot_data.values, colLabels=plot_data.columns,
+                     cellLoc='center', colWidths=col_widths, loc="center")
+    table.auto_set_font_size(False)
+    table.set_fontsize(font_size)
+
+    for key, cell in table.get_celld().items():
+        cell.get_text().set_fontname(font_name)
+        cell.get_text().set_color(font_color)
+    table.scale(1, 4)
+    table.auto_set_column_width(col=list(range(len(plot_data.columns))))
+    ax.axis('off')
+
+    return ax

MatplotLibAPI-2.0.2/MatplotLibAPI/TimeSeries.py

@@ -0,0 +1,136 @@
+from datetime import datetime
+from typing import List, Optional, Union
+
+import numpy as np
+import pandas as pd
+
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
+
+from .Utils import (PIVOTLINES_STYLE_TEMPLATE, DynamicFuncFormatter,
+                    StyleTemplate, generate_ticks)
+
+# region TimeSeries
+
+
+def plot_timeseries(ax: Axes,
+                    data: pd.DataFrame,
+                    x_col: str,
+                    y_col: Union[str, List[str]],
+                    fig_title:  Optional[str] = None,
+                    style:  Optional[StyleTemplate] = None,
+
+                    rolling_days: int = 30,
+                    highlight: Optional[List[datetime]] = None,
+                    **kwargs) -> Axes:
+    """
+    Plots a time series with the actual data, rolling mean, and standard deviation of multiple metrics.
+    Highlights the specified dates and the dates with the 5 highest cumulative sum of residuals
+    for each metric, ensuring each date is at least 10% of the total timeframe apart from the others.
+
+    Parameters:
+        data (pd.DataFrame): Data to plot. Must have a datetime index.
+        metrics (List[str]): List of column names in 'data' to plot.
+        rolling_days (int, optional): Window size for the rolling mean and standard deviation. Default is 30.
+        title (str, optional): Title for the plot. If None, no title is set. Default is None.
+        highlight (List[datetime], optional): List of dates to highlight. If None, highlights the entire timeframe. 
+            Default is None.
+
+    Returns:
+        plt.Figure: The created matplotlib Figure object.
+    """
+    if type(y_col) == str:
+        y_col = [y_col]
+    # Clear the axis before plotting
+    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)
+    if x_col in data.columns:
+        data[x_col] = pd.to_datetime(data[x_col])
+        data.sort_values(by=x_col)
+        data.set_index(x_col, inplace=True)
+    total_days = (data.index.max() - data.index.min()).days
+    min_interval = total_days * 0.1
+
+    for metric in y_col:
+        # Compute rolling mean, standard deviation, residuals, and cusum for each metric
+        rolling_mean = data[metric].rolling(window=rolling_days).mean()
+        rolling_std = data[metric].rolling(window=rolling_days).std()
+        residuals = data[metric] - rolling_mean
+        residuals.dropna(inplace=True)
+        cusum = np.cumsum(residuals)
+        # Prepare dates to highlight
+        if highlight is None:
+            highlight = [data.index.min(), data.index.max()]
+            z_scores = (data[metric] - rolling_mean) / rolling_std
+            z_scores.dropna(inplace=True)
+            Q1 = z_scores.quantile(0.25)
+            Q3 = z_scores.quantile(0.75)
+            IQR = Q3 - Q1
+            z_threshold = Q3 + 1.5 * IQR
+            # Find dates with z-scores above the threshold
+            outlier_dates = z_scores[z_scores > z_threshold].index.tolist()
+
+            sorted_z_scores = z_scores.sort_values(ascending=False)
+            top_5_z_dates = []
+            for date, value in sorted_z_scores.items():
+                if value >= z_threshold:
+                    if all(abs((date - d).days) >= min_interval for d in top_5_z_dates):
+                        top_5_z_dates.append(date)
+                        if len(top_5_z_dates) >= 5:
+                            break
+            highlight += top_5_z_dates
+        else:
+            highlight.sort()
+
+            min_date = data.index.min()
+            if min_date < highlight[0]:
+                highlight.insert(0, min_date)
+
+            max_date = data.index.max()
+            if max_date < highlight[len(highlight)-1]:
+                highlight.append(max_date)
+
+        # Plot the metric, its rolling mean, and standard deviation
+        # Get the line object to extract the color
+        line, = ax.plot(data[metric], label=metric)
+        ax.plot(rolling_mean, color=line.get_color(), linewidth=line.get_linewidth()
+                * 3, label='_nolegend_')  # Use the same color for the rolling mean
+        ax.fill_between(rolling_std.index,
+                        rolling_mean - rolling_std,
+                        rolling_mean + rolling_std,
+                        alpha=0.2)
+
+    # Sort and deduplicate the highlight dates
+    highlight = sorted(set(highlight))
+
+    # Calculate mean of each metric between each pair of consecutive highlight dates
+    for i in range(len(highlight) - 1):
+        start_date = highlight[i]
+        end_date = highlight[i+1]
+        for metric in y_col:
+            metric_mean = data.loc[start_date:end_date, metric].mean()
+            ax.hlines(y=metric_mean, xmin=start_date, xmax=end_date,
+                      linestyle='--', color=style.font_color, alpha=0.5)
+            # ax.text(start_date, metric_mean, start_date.strftime('%Y-%m-%d'),
+            #        va='center', ha='right', backgroundcolor='w')
+
+        # Add vertical lines for highlight dates
+        ax.axvline(x=start_date, color=style.font_color, linestyle='--')
+
+    ax.xaxis.set_major_formatter(DynamicFuncFormatter(style.x_formatter))
+    ax.xaxis.set_major_locator(plt.matplotlib.dates.MonthLocator())
+    ax.set_xticklabels(ax.get_xticklabels(), rotation=45)
+    if style.y_formatter is None:
+        ylabels = ['{:,.0f}%'.format(y) for y in ax.get_yticks()*100]
+        ax.set_yticklabels(ylabels)
+    else:
+        ax.yaxis.set_major_formatter(DynamicFuncFormatter(style.y_formatter))
+    if style.legend:
+        ax.legend(loc='best')
+    return ax
+# endregion

MatplotLibAPI-2.0.2/MatplotLibAPI/Utils.py

@@ -0,0 +1,204 @@
+
+from dataclasses import dataclass
+
+from typing import List, Optional, Union
+
+import numpy as np
+import pandas as pd
+
+
+from matplotlib.axes import Axes
+from matplotlib.dates import num2date
+from matplotlib.ticker import FuncFormatter
+
+
+# region Style
+
+
+@dataclass
+class StyleTemplate:
+    fig_background_color: str = 'skyblue'
+    fig_border: str = 'steelblue'
+    font_name: str = 'Arial'
+    font_size: int = 10
+    font_color: str = 'black'
+    palette: str = 'rocket'
+    legend: bool = True
+    x_formatter: Optional[str] = None
+    x_ticks: int = 10
+    y_formatter: Optional[str] = None
+    y_ticks: int = 5
+
+
+KILO_STYLE_TEMPLATE = StyleTemplate(
+    fig_background_color='white',
+    fig_border='lightgrey',
+    palette='viridis',
+    y_formatter="kilo_formatter"
+)
+
+PERCENT_STYLE_TEMPLATE = StyleTemplate(
+    fig_background_color='white',
+    fig_border='lightgrey',
+    palette='viridis',
+    y_formatter="percent_formatter"
+)
+BUBBLE_STYLE_TEMPLATE = StyleTemplate(
+    fig_background_color='white',
+    fig_border='lightgrey',
+    palette='rocket',
+    x_formatter="integer_formatter",
+    y_formatter="percent_formatter",
+    y_ticks=5
+)
+TIMESERIES_STYLE_TEMPLATE = StyleTemplate(
+    fig_background_color='white',
+    fig_border='lightgrey',
+    palette='viridis',
+    x_formatter="year_month_formatter",
+    y_formatter="percent_formatter"
+)
+PIVOTLINES_STYLE_TEMPLATE = StyleTemplate(
+    fig_background_color='white',
+    fig_border='lightgrey',
+    palette='viridis',
+    x_formatter="year_month_formatter",
+    y_formatter="percent_formatter"
+)
+PIVOTBARS_STYLE_TEMPLATE = StyleTemplate(
+    fig_background_color='white',
+    fig_border='lightgrey',
+    palette='viridis',
+    x_formatter="year_month_formatter",
+    y_formatter="kilo_formatter"
+)
+
+
+DARK_STYLE_TEMPLATE = StyleTemplate(
+    fig_background_color='black',
+    fig_border='darkgrey',
+    font_color='white',
+    palette='magma'
+)
+
+
+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
+
+
+class DynamicFuncFormatter(FuncFormatter):
+    def __init__(self, func_name):
+        self.func = globals()[func_name]
+        super().__init__(self.func)
+
+
+def kilo_formatter(value, pos):
+    # Format values for better readability
+    if value >= 1000000:
+        return f"{value/1000000:.2f}M"
+    elif value >= 10000:
+        return f"{value/110000:.2f}K"
+    else:
+        return str(value)
+
+
+def percent_formatter(x, pos):
+    return f"{x * 100:.0f}%"
+
+
+def integer_formatter(x, pos):
+    return f"{x:.0f}"
+
+
+def year_month_formatter(x, pos):
+    return num2date(x).strftime('%Y-%m')
+# endregion
+
+# region Wrapper
+
+
+def plot_func(plot_type, 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,
+              **kwargs):
+    from .Bubble import plot_bubble
+    from .Pivot import plot_bars, plot_lines
+    from .TimeSeries import plot_timeseries
+    if plot_type == "bubble":
+        plot_bubble(ax=ax,
+                    data=data,
+                    x_col=x_col,
+                    y_col=y_col,
+                    fig_title=fig_title,
+                    style=style,
+                    legend=legend,
+                    **kwargs)
+    elif plot_type == "timeseries":
+        plot_timeseries(ax=ax,
+                        data=data,
+                        x_col=x_col,
+                        y_col=y_col,
+                        fig_title=fig_title,
+                        style=style,
+                        legend=legend,
+                        **kwargs)
+    elif plot_type == "lines":
+        plot_lines(ax=ax,
+                   data=data,
+                   x_col=x_col,
+                   y_col=y_col,
+                   fig_title=fig_title,
+                   style=style,
+                   **kwargs)
+    elif plot_type == "bars":
+        plot_bars(ax=ax,
+                  data=data,
+                  x_col=x_col,
+                  y_col=y_col,
+                  fig_title=fig_title,
+                  style=style,
+                  **kwargs)
+    else:
+        raise ValueError(f"Unknown plot type: {plot_type}")
+# endregion

{MatplotLibAPI-1.0 → MatplotLibAPI-2.0.2/MatplotLibAPI.egg-info}/PKG-INFO

@@ -1,13 +1,11 @@
 Metadata-Version: 2.1
 Name: MatplotLibAPI
-Version: 1.0
+Version: 2.0.2
 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-2.0.2/MatplotLibAPI.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+MatplotLibAPI/Bubble.py
+MatplotLibAPI/Composite.py
+MatplotLibAPI/Network.py
+MatplotLibAPI/Pivot.py
+MatplotLibAPI/Table.py
+MatplotLibAPI/TimeSeries.py
+MatplotLibAPI/Utils.py
+MatplotLibAPI/__init__.py
+MatplotLibAPI.egg-info/PKG-INFO
+MatplotLibAPI.egg-info/SOURCES.txt
+MatplotLibAPI.egg-info/dependency_links.txt
+MatplotLibAPI.egg-info/requires.txt
+MatplotLibAPI.egg-info/top_level.txt

{MatplotLibAPI-1.0 → MatplotLibAPI-2.0.2}/MatplotLibAPI.egg-info/requires.txt

@@ -1,6 +1,4 @@
 pandas
 matplotlib
 seaborn
-json
-logging
 scikit-learn

MatplotLibAPI-2.0.2/MatplotLibAPI.egg-info/top_level.txt

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

{MatplotLibAPI-1.0/MatplotLibAPI.egg-info → MatplotLibAPI-2.0.2}/PKG-INFO

@@ -1,13 +1,11 @@
 Metadata-Version: 2.1
 Name: MatplotLibAPI
-Version: 1.0
+Version: 2.0.2
 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-1.0 → MatplotLibAPI-2.0.2}/setup.py

@@ -2,14 +2,12 @@ from setuptools import setup, find_packages
 
 setup(
     name='MatplotLibAPI',
-    version='1.0',
+    version='v2.0.2',
     packages=find_packages(),
     install_requires=[
         "pandas",
         "matplotlib",
         "seaborn",
-        "json",
-        "logging",
         "scikit-learn"
     ],
     long_description=open('README.md').read(),

MatplotLibAPI-1.0/MatplotLibAPI.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-setup.py
-MatplotLibAPI.egg-info/PKG-INFO
-MatplotLibAPI.egg-info/SOURCES.txt
-MatplotLibAPI.egg-info/dependency_links.txt
-MatplotLibAPI.egg-info/requires.txt
-MatplotLibAPI.egg-info/top_level.txt

MatplotLibAPI-1.0/MatplotLibAPI.egg-info/top_level.txt

@@ -1 +0,0 @@
-