openretailscience 0.45.0__py3-none-any.whl

openretailscience/plots/price.py

@@ -0,0 +1,275 @@
+"""Bubble chart visualizations for price distribution analysis across categories.
+
+The bubble chart shows price distribution as vertical layers (price bands) with bubble sizes
+representing the percentage of products in each price range for different categories like
+retailers, countries, etc.
+
+### Core Features
+
+- **Price Band Analysis**: Automatically bins price data into ranges using pandas.cut()
+- **Categorical Grouping**: Groups data by categorical columns (retailers, countries, etc.)
+- **Bubble Sizing**: Bubble sizes represent percentage of products in each price band per group
+- **Flexible Binning**: Supports both integer (equal-width bins) and array (custom boundaries) inputs
+- **Grid Layout**: X-axis shows categories, Y-axis shows price bands
+
+### Use Cases
+
+- **Retailer Price Comparison**: Compare price distributions across different retailers
+- **Regional Price Analysis**: Analyze price positioning by country/region
+- **Competitive Pricing**: Identify pricing gaps and opportunities
+- **Price Architecture Visualization**: Visualize competitive pricing landscapes
+
+### Limitations
+
+- **Pandas DataFrame Only**: No Ibis table support
+- **Pre-aggregated Data**: Data should be at product level (one row per product)
+- **Numeric Price Column**: Requires numeric price/value column for binning
+"""
+
+import matplotlib.pyplot as plt
+import pandas as pd
+from matplotlib.axes import Axes, SubplotBase
+from matplotlib.lines import Line2D
+
+import openretailscience.plots.styles.graph_utils as gu
+from openretailscience.plots.styles.colors import get_plot_colors
+
+
+def _validate_inputs(
+    df: pd.DataFrame,
+    value_col: str,
+    group_col: str,
+    bins: int | list[float],
+) -> tuple[pd.DataFrame, int | list[float]]:
+    """Validates and processes inputs for price distribution plotting.
+
+    Args:
+        df: Input DataFrame containing product-level data.
+        value_col: Column containing the price/value data.
+        group_col: Column containing the categorical grouping.
+        bins: Either number of equal-width bins (int) or custom bin boundaries (list).
+
+    Returns:
+        Tuple of (cleaned_dataframe, validated_bins).
+
+    Raises:
+        ValueError: If DataFrame is empty, columns don't exist, value column is not numeric,
+            or bins parameter is invalid.
+        KeyError: If specified columns are not found in DataFrame.
+        TypeError: If bins parameter has invalid type.
+    """
+    # Validate DataFrame is not empty
+    if df.empty:
+        raise ValueError("Cannot plot with empty DataFrame")
+
+    # Validate columns exist
+    if value_col not in df.columns:
+        msg = f"value_col '{value_col}' not found in DataFrame"
+        raise KeyError(msg)
+
+    if group_col not in df.columns:
+        msg = f"group_col '{group_col}' not found in DataFrame"
+        raise KeyError(msg)
+
+    # Validate value column is numeric
+    if not pd.api.types.is_numeric_dtype(df[value_col]):
+        msg = f"value_col '{value_col}' must be numeric for binning"
+        raise ValueError(msg)
+
+    # Validate bins parameter
+    validated_bins = _validate_bins_parameter(bins)
+
+    # Remove rows with missing values in key columns
+    df_clean = df[[value_col, group_col]].dropna()
+
+    if df_clean.empty:
+        msg = f"No valid data after removing missing values from {value_col} and {group_col}"
+        raise ValueError(msg)
+
+    return df_clean, validated_bins
+
+
+def _validate_bins_parameter(bins: int | list[float]) -> int | list[float]:
+    """Validates and processes the bins parameter for price distribution plotting.
+
+    Args:
+        bins: Either number of equal-width bins (int) or custom bin boundaries (list).
+
+    Returns:
+        Validated and processed bins parameter.
+
+    Raises:
+        ValueError: If bins parameter is invalid.
+        TypeError: If bins parameter has invalid type.
+    """
+    if isinstance(bins, int):
+        if bins <= 0:
+            raise ValueError("bins must be a positive integer")
+        return bins
+    if isinstance(bins, list):
+        min_bins = 2
+        if len(bins) < min_bins:
+            raise ValueError("bins list must contain at least 2 values")
+        if not all(isinstance(x, int | float) for x in bins):
+            raise ValueError("All values in bins list must be numeric")
+        return sorted(bins)
+    msg = "bins must be either an integer or a list of numeric values"
+    raise TypeError(msg)
+
+
+def plot(
+    df: pd.DataFrame,
+    value_col: str,
+    group_col: str,
+    bins: int | list[float],
+    title: str | None = None,
+    x_label: str | None = None,
+    y_label: str | None = None,
+    legend_title: str | None = None,
+    ax: Axes | None = None,
+    source_text: str | None = None,
+    move_legend_outside: bool = False,
+    **kwargs: dict[str, any],
+) -> SubplotBase:
+    """Creates a bubble chart visualization showing price distribution analysis across categories.
+
+    The chart displays price bands as vertical layers with bubble sizes representing the percentage
+    of products in each price range for different groups (retailers, countries, etc.).
+
+    Args:
+        df (pd.DataFrame): Input DataFrame containing product-level data.
+        value_col (str): Column containing the price/value data (e.g., "unit_price").
+        group_col (str): Column containing the categorical grouping (e.g., "retailer").
+        bins (int | list[float]): Either number of equal-width bins (int) or custom bin boundaries (list).
+        title (str, optional): The title of the plot. Defaults to None.
+        x_label (str, optional): The label for the x-axis. Defaults to None.
+        y_label (str, optional): The label for the y-axis. Defaults to None.
+        legend_title (str, optional): The title for the legend. Defaults to None.
+        ax (Axes, optional): The Matplotlib Axes object to plot on. Defaults to None.
+        source_text (str, optional): Text to be displayed as a source at the bottom of the plot. Defaults to None.
+        move_legend_outside (bool, optional): Whether to move the legend outside the plot area. Defaults to False.
+        **kwargs (dict[str, Any]): Additional keyword arguments for the scatter plot function.
+
+    Returns:
+        SubplotBase: The Matplotlib Axes object with the generated bubble chart.
+
+    Raises:
+        ValueError: If DataFrame is empty, columns don't exist, or bins parameter is invalid.
+        KeyError: If specified columns are not found in DataFrame.
+        TypeError: If bins parameter has invalid type.
+    """
+    # Validate inputs and get clean data
+    df_clean, bins = _validate_inputs(df, value_col, group_col, bins)
+
+    # Create price bins
+    df_clean["price_bin"] = pd.cut(df_clean[value_col], bins=bins, include_lowest=True)
+
+    # Calculate percentage distribution for each group
+    group_totals = df_clean.groupby(group_col, observed=True).size()
+    bin_counts = df_clean.groupby([group_col, "price_bin"], observed=True).size().unstack(fill_value=0)
+
+    # Convert to proportions (0-1 range)
+    proportions = bin_counts.div(group_totals, axis=0)
+
+    ax = ax or plt.gca()
+
+    # Get unique groups and bins
+    groups = proportions.index.tolist()
+    price_bins = proportions.columns.tolist()
+
+    # Set up color mapping
+    colors = get_plot_colors(len(groups))
+
+    alpha = kwargs.pop("alpha", 0.7)
+    s_scale = kwargs.pop("s", 800)  # size for bubbles
+    edge_color = kwargs.pop("edgecolor", "black")  # black stroke around bubbles
+    line_width = kwargs.pop("linewidth", 1.5)  # Stroke width
+
+    # Validate that we have some data
+    if proportions.max().max() == 0 or pd.isna(proportions.max().max()):
+        raise ValueError("All proportions are zero - no data falls within the specified bins")
+
+    # Melt to get all (group, price_bin) combinations with their proportions
+    melted = proportions.reset_index().melt(id_vars=group_col, var_name="price_bin", value_name="proportion")
+    # Filter out zero proportions to avoid invisible bubbles
+    melted = melted[melted["proportion"] > 0]
+
+    if len(melted) > 0:  # Only plot if there are non-zero proportions
+        x_positions = [groups.index(group) for group in melted[group_col]]
+        y_positions = [price_bins.index(price_bin) for price_bin in melted["price_bin"]]
+        # Calculate bubble sizes using absolute proportion values for cross-group comparison
+        bubble_sizes = (melted["proportion"] * s_scale).to_numpy()
+        bubble_colors = [colors[groups.index(group)] for group in melted[group_col]]
+
+        ax.scatter(
+            x_positions,
+            y_positions,
+            s=bubble_sizes,
+            c=bubble_colors,
+            alpha=alpha,
+            edgecolor=edge_color,
+            linewidth=line_width,
+            **kwargs,
+        )
+
+    ax.set_xticks(range(len(groups)))
+    ax.set_xticklabels(groups)
+    ax.set_yticks(range(len(price_bins)))
+
+    # Format price bin labels to be more user-friendly
+    formatted_labels = []
+    for bin_ in price_bins:
+        # Extract left and right bounds from pandas Interval
+        left = bin_.left
+        right = bin_.right
+        # Format as price ranges
+        formatted_labels.append(f"{left:.1f} - {right:.1f}")
+
+    ax.set_yticklabels(formatted_labels)
+
+    # Apply standard styling but completely disable legend handling
+    ax = gu.standard_graph_styles(
+        ax=ax,
+        title=title,
+        x_label=x_label,
+        y_label=y_label,
+        legend_title=None,
+        move_legend_outside=False,
+        show_legend=False,
+    )
+
+    # Create custom legend with uniform circle sizes AFTER standard_graph_styles
+    if len(groups) > 1:  # Only create legend if there are multiple groups
+        legend_elements = []
+        for i, _group in enumerate(groups):
+            legend_elements.append(
+                Line2D(
+                    [0],
+                    [0],
+                    marker="o",
+                    color="w",
+                    markerfacecolor=colors[i],
+                    markersize=8,
+                    markeredgecolor="white",
+                    markeredgewidth=1,
+                    alpha=0.8,
+                    linestyle="None",
+                ),
+            )
+
+        if move_legend_outside:
+            ax.legend(
+                legend_elements,
+                groups,
+                title=legend_title,
+                bbox_to_anchor=(1.05, 1),
+                loc="upper left",
+                frameon=False,
+            )
+        else:
+            ax.legend(legend_elements, groups, title=legend_title, frameon=False)
+
+    if source_text:
+        gu.add_source_text(ax=ax, source_text=source_text)
+
+    return gu.standard_tick_styles(ax=ax)

openretailscience/plots/scatter.py

@@ -0,0 +1,382 @@
+"""This module provides functionality for creating scatter plots and bubble charts from pandas DataFrames.
+
+It is designed to visualize relationships between variables, highlight distributions,
+and compare different categories using scatter points with optional variable sizing
+for bubble chart functionality.
+
+### Core Features
+
+- **Flexible X-Axis Handling**: Uses an index or a specified x-axis column (**`x_col`**) for plotting.
+- **Multiple Scatter Groups**: Supports plotting multiple columns (**`value_col`**) or groups (**`group_col`**).
+- **Bubble Chart Support**: Variable point sizes via **`size_col`** and **`size_scale`** parameters.
+- **Point Labels**: Text labels with automatic positioning to avoid overlaps.
+- **Dynamic Color Mapping**: Automatically selects a colormap based on the number of groups.
+
+### Use Cases
+
+- **Category-Based Scatter Plots**: Compare different categories using scatter points.
+- **Bubble Charts**: Visualize three dimensions of data with x, y positions and point sizes.
+- **Labeled Scatter Plots**: Identify specific data points with text labels (e.g., product names, store IDs).
+
+### Limitations and Warnings
+
+- **Pre-Aggregated Data Required**: Data should be pre-aggregated before being passed to the function.
+- **Label Limitations**: Point labels are not supported when `value_col` is a list (raises ValueError).
+- **Size Column Requirements**: `size_col` must contain numeric, non-negative values.
+"""
+
+import warnings
+from typing import Any
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import textalloc as ta
+from matplotlib.axes import Axes, SubplotBase
+
+import openretailscience.plots.styles.graph_utils as gu
+from openretailscience.options import PlotStyleHelper
+from openretailscience.plots.styles.colors import get_plot_colors
+
+
+def _handle_size_params(
+    df: pd.DataFrame,
+    size_col: str | None,
+    size_scale: float,
+    kwargs: dict[str, Any],
+) -> dict[str, Any]:
+    """Validate size parameters and resolve conflicting kwargs.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing the data.
+        size_col (str | None): Column name containing values to determine point sizes.
+        size_scale (float): Scaling factor for point sizes.
+        kwargs (dict[str, Any]): Keyword arguments for matplotlib scatter function.
+
+    Returns:
+        dict[str, Any]: The original kwargs, or a copy with the 's' key removed if it was present.
+
+    Raises:
+        KeyError: If size_col doesn't exist in DataFrame.
+        ValueError: If size_col contains non-numeric values.
+        ValueError: If size_col contains negative values.
+        ValueError: If size_scale is not positive when size_col is specified.
+    """
+    if size_col is None:
+        return kwargs
+
+    if size_col not in df.columns:
+        msg = f"size_col '{size_col}' not found in DataFrame"
+        raise KeyError(msg)
+
+    if not pd.api.types.is_numeric_dtype(df[size_col]):
+        msg = f"size_col '{size_col}' must contain numeric values"
+        raise ValueError(msg)
+
+    if (df[size_col] < 0).any():
+        msg = f"size_col '{size_col}' contains negative values, which are not supported for bubble sizes"
+        raise ValueError(msg)
+
+    if size_scale <= 0:
+        msg = "size_scale must be a positive number"
+        raise ValueError(msg)
+
+    if "s" in kwargs:
+        warnings.warn(
+            "The 's' keyword argument is ignored when 'size_col' is specified. "
+            "Point sizes are controlled by 'size_col'.",
+            UserWarning,
+            stacklevel=3,
+        )
+        kwargs = {k: v for k, v in kwargs.items() if k != "s"}
+
+    return kwargs
+
+
+def _process_size_data(
+    df: pd.DataFrame,
+    size_col: str | None,
+    size_scale: float,
+    x_col: str | None,
+    group_col: str | None,
+) -> pd.DataFrame | pd.Series | None:
+    """Process size data for bubble charts.
+
+    Args:
+        df (pd.DataFrame): DataFrame containing the data.
+        size_col (str | None): Column name containing values to determine point sizes.
+        size_scale (float): Scaling factor for point sizes.
+        x_col (str | None): Column name for x-values. If None, uses index.
+        group_col (str | None): Column name for grouping. If None, treats as single series.
+
+    Returns:
+        pd.DataFrame | pd.Series | None: Processed size data aligned with plot structure, or None if no size_col.
+    """
+    if size_col is None:
+        return None
+
+    if group_col is None:
+        # Extract size values before set_index, which removes x_col from columns
+        size_values = df[size_col] * size_scale
+        index = df[x_col] if x_col is not None else df.index
+        return pd.Series(size_values.to_numpy(), index=index)
+
+    # For grouped data, create size array that aligns with pivot structure
+    size_pivot = (
+        df.pivot(columns=group_col, values=size_col)
+        if x_col is None
+        else df.pivot(index=x_col, columns=group_col, values=size_col)
+    )
+    return size_pivot * size_scale
+
+
+def _create_scatter_plot(
+    ax: Axes,
+    pivot_df: pd.DataFrame,
+    colors: list[str],
+    size_data: pd.DataFrame | pd.Series | None,
+    group_col: str | None,
+    is_multi_scatter: bool,
+    alpha: float,
+    **kwargs: Any,  # noqa: ANN401
+) -> None:
+    """Create scatter plots for each column in pivot_df.
+
+    Args:
+        ax (Axes): Matplotlib axes object to plot on.
+        pivot_df (pd.DataFrame): DataFrame with pivoted data for plotting.
+        colors (list[str]): List of colors for each column.
+        size_data (pd.DataFrame | pd.Series | None): Processed size data for bubble charts.
+        group_col (str | None): Column name for grouping.
+        is_multi_scatter (bool): Whether this is a multi-series scatter plot.
+        alpha (float): Alpha transparency value.
+        **kwargs: Additional keyword arguments for matplotlib scatter function.
+    """
+    for col, color_val in zip(pivot_df.columns, colors, strict=False):
+        # Get size values for this column if size_col is specified
+        sizes = None
+        if size_data is not None:
+            sizes = size_data if group_col is None else size_data[col]
+
+        # Filter out NaN values for grouped data
+        if group_col is not None:
+            # Get non-NaN mask for both y-values and sizes
+            y_values = pivot_df[col]
+            mask = y_values.notna()
+
+            x_values = pivot_df.index[mask]
+            y_values = y_values[mask]
+
+            if sizes is not None:
+                sizes = sizes[mask]
+        else:
+            x_values = pivot_df.index
+            y_values = pivot_df[col]
+
+        scatter_kwargs: dict[str, Any] = {
+            "color": color_val,
+            "label": col if is_multi_scatter else None,
+            "alpha": alpha,
+            **kwargs,
+        }
+        if sizes is not None:
+            scatter_kwargs["s"] = sizes
+
+        ax.scatter(x_values, y_values, **scatter_kwargs)
+
+
+def _add_point_labels(
+    ax: Axes,
+    df: pd.DataFrame,
+    value_col: str,
+    label_col: str,
+    x_col: str | None = None,
+    group_col: str | None = None,
+    label_kwargs: dict[str, Any] | None = None,
+) -> None:
+    """Add text labels to scatter plot points with automatic positioning.
+
+    Args:
+        ax (Axes): Matplotlib axes object to add labels to.
+        df (pd.DataFrame): DataFrame containing the data.
+        value_col (str): Column name for y-values.
+        label_col (str): Column name containing text labels.
+        x_col (str | None): Column name for x-values. If None, uses index.
+        group_col (str | None): Column name for grouping. If None, treats as single series.
+        label_kwargs (dict[str, Any] | None): Additional arguments passed to textalloc.allocate().
+    """
+    # Get style configuration for label styling
+    style = PlotStyleHelper()
+
+    # Prepare data for labeling - drop rows with NaN in value_col, label_col, or x_col
+    cols_to_check = [value_col, label_col]
+    if x_col is not None:
+        cols_to_check.append(x_col)
+    data_with_labels_df = df.dropna(subset=cols_to_check)
+
+    # Get x-values (either from x_col or use index)
+    x_values = data_with_labels_df[x_col] if x_col is not None else data_with_labels_df.index
+
+    if group_col is None:
+        # Single series - vectorized approach
+        all_x_coords = x_values.tolist()
+        all_y_coords = data_with_labels_df[value_col].tolist()
+        all_labels = data_with_labels_df[label_col].astype(str).tolist()
+    else:
+        # Multi-series with groups - vectorized approach
+        all_x_coords = data_with_labels_df.index.to_numpy() if x_col is None else data_with_labels_df[x_col].to_numpy()
+        all_y_coords = data_with_labels_df[value_col].to_numpy()
+        all_labels = data_with_labels_df[label_col].astype(str).to_numpy()
+
+    # Apply textalloc to avoid overlaps
+    if len(all_x_coords) > 0 and len(all_y_coords) > 0 and len(all_labels) > 0:
+        # Set default textalloc parameters
+        allocate_kwargs = {
+            "textsize": style.data_label_size,
+            "x_scatter": all_x_coords,
+            "y_scatter": all_y_coords,
+            "nbr_candidates": 50,  # More candidates for better positioning
+            "draw_lines": False,  # Remove lines to scatter points
+        }
+
+        # Override with user-provided kwargs
+        if label_kwargs:
+            allocate_kwargs.update(label_kwargs)
+
+        ta.allocate(
+            ax,
+            all_x_coords,
+            all_y_coords,
+            all_labels,
+            **allocate_kwargs,
+        )
+
+
+def plot(
+    df: pd.DataFrame | pd.Series,
+    value_col: str | list[str],
+    x_label: str | None = None,
+    y_label: str | None = None,
+    title: str | None = None,
+    x_col: str | None = None,
+    group_col: str | None = None,
+    size_col: str | None = None,
+    size_scale: float = 1.0,
+    ax: Axes | None = None,
+    source_text: str | None = None,
+    legend_title: str | None = None,
+    move_legend_outside: bool = False,
+    label_col: str | None = None,
+    label_kwargs: dict[str, Any] | None = None,
+    **kwargs: Any,  # noqa: ANN401
+) -> SubplotBase:
+    """Plots a scatter chart for the given `value_col` over `x_col` or index, with optional grouping by `group_col`.
+
+    Args:
+        df (pd.DataFrame or pd.Series): The dataframe or series to plot.
+        value_col (str or list of str): The column(s) to plot.
+        x_label (str, optional): The x-axis label.
+        y_label (str, optional): The y-axis label.
+        title (str, optional): The title of the plot.
+        x_col (str, optional): The column to be used as the x-axis. If None, the index is used.
+        group_col (str, optional): The column used to define different scatter groups.
+        size_col (str, optional): The column name containing values to determine point sizes.
+            If None, all points have uniform size. Creates bubble charts when specified.
+            When used with multiple value_col columns, the same size values apply to all series.
+        size_scale (float, optional): Scaling factor for point sizes. Default: 1.0.
+            Actual size = size_col_value * size_scale.
+        ax (Axes, optional): Matplotlib axes object to plot on.
+        source_text (str, optional): The source text to add to the plot.
+        legend_title (str, optional): The title of the legend.
+        move_legend_outside (bool, optional): Move the legend outside the plot.
+        label_col (str, optional): Column name containing text labels for each point.
+            Not supported when value_col is a list. Defaults to None.
+        label_kwargs (dict, optional): Keyword arguments passed to textalloc.allocate().
+            Common options: textsize, nbr_candidates, min_distance, max_distance, draw_lines.
+            By default, draw_lines=False to avoid lines connecting labels to points.
+            Defaults to None.
+        **kwargs: Additional keyword arguments for matplotlib scatter function.
+
+    Returns:
+        SubplotBase: The matplotlib axes object.
+
+    Raises:
+        ValueError: If `value_col` is a list and `group_col` is provided (which causes ambiguity in plotting).
+        ValueError: If `label_col` is provided when `value_col` is a list.
+        KeyError: If `label_col` doesn't exist in DataFrame.
+        KeyError: If `size_col` doesn't exist in DataFrame.
+        ValueError: If `size_col` contains non-numeric or negative values.
+        ValueError: If `size_scale` is not positive when `size_col` is specified.
+    """
+    if isinstance(df, pd.Series):
+        df = df.to_frame()
+
+    if isinstance(value_col, list) and group_col:
+        raise ValueError("Cannot use both a list for `value_col` and a `group_col`. Choose one.")
+
+    if label_col is not None:
+        if isinstance(value_col, list):
+            raise ValueError(
+                "label_col is not supported when value_col is a list. "
+                "Please use a single value_col or create separate plots.",
+            )
+
+        if label_col not in df.columns:
+            msg = f"label_col '{label_col}' not found in DataFrame"
+            raise KeyError(msg)
+
+    # Validate size parameters and resolve conflicting kwargs
+    kwargs = _handle_size_params(df, size_col, size_scale, kwargs)
+
+    if group_col is None:
+        pivot_df = df.set_index(x_col if x_col is not None else df.index)[
+            [value_col] if isinstance(value_col, str) else value_col
+        ]
+    else:
+        pivot_df = (
+            df.pivot(columns=group_col, values=value_col)
+            if x_col is None
+            else df.pivot(index=x_col, columns=group_col, values=value_col)
+        )
+
+    is_multi_scatter = (group_col is not None) or (isinstance(value_col, list) and len(value_col) > 1)
+
+    num_colors = len(pivot_df.columns) if is_multi_scatter else 1
+    default_colors = get_plot_colors(num_colors)
+
+    # Handle color parameter - can be single color or list of colors
+    color = kwargs.pop("color", default_colors)
+    colors = [color] * num_colors if not isinstance(color, list) else color
+
+    # Process size data if size_col is specified
+    size_data = _process_size_data(df, size_col, size_scale, x_col, group_col)
+
+    ax = ax or plt.gca()
+    alpha = kwargs.pop("alpha", 0.7)
+
+    _create_scatter_plot(ax, pivot_df, colors, size_data, group_col, is_multi_scatter, alpha, **kwargs)
+
+    # Add labels if requested
+    if label_col is not None:
+        _add_point_labels(
+            ax=ax,
+            df=df,
+            value_col=value_col,
+            label_col=label_col,
+            x_col=x_col,
+            group_col=group_col,
+            label_kwargs=label_kwargs,
+        )
+
+    ax = gu.standard_graph_styles(
+        ax=ax,
+        title=title,
+        x_label=x_label,
+        y_label=y_label,
+        legend_title=legend_title,
+        move_legend_outside=move_legend_outside,
+    )
+
+    if source_text is not None:
+        gu.add_source_text(ax=ax, source_text=source_text)
+
+    return gu.standard_tick_styles(ax)

openretailscience/plots/styles/__init__.py

@@ -0,0 +1 @@
+"""Graph and style helpers for OpenRetailScience."""