MatplotLibAPI 3.2.7__tar.gz → 3.2.9__tar.gz

matplotlibapi-3.2.9/MatplotLibAPI/Composite.py

@@ -0,0 +1,195 @@
+# Hint for Visual Code Python Interactive window
+# %%
+from typing import Optional, Tuple, List, Dict
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from .Bubble import aplot_bubble, BUBBLE_STYLE_TEMPLATE
+from .Table import aplot_table
+from .Treemap import aplot_treemap, TREEMAP_STYLE_TEMPLATE
+from .StyleTemplate import StyleTemplate, format_func, validate_dataframe
+
+
+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,
+        filter_by: Optional[str] = None,
+        sort_by: Optional[str] = None,
+        ascending: bool = False,
+        table_rows: int = 10,
+        figsize: Tuple[float, float] = (19.2, 10.8)) -> Figure:
+    """
+    Plot a composite bubble chart with additional tables for top and bottom values.
+
+    Parameters:
+    pd_df (pd.DataFrame): 
+        The pandas DataFrame containing the data to be plotted.
+    label (str): 
+        The column name for the bubble labels.
+    x (str): 
+        The column name for the x-axis values.
+    y (str): 
+        The column name for the y-axis values.
+    z (str): 
+        The column name for the bubble sizes.
+    title (Optional[str]): 
+        The title of the plot. Default is "Test".
+    style (StyleTemplate): 
+        A StyleTemplate object to define the visual style of the plot. Default is BUBBLE_STYLE_TEMPLATE.
+    max_values (int): 
+        The maximum number of values to display in the bubble chart. Default is 50.
+    center_to_mean (bool): 
+        A flag indicating whether to center the bubbles to the mean. Default is False.
+    filter_by (Optional[str]): 
+        The column name to filter the data by. Default is None.
+    sort_by (Optional[str]): 
+        The column name to sort the data by. Default is None.
+    ascending (bool): 
+        A flag indicating whether to sort in ascending order. Default is False.
+    table_rows (int): 
+        The number of rows to display in the tables. Default is 10.
+    figsize (Tuple[float, float]): 
+        The size of the figure. Default is (19.2, 10.8).
+
+    Returns:
+    Figure: 
+        The matplotlib figure object containing the composite bubble chart and tables.
+
+    Example:
+    >>> df = pd.DataFrame({
+    ...     "Label": ["A", "B", "C"],
+    ...     "X": [1, 2, 3],
+    ...     "Y": [4, 5, 6],
+    ...     "Z": [7, 8, 9]
+    ... })
+    >>> fig = plot_composite_bubble(df, label="Label", x="X", y="Y", z="Z")
+    >>> fig.show()
+    """
+    validate_dataframe(pd_df, cols=[label, x, y, z], sort_by=sort_by)
+
+    if not sort_by:
+        sort_by = z
+    if not filter_by:
+        filter_by = z
+    plot_df = pd_df.sort_values(by=filter_by,
+                                ascending=ascending)[[label, x, y, z]].head(max_values)
+    style.format_funcs = format_func(
+        style.format_funcs, label=label, x=x, y=y, z=z)
+    fig = plt.figure(figsize=figsize)
+    fig.patch.set_facecolor(style.background_color)
+    grid = plt.GridSpec(2, 2, height_ratios=[2, 1], width_ratios=[1, 1])
+    ax = fig.add_subplot(grid[0, 0:])
+    ax = aplot_bubble(pd_df=plot_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 = aplot_table(
+        pd_df=plot_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 = aplot_table(
+        pd_df=plot_df,
+        cols=[label, z, y, x],
+        title=f"Last {table_rows}",
+        ax=ax3,
+        sort_by=sort_by,
+        ascending=True,
+        max_values=table_rows,
+        style=style
+    )
+    fig.tight_layout()
+    return fig
+
+
+def plot_composite_treemap(pd_dfs: Dict[str, pd.DataFrame],
+                           values: str,
+                           style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
+                           title: Optional[str] = None,
+                           color: Optional[str] = None,
+                           sort_by: Optional[str] = None,
+                           ascending: bool = False,
+                           max_values: int = 100) -> Optional[go.Figure]:
+    """
+    Plot a composite treemap from multiple DataFrames.
+
+    Parameters:
+    pd_dfs (Dict[str, pd.DataFrame]): 
+        A dictionary where keys are dimension names and values are pandas DataFrames to be plotted.
+    values (str): 
+        The column name in each DataFrame that contains the values to be visualized in the treemap.
+    style (StyleTemplate): 
+        A StyleTemplate object to define the visual style of the treemap. Default is TREEMAP_STYLE_TEMPLATE.
+    title (Optional[str]): 
+        An optional title for the composite treemap plot. Default is None.
+    color (Optional[str]): 
+        An optional column name for coloring the treemap. Default is None.
+    sort_by (Optional[str]): 
+        An optional column name for sorting the treemap values. Default is None.
+    ascending (bool): 
+        A flag indicating whether to sort in ascending order. Default is False.
+    max_values (int): 
+        The maximum number of values to display in each treemap. Default is 100.
+
+    Returns:
+    Optional[go.Figure]: 
+        The composite treemap figure object or None if no DataFrames are provided.
+    """
+    num_dimensions = len(pd_dfs)
+    if num_dimensions > 0:
+        subplot_titles = [f"{title}::{dim.title()}" if title is not None else dim.title(
+        ) for dim in pd_dfs.keys()]
+        fig = make_subplots(
+            rows=num_dimensions,
+            cols=1,
+            subplot_titles=subplot_titles,
+            vertical_spacing=0.2
+        )
+
+    current_row = 1
+    for path, df in pd_dfs.items():
+        trm = aplot_treemap(pd_df=df,
+                            path=path,
+                            values=values,
+                            style=style,
+                            color=color,
+                            sort_by=sort_by,
+                            ascending=ascending,
+                            max_values=max_values)
+        fig.add_trace(trm, row=current_row, col=1)
+        current_row += 1
+    return fig

matplotlibapi-3.2.9/MatplotLibAPI/StyleTemplate.py

@@ -0,0 +1,371 @@
+
+
+from typing import List, Optional, Dict, Callable, Union
+from dataclasses import dataclass
+import pandas as pd
+import numpy as np
+
+from matplotlib.dates import num2date
+from matplotlib.ticker import FuncFormatter
+
+# region Utils
+
+
+def validate_dataframe(pd_df: pd.DataFrame,
+                       cols: List[str],
+                       sort_by: Optional[str] = None):
+    """
+    Validate that specified columns exist in a pandas DataFrame and optionally check for a sorting column.
+
+    Parameters:
+    pd_df (pd.DataFrame): The pandas DataFrame to validate.
+    cols (List[str]): A list of column names that must exist in the DataFrame.
+    sort_by (Optional[str]): An optional column name that, if provided, must also exist in the DataFrame.
+
+    Raises:
+    AttributeError: If any of the specified columns or the sorting column (if provided) do not exist in the DataFrame.
+
+    Example:
+    >>> import pandas as pd
+    >>> data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
+    >>> df = pd.DataFrame(data)
+    >>> validate_dataframe(df, ['A', 'B'])  # No error
+    >>> validate_dataframe(df, ['A', 'C'])  # Raises AttributeError
+    >>> validate_dataframe(df, ['A'], sort_by='B')  # No error
+    >>> validate_dataframe(df, ['A'], sort_by='C')  # Raises AttributeError
+    """
+    _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):
+    """
+    Update the formatting functions for specified keys if they exist in the provided format functions dictionary.
+
+    Parameters:
+    format_funcs (Optional[Dict[str, Optional[Callable[[Union[int, float, str]], str]]]]): 
+        A dictionary mapping keys to formatting functions. The keys can be 'label', 'x', 'y', and 'z'.
+    label (Optional[str]): 
+        The key to update with the 'label' formatting function from the dictionary.
+    x (Optional[str]): 
+        The key to update with the 'x' formatting function from the dictionary.
+    y (Optional[str]): 
+        The key to update with the 'y' formatting function from the dictionary.
+    z (Optional[str]): 
+        The key to update with the 'z' formatting function from the dictionary.
+
+    Returns:
+    Optional[Dict[str, Optional[Callable[[Union[int, float, str]], str]]]]:
+        The updated dictionary with the specified keys pointing to their corresponding formatting functions.
+
+    Example:
+    >>> format_funcs = {
+    ...     "label": lambda x: f"Label: {x}",
+    ...     "x": lambda x: f"X-axis: {x}",
+    ...     "y": lambda y: f"Y-axis: {y}",
+    ... }
+    >>> updated_funcs = format_func(format_funcs, label="new_label", x="new_x")
+    >>> print(updated_funcs)
+    {
+        "label": lambda x: f"Label: {x}",
+        "x": lambda x: f"X-axis: {x}",
+        "y": lambda y: f"Y-axis: {y}",
+        "new_label": lambda x: f"Label: {x}",
+        "new_x": lambda x: f"X-axis: {x}",
+    }
+    """
+
+    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 = 5
+    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
+    """
+    A class to define style templates for data visualization with customizable attributes.
+
+    Attributes:
+    background_color (str): 
+        The background color for the visualizations. Default is BACKGROUND_COLOR.
+    fig_border (str): 
+        The border color for the figures. Default is BACKGROUND_COLOR.
+    font_name (str): 
+        The name of the font to use. Default is 'Arial'.
+    font_size (int): 
+        The base size of the font. Default is FONT_SIZE.
+    font_color (str): 
+        The color of the font. Default is TEXT_COLOR.
+    palette (str): 
+        The color palette to use. Default is PALETTE.
+    legend (bool): 
+        A flag to determine if the legend should be displayed. Default is True.
+    xscale (Optional[str]): 
+        The scale type for the x-axis. Default is None.
+    x_ticks (int): 
+        The number of ticks on the x-axis. Default is 10.
+    yscale (Optional[str]): 
+        The scale type for the y-axis. Default is None.
+    y_ticks (int): 
+        The number of ticks on the y-axis. Default is 5.
+    format_funcs (Optional[Dict[str, Optional[Callable[[Union[int, float, str]], str]]]]): 
+        A dictionary mapping data keys to formatting functions. Default is None.
+    col_widths (Optional[List[float]]): 
+        A list of column widths. Default is None.
+
+    Properties:
+    font_mapping (dict): 
+        A dictionary mapping font size levels to specific font sizes.
+
+    Example:
+    >>> template = StyleTemplate()
+    >>> template.font_mapping
+    {0: FONT_SIZE-3, 1: FONT_SIZE-1, 2: FONT_SIZE, 3: FONT_SIZE+1, 4: FONT_SIZE+3}
+    """
+    @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):
+    """
+    A class to create a dynamic function formatter for matplotlib plots.
+
+    Inherits from:
+    FuncFormatter: A base class from matplotlib for formatting axis ticks.
+
+    Parameters:
+    func_name (Callable): The function to be used for formatting.
+
+    Example:
+    >>> formatter = DynamicFuncFormatter(percent_formatter)
+    """
+    def __init__(self, func_name):
+        super().__init__(func_name)
+
+
+def percent_formatter(val, pos: Optional[int] = None):
+    """
+    Format a value as a percentage.
+
+    Parameters:
+    val (float): The value to format.
+    pos (Optional[int]): The position (not used).
+
+    Returns:
+    str: The formatted percentage string.
+
+    Example:
+    >>> percent_formatter(0.005)
+    '1%'
+    """
+    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):
+    """
+    Format a value as billions, millions, or thousands.
+
+    Parameters:
+    val (float): The value to format.
+    pos (Optional[int]): The position (not used).
+
+    Returns:
+    str: The formatted string with B, M, or K suffix.
+
+    Example:
+    >>> bmk_formatter(1500000)
+    '1.5M'
+    """
+    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):
+    """
+    Format a value as an integer.
+
+    Parameters:
+    value (float): The value to format.
+    pos (Optional[int]): The position (not used).
+
+    Returns:
+    str: The formatted integer string.
+
+    Example:
+    >>> integer_formatter(42.9)
+    '42'
+    """
+    return f"{int(value)}"
+
+
+def string_formatter(value, pos: Optional[int] = None):
+    """
+    Format a string by replacing '-' and '_' with spaces and capitalizing words.
+
+    Parameters:
+    value (str): The string to format.
+    pos (Optional[int]): The position (not used).
+
+    Returns:
+    str: The formatted string.
+
+    Example:
+    >>> string_formatter("example-string_formatter")
+    'Example String Formatter'
+    """
+    return str(value).replace("-", " ").replace("_", " ").title()
+
+
+def yy_mm__formatter(x, pos: Optional[int] = None):
+    """
+    Format a date as 'YYYY-MM'.
+
+    Parameters:
+    x (float): The value to format.
+    pos (Optional[int]): The position (not used).
+
+    Returns:
+    str: The formatted date string.
+
+    Example:
+    >>> yy_mm__formatter(737060)
+    '2020-01'
+    """
+    return num2date(x).strftime('%Y-%m')
+
+
+def yy_mm_dd__formatter(x, pos: Optional[int] = None):
+    """
+    Format a date as 'YYYY-MM-DD'.
+
+    Parameters:
+    x (float): The value to format.
+    pos (Optional[int]): The position (not used).
+
+    Returns:
+    str: The formatted date string.
+
+    Example:
+    >>> yy_mm_dd__formatter(737060)
+    '2020-01-01'
+    """
+    return num2date(x).strftime('%Y-%m-%D')
+
+
+def generate_ticks(min_val, max_val, num_ticks:int=5):
+    """
+    Generate tick marks for a given range.
+
+    Parameters:
+    min_val (Union[float, str]): The minimum value of the range.
+    max_val (Union[float, str]): The maximum value of the range.
+    num_ticks (int): The number of ticks to generate. Default is 10.
+
+    Returns:
+    np.ndarray: An array of tick marks.
+
+    Example:
+    >>> generate_ticks(0, 100, 5)
+    array([  0.,  25.,  50.,  75., 100.])
+    """
+    # 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-3.2.7 → matplotlibapi-3.2.9}/MatplotLibAPI/Treemap.py

@@ -2,11 +2,10 @@
 # %%
 from typing import Optional
 import pandas as pd
-from pandas import CategoricalDtype,BooleanDtype
+from pandas import CategoricalDtype, BooleanDtype
 import plotly.graph_objects as go
 
-from .StyleTemplate import StyleTemplate, string_formatter, percent_formatter,validate_dataframe
-
+from .StyleTemplate import StyleTemplate, string_formatter, percent_formatter, validate_dataframe
 
 
 TREEMAP_STYLE_TEMPLATE = StyleTemplate(
@@ -19,16 +18,15 @@ TREEMAP_STYLE_TEMPLATE = StyleTemplate(
 )
 
 
-def fplot_treemap(pd_df: pd.DataFrame,
-                 path: str,
-                 values: str,
-                 style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
-                 title: Optional[str] = None,
-                 color: Optional[str] = None,
-                 sort_by: Optional[str] = None,
-                 ascending: bool = False,
-                 max_values: int = 100,
-                 fig: Optional[go.Figure] = None) -> go.Figure:
+def aplot_treemap(pd_df: pd.DataFrame,
+                  path: str,
+                  values: str,
+                  style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
+                  title: Optional[str] = None,
+                  color: Optional[str] = None,
+                  sort_by: Optional[str] = None,
+                  ascending: bool = False,
+                  max_values: int = 100) -> go.Trace:
     cols = [path, values]
     if color:
         cols.append(color)
@@ -57,7 +55,33 @@ def fplot_treemap(pd_df: pd.DataFrame,
         data['marker'] = dict(colorscale="Viridis",
                               colors=color_data.to_list())
 
-    g = go.Treemap(data)
+    g = go.Treemap(data,
+                   root_color=style.background_color
+                   )
+
+    return g
+
+
+def fplot_treemap(pd_df: pd.DataFrame,
+                  path: str,
+                  values: str,
+                  style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
+                  title: Optional[str] = None,
+                  color: Optional[str] = None,
+                  sort_by: Optional[str] = None,
+                  ascending: bool = False,
+                  max_values: int = 100,
+                  fig: Optional[go.Figure] = None) -> go.Figure:
+
+    g = aplot_treemap(pd_df=pd_df,
+                      path=path,
+                      values=values,
+                      title=title,
+                      style=style,
+                      color=color,
+                      sort_by=sort_by,
+                      ascending=ascending,
+                      max_values=max_values)
 
     if not fig:
         fig = go.Figure(g)

{matplotlibapi-3.2.7 → matplotlibapi-3.2.9}/MatplotLibAPI/__init__.py

@@ -1,12 +1,12 @@
 
 from .StyleTemplate import StyleTemplate
 from .Bubble import aplot_bubble, fplot_bubble, BUBBLE_STYLE_TEMPLATE
-from .Composite import plot_composite_bubble
+from .Composite import plot_composite_bubble,plot_composite_treemap
 from .Timeserie import aplot_timeserie, fplot_timeserie, TIMESERIE_STYLE_TEMPLATE
 from .Table import aplot_table, fplot_table, TABLE_STYLE_TEMPLATE
 from .Network import aplot_network, aplot_network_components, fplot_network, NETWORK_STYLE_TEMPLATE
-from .Treemap import fplot_treemap, TREEMAP_STYLE_TEMPLATE
-from typing import List, Optional, Tuple
+from .Treemap import fplot_treemap, aplot_treemap, TREEMAP_STYLE_TEMPLATE
+from typing import List, Optional, Tuple,Dict
 import pandas as pd
 from pandas.api.extensions import register_dataframe_accessor
 
@@ -274,6 +274,50 @@ class DataFrameAccessor:
                              max_values=max_values,
                              fig=fig)
 
+    def aplot_treemap(self,
+                      path: str,
+                      values: str,
+                      style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
+                      title: Optional[str] = None,
+                      color: Optional[str] = None,
+                      sort_by: Optional[str] = None,
+                      max_values: int = 100,
+                      ascending: bool = False,
+                      fig: Optional[go.Figure] = None) -> go.Figure:
+        return aplot_treemap(pd_df=self._obj,
+                             path=path,
+                             values=values,
+                             title=title,
+                             style=style,
+                             color=color,
+                             sort_by=sort_by,
+                             ascending=ascending,
+                             max_values=max_values)
+
+    def fplot_composite_treemap(self,
+                      pathes: List[str],
+                      values: str,
+                      style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
+                      title: Optional[str] = None,
+                      color: Optional[str] = None,
+                      sort_by: Optional[str] = None,
+                      max_values: int = 100,
+                      ascending: bool = False,
+                      fig: Optional[go.Figure] = None) -> go.Figure:
+        pd_dfs:Dict[str,pd.DataFrame]={}
+        for path in pathes:
+            pd_dfs[path]=self._obj
+
+
+        return plot_composite_treemap(pd_dfs=pd_dfs,
+                             values=values,
+                             title=title,
+                             style=style,
+                             color=color,
+                             sort_by=sort_by,
+                             ascending=ascending,
+                             max_values=max_values)
+
 
 __all__ = ["validate_dataframe", "aplot_bubble", "aplot_timeserie", "aplot_table", "aplot_network", "aplot_network_components", "fplot_network",
-           "plot_pivotbar", "fplot_treemap", "plot_composite_bubble", "StyleTemplate", "DataFrameAccessor"]
+           "plot_pivotbar", "fplot_treemap", "aplot_treemap", "plot_composite_bubble","plot_composite_treemap", "StyleTemplate", "DataFrameAccessor"]

{matplotlibapi-3.2.7 → matplotlibapi-3.2.9/MatplotLibAPI.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MatplotLibAPI
-Version: 3.2.7
+Version: 3.2.9
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE

{matplotlibapi-3.2.7/MatplotLibAPI.egg-info → matplotlibapi-3.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MatplotLibAPI
-Version: 3.2.7
+Version: 3.2.9
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE

{matplotlibapi-3.2.7 → matplotlibapi-3.2.9}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "MatplotLibAPI"
-version="v3.2.7"
+version="v3.2.9"
 readme = "README.md"
 requires-python=">=3.7"
 dependencies = ["pandas","matplotlib","networkx","plotly","seaborn","scikit-learn","kaleido","nbformat"]

matplotlibapi-3.2.7/MatplotLibAPI/Composite.py

@@ -1,126 +0,0 @@
-# Hint for Visual Code Python Interactive window
-# %%
-from typing import Optional, Tuple, List, Union, Dict
-import pandas as pd
-import matplotlib.pyplot as plt
-from matplotlib.pyplot import GridSpec
-from matplotlib.figure import Figure
-from matplotlib.axes import Axes
-import plotly.graph_objects as go
-from .Bubble import aplot_bubble, BUBBLE_STYLE_TEMPLATE
-from .Table import aplot_table
-from .Treemap import fplot_treemap, TREEMAP_STYLE_TEMPLATE
-from .StyleTemplate import StyleTemplate, format_func, validate_dataframe
-
-
-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,
-        filter_by: Optional[str] = None,
-        sort_by: Optional[str] = None,
-        ascending: bool = False,
-        table_rows: int = 10,
-        figsize: Tuple[float, float] = (19.2, 10.8)) -> Figure:
-
-    validate_dataframe(pd_df, cols=[label, x, y, z], sort_by=sort_by)
-
-    if not sort_by:
-        sort_by = z
-    if not filter_by:
-        filter_by = z
-    plot_df = pd_df.sort_values(by=filter_by,
-                                ascending=ascending)[[label, x, y, z]].head(max_values)
-    style.format_funcs = format_func(
-        style.format_funcs, label=label, x=x, y=y, z=z)
-    fig = plt.figure(figsize=figsize)
-    fig.patch.set_facecolor(style.background_color)
-    grid = plt.GridSpec(2, 2, height_ratios=[2, 1], width_ratios=[1, 1])
-    ax = fig.add_subplot(grid[0, 0:])
-    ax = aplot_bubble(pd_df=plot_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 = aplot_table(
-        pd_df=plot_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 = aplot_table(
-        pd_df=plot_df,
-        cols=[label, z, y, x],
-        title=f"Last {table_rows}",
-        ax=ax3,
-        sort_by=sort_by,
-        ascending=True,
-        max_values=table_rows,
-        style=style
-    )
-    fig.tight_layout()
-    return fig
-
-
-def fplot_treemaps(pd_dfs: List[pd.DataFrame],
-                   path: str,
-                   values: str,
-                   style: StyleTemplate = TREEMAP_STYLE_TEMPLATE,
-                   title: Optional[str] = None,
-                   color: Optional[str] = None,
-                   sort_by: Optional[str] = None,
-                   ascending: bool = False,
-                   max_values: int = 100) -> go.Figure:
-
-    trms = []
-    num_dimensions = len(pd_dfs)
-    if num_dimensions > 0:
-        fig = make_subplots(
-            rows=num_dimensions,
-            cols=1,
-            specs=[[{'type': 'domain'}] for _ in range(num_dimensions)],
-            vertical_spacing=0.02
-        )
-        current_row = 0
-        for pd_df in pd_dfs:
-            trm = fplot_treemap(pd_df=pd_df,
-                                path=path,
-                                values=values,
-                                title=title,
-                                style=style,
-                                color=color,
-                                sort_by=sort_by,
-                                ascending=ascending,
-                                max_values=max_values,
-                                fig=fig)
-            trms.append(trm)
-            current_row += 1

matplotlibapi-3.2.7/MatplotLibAPI/StyleTemplate.py

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