ruff

Author: bbcho

ggplotly/__init__.py

@@ -1,88 +1,97 @@
 # __init__.py
 
-from .ggplot import ggplot
-from .ggtitle import ggtitle
 from .aes import aes
-from .themes import (
-    theme_default,
-    theme,
-    theme_ggplot2,
-    theme_nytimes,
-    theme_minimal,
-    theme_bbc,
-    # theme_bw,
-    theme_dark,
-    theme_classic,
-    theme_custom,
-    element_text,
-    element_line,
-    element_rect,
-)
-from .facets import Facet, facet_wrap, facet_grid, label_value, label_both
-from .coords import Coord, coord_flip, coord_polar, coord_cartesian, coord_sf
-from .limits import xlim, ylim, lims
+from .coords import Coord, coord_cartesian, coord_flip, coord_polar, coord_sf
+from .datasets import data
+from .facets import Facet, facet_grid, facet_wrap, label_both, label_value
 from .geoms import (
-    geom_point,
-    geom_line,
-    geom_path,
+    geom_abline,
+    geom_area,
     geom_bar,
-    geom_col,
-    geom_histogram,
     geom_boxplot,
-    geom_smooth,
-    geom_area,
+    geom_candlestick,
+    geom_col,
+    geom_contour,
+    geom_contour_filled,
     geom_density,
-    geom_violin,
-    geom_ribbon,
-    geom_tile,
-    geom_text,
+    geom_edgebundle,
     geom_errorbar,
-    geom_segment,
-    geom_step,
-    geom_vline,
+    geom_histogram,
     geom_hline,
-    geom_edgebundle,
-    geom_searoute,
     geom_jitter,
-    geom_rug,
-    geom_abline,
-    geom_contour,
-    geom_contour_filled,
+    geom_line,
     geom_map,
-    geom_sf,
-    geom_range,
+    geom_ohlc,
+    geom_path,
+    geom_point,
     geom_point_3d,
+    geom_range,
+    geom_ribbon,
+    geom_rug,
+    geom_searoute,
+    geom_segment,
+    geom_sf,
+    geom_smooth,
+    geom_step,
     geom_surface,
+    geom_text,
+    geom_tile,
+    geom_violin,
+    geom_vline,
     geom_wireframe,
-    geom_candlestick,
-    geom_ohlc,
 )
+from .ggplot import ggplot
+from .ggtitle import ggtitle
+from .guides import annotate, guide_colorbar, guide_legend, guides, labs
+from .layer import Layer, layer
+from .limits import lims, xlim, ylim
+from .map_data import map_data
+from .positions import position_dodge, position_jitter, position_stack
 from .scales import (
-    scale_x_continuous,
-    scale_y_continuous,
-    scale_color_manual,
     scale_color_brewer,
+    scale_color_gradient,
+    scale_color_manual,
+    scale_fill_brewer,
     scale_fill_gradient,
     scale_fill_manual,
-    scale_fill_brewer,
     scale_fill_viridis_c,
     scale_shape_manual,
     scale_size,
-    scale_x_log10,
-    scale_y_log10,
+    scale_x_continuous,
     scale_x_date,
     scale_x_datetime,
-    scale_x_rangeslider,
+    scale_x_log10,
     scale_x_rangeselector,
-    scale_color_gradient,
+    scale_x_rangeslider,
+    scale_y_continuous,
+    scale_y_log10,
+)
+from .stats import (
+    stat_bin,
+    stat_contour,
+    stat_count,
+    stat_density,
+    stat_ecdf,
+    stat_identity,
+    stat_smooth,
+    stat_summary,
+)
+from .themes import (
+    element_line,
+    element_rect,
+    element_text,
+    theme,
+    theme_bbc,
+    theme_classic,
+    theme_custom,
+    # theme_bw,
+    theme_dark,
+    theme_default,
+    theme_ggplot2,
+    theme_minimal,
+    theme_nytimes,
 )
-from .guides import labs, annotate, guides, guide_legend, guide_colorbar
-from .positions import position_dodge, position_jitter, position_stack
 from .utils import ggsave, ggsize
-from .stats import *
-from .datasets import data
-from .map_data import map_data
-from .layer import Layer, layer
 
 __all__ = [
     "ggplot",
@@ -175,8 +184,14 @@
     "scale_x_rangeslider",
     "scale_x_rangeselector",
     "scale_color_gradient",
-    "stat_count",
+    "stat_identity",
+    "stat_smooth",
     "stat_bin",
+    "stat_density",
+    "stat_ecdf",
+    "stat_count",
+    "stat_summary",
+    "stat_contour",
     "data",
     "map_data",
     "Layer",

ggplotly/aesthetic_mapper.py

@@ -5,14 +5,16 @@
 This module provides a clean interface for resolving aesthetic mappings
 and determining whether aesthetic values are column references or literal values.
 """
+from __future__ import annotations
 
-import pandas as pd
-import plotly.express as px
 from functools import lru_cache
-from typing import Any, Dict, Optional, Union, Tuple
+from typing import Any
+
+import pandas as pd
 
-from .constants import SHAPE_PALETTE, get_color_palette as _get_color_palette
-from .exceptions import ColumnNotFoundError, InvalidColorError
+from .constants import SHAPE_PALETTE
+from .constants import get_color_palette as _get_color_palette
+from .exceptions import ColumnNotFoundError
 
 
 # Module-level cache for color conversions (expensive Plotly operations)
@@ -103,8 +105,8 @@ class AestheticMapper:
     - Literal values (colors, sizes, etc. to be used directly)
     """
 
-    def __init__(self, data: pd.DataFrame, mapping: Dict[str, Any], params: Dict[str, Any], theme=None,
-                 global_color_map: Dict[Any, str] = None, global_shape_map: Dict[Any, str] = None,
+    def __init__(self, data: pd.DataFrame, mapping: dict[str, Any], params: dict[str, Any], theme=None,
+                 global_color_map: dict[Any, str] = None, global_shape_map: dict[Any, str] = None,
                  validate: bool = True):
         """
         Initialize the aesthetic mapper.
@@ -171,8 +173,8 @@ def validate_column(self, column: str, aesthetic: str = None) -> None:
         """
         if column not in self._column_set:
             raise ColumnNotFoundError(column, list(self.data.columns), aesthetic)
-    
-    def resolve_aesthetic(self, aesthetic: str) -> Tuple[Any, Optional[pd.Series], Optional[Dict]]:
+
+    def resolve_aesthetic(self, aesthetic: str) -> tuple[Any, pd.Series | None, dict | None]:
         """
         Resolve an aesthetic from both mapping and params.
 
@@ -202,7 +204,7 @@ def resolve_aesthetic(self, aesthetic: str) -> Tuple[Any, Optional[pd.Series], O
         else:
             # It's a literal value
             return value, None, None
-    
+
     def _is_continuous(self, series: pd.Series) -> bool:
         """
         Determine if a series should be treated as continuous (numeric) or categorical.
@@ -237,7 +239,7 @@ def _is_continuous(self, series: pd.Series) -> bool:
 
         return False
 
-    def _create_color_map(self, series: pd.Series) -> Dict[Any, str]:
+    def _create_color_map(self, series: pd.Series) -> dict[Any, str]:
         """
         Create a mapping from unique values to colors.
 
@@ -261,7 +263,7 @@ def _create_color_map(self, series: pd.Series) -> Dict[Any, str]:
 
         return color_map
 
-    def _create_shape_map(self, series: pd.Series) -> Dict[Any, str]:
+    def _create_shape_map(self, series: pd.Series) -> dict[Any, str]:
         """
         Create a mapping from unique values to marker shapes.
 
@@ -278,8 +280,8 @@ def _create_shape_map(self, series: pd.Series) -> Dict[Any, str]:
             shape_map[val] = SHAPE_PALETTE[i % len(SHAPE_PALETTE)]
 
         return shape_map
-    
-    def get_style_properties(self) -> Dict[str, Any]:
+
+    def get_style_properties(self) -> dict[str, Any]:
         """
         Extract all relevant style properties for a geom.
 
@@ -368,8 +370,8 @@ def get_style_properties(self) -> Dict[str, Any]:
         # Cache the result for subsequent calls
         self._style_props_cache = result
         return result
-    
-    def get_color_for_value(self, value_key: Any, style_props: Dict[str, Any] = None,
+
+    def get_color_for_value(self, value_key: Any, style_props: dict[str, Any] = None,
                             prefer_fill: bool = False) -> str:
         """
         Get the resolved color for a specific value/group.
@@ -411,7 +413,7 @@ def get_color_for_value(self, value_key: Any, style_props: Dict[str, Any] = None
 
         return style_props['default_color']
 
-    def get_color_with_alpha(self, value_key: Any = None, style_props: Dict[str, Any] = None,
+    def get_color_with_alpha(self, value_key: Any = None, style_props: dict[str, Any] = None,
                             prefer_fill: bool = False, alpha_override: float = None) -> str:
         """
         Get color with alpha channel as RGBA string.
@@ -457,7 +459,7 @@ def _color_to_rgba(self, color: str, alpha: float) -> str:
         return _cached_color_to_rgba(color, alpha)
 
     def apply_style_to_trace(self, trace_kwargs: dict, style_props: dict,
-                            target_mapping: dict, value_key: Optional[Any] = None) -> dict:
+                            target_mapping: dict, value_key: Any | None = None) -> dict:
         """
         Apply style properties to a trace dictionary based on target mapping.
 
@@ -496,17 +498,17 @@ def apply_style_to_trace(self, trace_kwargs: dict, style_props: dict,
         return trace_kwargs
 
 
-def create_aesthetic_mapper(data: pd.DataFrame, mapping: Dict[str, Any], 
-                           params: Dict[str, Any], theme=None) -> AestheticMapper:
+def create_aesthetic_mapper(data: pd.DataFrame, mapping: dict[str, Any],
+                           params: dict[str, Any], theme=None) -> AestheticMapper:
     """
     Factory function to create an AestheticMapper instance.
-    
+
     Parameters:
         data: The DataFrame containing the plot data
         mapping: Dictionary of aesthetic mappings from aes()
         params: Dictionary of parameters passed to the geom
         theme: Optional theme object
-        
+
     Returns:
         AestheticMapper instance
     """

ggplotly/constants.py

@@ -7,7 +7,6 @@
 
 import plotly.express as px
 
-
 # Default shape palette matching ggplot2's defaults
 # Maps to Plotly marker symbols
 # See: https://plotly.com/python/marker-style/

ggplotly/coords/__init__.py

@@ -1,9 +1,9 @@
 # coords/__init__.py
 
 from .coord_base import Coord
+from .coord_cartesian import coord_cartesian
 from .coord_flip import coord_flip
 from .coord_polar import coord_polar
-from .coord_cartesian import coord_cartesian
 from .coord_sf import coord_sf
 
 __all__ = ["Coord", "coord_flip", "coord_polar", "coord_cartesian", "coord_sf"]

ggplotly/coords/coord_polar.py

@@ -2,6 +2,7 @@
 
 import numpy as np
 import plotly.graph_objects as go
+
 from .coord_base import Coord
 
 

ggplotly/data_utils.py

@@ -28,15 +28,17 @@
     >>> df.index.name = 'time'
     >>> ggplot(df, aes(y='y')) + geom_point()  # x-axis labeled 'time'
 """
+from __future__ import annotations
+
+from typing import Any
 
 import pandas as pd
-from typing import Tuple, Dict, Any, Optional
 
 # Reserved column name for index data
 INDEX_COLUMN = '_ggplotly_index'
 
 
-def normalize_data(data, mapping: Dict[str, Any]) -> Tuple[Optional[pd.DataFrame], Dict[str, Any], Optional[str]]:
+def normalize_data(data, mapping: dict[str, Any]) -> tuple[pd.DataFrame | None, dict[str, Any], str | None]:
     """
     Normalize input data and mapping for ggplotly consumption.
 
@@ -94,7 +96,7 @@ def normalize_data(data, mapping: Dict[str, Any]) -> Tuple[Optional[pd.DataFrame
     return data, mapping, index_name
 
 
-def _normalize_series(series: pd.Series, mapping: Dict[str, Any]) -> Tuple[pd.DataFrame, Dict[str, Any], str]:
+def _normalize_series(series: pd.Series, mapping: dict[str, Any]) -> tuple[pd.DataFrame, dict[str, Any], str]:
     """
     Convert a Series to a DataFrame for plotting.
 
@@ -131,7 +133,7 @@ def _normalize_series(series: pd.Series, mapping: Dict[str, Any]) -> Tuple[pd.Da
     return df, mapping, index_name
 
 
-def _handle_index_references(data: pd.DataFrame, mapping: Dict[str, Any]) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+def _handle_index_references(data: pd.DataFrame, mapping: dict[str, Any]) -> tuple[pd.DataFrame, dict[str, Any]]:
     """
     Handle 'index' keyword in aesthetic mappings.
 
@@ -170,7 +172,7 @@ def _handle_index_references(data: pd.DataFrame, mapping: Dict[str, Any]) -> Tup
     return data, mapping
 
 
-def _auto_populate_x(data: pd.DataFrame, mapping: Dict[str, Any]) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+def _auto_populate_x(data: pd.DataFrame, mapping: dict[str, Any]) -> tuple[pd.DataFrame, dict[str, Any]]:
     """
     Auto-populate x aesthetic from index when not specified.
 
@@ -203,7 +205,7 @@ def _auto_populate_x(data: pd.DataFrame, mapping: Dict[str, Any]) -> Tuple[pd.Da
     return data, mapping
 
 
-def get_index_label(index_name: Optional[str]) -> str:
+def get_index_label(index_name: str | None) -> str:
     """
     Get the appropriate label for the index axis.