lets-plot 4.6.2__cp310-cp310-macosx_11_0_arm64.whl → 4.7.0__cp310-cp310-macosx_11_0_arm64.whl

lets_plot/plot/geom_function_.py

@@ -102,7 +102,7 @@ def geom_function(mapping=None, *, data=None, stat=None, geom=None, position=Non
         The geometry to display the function, as a string.
     position : str or `FeatureSpec`, default='identity'
         Position adjustment.
-        Either a position adjustment name: 'dodge', 'dodgev', 'jitter', 'nudge', 'jitterdodge', 'fill',
+        Either a position adjustment name: 'dodge', 'jitter', 'nudge', 'jitterdodge', 'fill',
         'stack' or 'identity', or the result of calling a position adjustment function (e.g., `position_dodge()` etc.).
     show_legend : bool, default=True
         False - do not show legend for this layer.

lets_plot/plot/geom_imshow_.py

@@ -234,29 +234,44 @@ def geom_imshow(image_data, cmap=None, *,
 
         (image_data, greyscale_data_min, greyscale_data_max) = _normalize_2D(image_data, norm, vmin, vmax, min_lum)
         height, width = image_data.shape
-        nchannels = 1
-
         has_nan = numpy.isnan(image_data.max())
-        if has_nan and not cmap:
-            # add alpha-channel (LA)
+
+        if cmap:
+            # colormap via palettable
+            if not palettable:
+                raise ValueError(
+                    "Can't process `cmap`: please install 'Palettable' (https://pypi.org/project/palettable/) to your "
+                    "Python environment. "
+                )
+
+            # prepare palette
+            palette = None
+            if not has_nan:
+                alpha_ch_val = 255 if alpha is None else 255 * alpha
+                cmap_256 = palettable.get_map(cmap + "_256")
+                palette = [_hex2rgb_arr_uint8(c, alpha_ch_val) for c in cmap_256.hex_colors]
+            else:
+                alpha_ch_val = 255 if alpha is None else 255 * alpha
+                cmap_255 = palettable.get_map(cmap + "_255")
+                # transparent color at index 0
+                palette = [numpy.array([0, 0, 0, 0], dtype=numpy.uint8)] \
+                          + [_hex2rgb_arr_uint8(c, alpha_ch_val) for c in cmap_255.hex_colors]
+
+            # replace indexes with palette colors
+            if has_nan:
+                # replace all NaN-s with 0 (index 0 for transparent color)
+                numpy.nan_to_num(image_data, copy=False, nan=0)
+            image_data = numpy.take(palette, numpy.round(image_data).astype(numpy.int32), axis=0)
+        else:
+            # Greyscale
             alpha_ch_scaler = 1 if alpha is None else alpha
             is_nan = numpy.isnan(image_data)
             im_shape = numpy.shape(image_data)
             alpha_ch = numpy.zeros(im_shape, dtype=image_data.dtype)
             alpha_ch[is_nan == False] = 255 * alpha_ch_scaler
             image_data[is_nan] = 0
-            image_data = numpy.dstack((image_data, alpha_ch))
-            nchannels = 2
-        elif has_nan and cmap:
-            # replace all NaN-s with 0 (index 0 for transparent color)
-            numpy.nan_to_num(image_data, copy=False, nan=0)
-        elif not cmap and alpha is not None:
-            # add alpha-channel (LA)
-            im_shape = numpy.shape(image_data)
-            alpha_ch = numpy.full(im_shape, 255 * alpha, dtype=image_data.dtype)
-            image_data = numpy.dstack((image_data, alpha_ch))
-            nchannels = 2
-
+            image_data = numpy.repeat(image_data[:, :, numpy.newaxis], 3, axis=2)  # convert to RGB
+            image_data = numpy.dstack((image_data, alpha_ch)) # convert to RGBA
     else:
         # Color RGB/RGBA image
         # Make a copy:
@@ -268,15 +283,14 @@ def geom_imshow(image_data, cmap=None, *,
 
         height, width, nchannels = image_data.shape
 
-        if alpha is not None:
-            if nchannels == 3:
-                # RGB image: add alpha channel (RGBA)
-                alpha_ch = numpy.full((height, width, 1), 255 * alpha, dtype=image_data.dtype)
-                image_data = numpy.dstack((image_data, alpha_ch))
-                nchannels = 4
-            elif nchannels == 4:
-                # RGBA image: apply alpha scaling
-                image_data[:, :, 3] *= alpha
+        if nchannels == 3:
+            alpha_ch_scaler = 1 if alpha is None else alpha
+            # RGB image: add alpha channel (RGBA)
+            alpha_ch = numpy.full((height, width, 1), 255 * alpha_ch_scaler, dtype=image_data.dtype)
+            image_data = numpy.dstack((image_data, alpha_ch))
+        elif nchannels == 4 and alpha is not None:
+            # RGBA image: apply alpha scaling
+            image_data[:, :, 3] *= alpha
 
     # Make sure all values are ints in range 0-255.
     image_data.clip(0, 255, out=image_data)
@@ -312,39 +326,16 @@ def geom_imshow(image_data, cmap=None, *,
         image_data = image_data.astype(numpy.int8)
 
     # Reshape to 2d-array:
-    # from [[[R, G, B], [R, G, B]], ...] to [[R, G, B, R, G, B],..] for RGB(A)
-    # or from [[[L, A], [L, A]], ...] to [[L, A, L, A],..] for greyscale–alpha (LA)
-    # or pypng will fail
-    image_2d = image_data.reshape(-1, width * nchannels)
+    image_2d = image_data.reshape(-1, width * 4)  # always 4 channels (RGBA)
 
     # PNG writer
-    palette = None
-    if cmap and greyscale:
-        # colormap via palettable
-        if not palettable:
-            raise ValueError(
-                "Can't process `cmap`: please install 'Palettable' (https://pypi.org/project/palettable/) to your "
-                "Python environment. "
-            )
-        if not has_nan:
-            alpha_ch_val = None if alpha is None else 255 * alpha
-            cmap_256 = palettable.get_map(cmap + "_256")
-            palette = [_hex2rgb_arr_uint8(c, alpha_ch_val) for c in cmap_256.hex_colors]
-        else:
-            alpha_ch_val = 255 if alpha is None else 255 * alpha
-            cmap_255 = palettable.get_map(cmap + "_255")
-            # transparent color at index 0
-            palette = [numpy.array([0, 0, 0, 0], dtype=numpy.uint8)] + [_hex2rgb_arr_uint8(c, alpha_ch_val) for c in
-                                                                        cmap_255.hex_colors]
-
     png_bytes = io.BytesIO()
     png.Writer(
         width=width,
         height=height,
-        greyscale=greyscale and not cmap,
-        alpha=(nchannels == 4 or nchannels == 2),  # RGBA or LA
+        greyscale=False,
+        alpha=True,
         bitdepth=8,
-        palette=palette,
         compression=compression
     ).write(png_bytes, image_2d)
 

lets_plot/plot/pos.py

@@ -22,6 +22,7 @@ def position_dodge(width=None):
         This is useful when you want to align narrow geoms with wider geoms.
         The value of width is relative and typically ranges between 0 and 1.
         Values that are greater than 1 lead to overlapping of the objects.
+        The default value is taken from the width aesthetics of the data point.
 
     Returns
     -------
@@ -55,44 +56,11 @@ def position_dodge(width=None):
 
 def position_dodgev(height=None):
     """
-    Adjust position by dodging overlaps to the side.
-
-    Parameters
-    ----------
-    height : float
-        Dodging height, when different to the height of the individual elements.
-        This is useful when you want to align narrow geoms with taller geoms.
-        The value of height is relative and typically ranges between 0 and 1.
-        Values that are greater than 1 lead to overlapping of the objects.
-
-    Returns
-    -------
-    `FeatureSpec`
-        Geom object position specification.
-
-    Notes
-    -----
-    Adjust position by dodging overlaps to the side.
-
-    Examples
-    --------
-    .. jupyter-execute::
-        :linenos:
-        :emphasize-lines: 11
-
-        from lets_plot import *
-        LetsPlot.setup_html()
-        data = {
-            'xmin': [0.2, 4.6, 1.6, 3.5],
-            'xmax': [1.5, 5.3, 3.0, 4.4],
-            'y': ['a', 'a', 'b', 'b'],
-            'c': ['gr1', 'gr2', 'gr1', 'gr2']
-        }
-        ggplot(data, aes(y='y', color='c')) + \\
-            geom_errorbar(aes(xmin='xmin', xmax='xmax'), height=0.1, size=2, \\
-                          position=position_dodgev(height=0.2))
+    Function `position_dodgev()` is deprecated and will be removed in future releases.
 
     """
+    print("WARN: The function position_dodgev() is deprecated and will be removed in future releases.")
+
     return _pos('dodgev', height=height)
 
 
@@ -102,11 +70,11 @@ def position_jitter(width=None, height=None, seed=None):
 
     Parameters
     ----------
-    width : float
+    width : float, default=.4
         Jittering width.
         The value of width is relative and typically ranges between 0 and 0.5.
         Values that are greater than 0.5 lead to overlapping of the points.
-    height : float
+    height : float, default=.4
         Jittering height.
         The value of height is relative and typically ranges between 0 and 0.5.
         Values that are greater than 0.5 lead to overlapping of the points.
@@ -152,9 +120,9 @@ def position_nudge(x=None, y=None, unit=None):
 
     Parameters
     ----------
-    x : float
+    x : float, default=0.0
         Nudging width.
-    y : float
+    y : float, default=0.0
         Nudging height.
     unit : {'identity', 'size', 'px'}, default='identity'
         Units for x and y nudging.
@@ -206,11 +174,12 @@ def position_jitterdodge(dodge_width=None, jitter_width=None, jitter_height=None
         Bin width.
         The value of `dodge_width` is relative and typically ranges between 0 and 1.
         Values that are greater than 1 lead to overlapping of the boxes.
-    jitter_width : float
+        The default value is taken from the width aesthetics of the data point.
+    jitter_width : float, default=.4
         Jittering width.
         The value of `jitter_width` is relative and typically ranges between 0 and 0.5.
         Values that are greater than 0.5 lead to overlapping of the points.
-    jitter_height : float
+    jitter_height : float, default=.4
         Jittering height.
         The value of `jitter_height` is relative and typically ranges between 0 and 0.5.
         Values that are greater than 0.5 lead to overlapping of the points.
@@ -259,7 +228,7 @@ def position_stack(vjust=None, mode=None):
 
     Parameters
     ----------
-    vjust : float
+    vjust : float, default=1.0
         Vertical adjustment for geoms that have a position (like points or lines),
         not a dimension (like bars or areas).
         Set to 0 to align with the bottom, 0.5 for the middle, and 1 for the top.
@@ -305,7 +274,7 @@ def position_fill(vjust=None, mode=None):
 
     Parameters
     ----------
-    vjust : float
+    vjust : float, default=1.0
         Vertical adjustment for geoms that have a position (like points or lines),
         not a dimension (like bars or areas).
         Set to 0 to align with the bottom, 0.5 for the middle, and 1 for the top.

lets_plot/plot/scale_position.py

@@ -722,7 +722,7 @@ def scale_x_discrete(name=None, *,
         LetsPlot.setup_html()
         np.random.seed(43)
         scores = {'rating': np.random.randint(3, 6, size=10)}
-        ggplot(scores, aes(x='rating')) + geom_bar() + \\
+        ggplot(scores, aes(x=as_discrete('rating'))) + geom_bar() + \\
             scale_x_discrete(name='rating', format='.1f')
 
     """
@@ -1012,7 +1012,10 @@ def scale_x_datetime(name=None, *,
                      position=None
                      ):
     """
-    Position scale x for date/time data.
+    Position scale for the x-axis with date/time data.
+    The input is expected to be either a series of integers representing milliseconds since the Unix epoch, or Python datetime objects.
+    Assumes UTC timezone if no timezone information is present in the data (naive datetime).
+    For timezone-aware datetime objects, the timezone information from the data is preserved.
 
     Parameters
     ----------
@@ -1099,7 +1102,10 @@ def scale_y_datetime(name=None, *,
                      position=None
                      ):
     """
-    Position scale y for date/time data.
+    Position scale for the y-axis with date/time data.
+    The input is expected to be either a series of integers representing milliseconds since the Unix epoch, or Python datetime objects.
+    Assumes UTC timezone if no timezone information is present in the data (naive datetime).
+    For timezone-aware datetime objects, the timezone information from the data is preserved.
 
     Parameters
     ----------

lets_plot/plot/series_meta.py

@@ -1,129 +1,203 @@
 #  Copyright (c) 2024. JetBrains s.r.o.
 #  Use of this source code is governed by the MIT license that can be found in the LICENSE file.
-from datetime import datetime
-from typing import Union, Dict, Iterable
+from datetime import datetime, date, time
+from typing import Union, Dict, Iterable, Optional
 
 from lets_plot._type_utils import is_polars_dataframe
 from lets_plot.plot.util import is_pandas_data_frame
 
+try:
+    import numpy
+except ImportError:
+    numpy = None
+
+try:
+    import pandas
+except ImportError:
+    pass
+
+try:
+    import polars as pl
+    from polars.datatypes.group import INTEGER_DTYPES as PL_INTEGER_DTYPES
+    from polars.datatypes.group import FLOAT_DTYPES as PL_FLOAT_DTYPES
+except ImportError:
+    pass
+
 TYPE_INTEGER = 'int'
 TYPE_FLOATING = 'float'
 TYPE_STRING = 'str'
 TYPE_BOOLEAN = 'bool'
 TYPE_DATE_TIME = 'datetime'
+TYPE_DATE = 'date'  # Local date (no time zone)
+TYPE_TIME = 'time'  # Local time (we ignore time zone even if it is present)
 TYPE_UNKNOWN = 'unknown'
 
 
-def infer_type(data: Union[Dict, 'pandas.DataFrame', 'polars.DataFrame']) -> Dict[str, str]:
+def _infer_type(data: Union[Dict, 'pandas.DataFrame', 'polars.DataFrame']) -> Dict[str, str]:
     type_info = {}
 
     if is_pandas_data_frame(data):
-        import pandas as pd
-        import numpy as np  # np is a dependency of pandas, we can import it without checking
-
         for var_name, var_content in data.items():
-            if data.empty:
-                type_info[var_name] = TYPE_UNKNOWN
-                continue
-
-            inferred_type = pd.api.types.infer_dtype(var_content.values, skipna=True)
-            if inferred_type == "categorical":
-                dtype = var_content.cat.categories.dtype
-
-                if np.issubdtype(dtype, np.integer):
-                    type_info[var_name] = TYPE_INTEGER
-                elif np.issubdtype(dtype, np.floating):
-                    type_info[var_name] = TYPE_FLOATING
-                elif np.issubdtype(dtype, np.object_):
-                    # Check if all elements are strings
-                    if all(isinstance(x, str) for x in var_content.cat.categories):
-                        type_info[var_name] = TYPE_STRING
-                    else:
-                        type_info[var_name] = TYPE_UNKNOWN
-                else:
-                    type_info[var_name] = TYPE_UNKNOWN
-            else:
-                # see https://pandas.pydata.org/docs/reference/api/pandas.api.types.infer_dtype.html
-                if inferred_type == 'string':
-                    type_info[var_name] = TYPE_STRING
-                elif inferred_type == 'floating':
-                    type_info[var_name] = TYPE_FLOATING
-                elif inferred_type == 'integer':
-                    type_info[var_name] = TYPE_INTEGER
-                elif inferred_type == 'boolean':
-                    type_info[var_name] = TYPE_BOOLEAN
-                elif inferred_type == 'datetime64' or inferred_type == 'datetime':
-                    type_info[var_name] = TYPE_DATE_TIME
-                elif inferred_type == "date":
-                    type_info[var_name] = TYPE_DATE_TIME
-                elif inferred_type == 'empty':  # for columns with all None values
-                    type_info[var_name] = TYPE_UNKNOWN
-                else:
-                    type_info[var_name] = 'unknown(pandas:' + inferred_type + ')'
+            type_info[var_name] = _infer_type_pandas_dataframe(var_name, var_content)
     elif is_polars_dataframe(data):
-        import polars as pl
-        from polars.datatypes.group import INTEGER_DTYPES, FLOAT_DTYPES
         for var_name, var_type in data.schema.items():
-
-            # https://docs.pola.rs/api/python/stable/reference/datatypes.html
-            if var_type in FLOAT_DTYPES:
-                type_info[var_name] = TYPE_FLOATING
-            elif var_type in INTEGER_DTYPES:
-                type_info[var_name] = TYPE_INTEGER
-            elif var_type == pl.datatypes.String:
-                type_info[var_name] = TYPE_STRING
-            elif var_type == pl.datatypes.Boolean:
-                type_info[var_name] = TYPE_BOOLEAN
-            elif var_type == pl.datatypes.Date or var_type == pl.datatypes.Datetime:
-                type_info[var_name] = TYPE_DATE_TIME
-            else:
-                type_info[var_name] = 'unknown(polars:' + str(var_type) + ')'
+            type_info[var_name] = _infer_type_polars_dataframe(var_name, var_type)
     elif isinstance(data, dict):
         for var_name, var_content in data.items():
-            if isinstance(var_content, Iterable):
-                if not any(True for _ in var_content):  # empty
-                    type_info[var_name] = TYPE_UNKNOWN
-                    continue
-
-                type_set = set(type(val) for val in var_content)
-                if type(None) in type_set:
-                    type_set.remove(type(None))
-
-                if len(type_set) == 0:
-                    continue
-
-                if len(type_set) > 1:
-                    if all(issubclass(type_obj, int) or issubclass(type_obj, float) for type_obj in type_set):
-                        type_info[var_name] = TYPE_FLOATING
-                    else:
-                        type_info[var_name] = 'unknown(mixed types)'
-                    continue
-
-                try:
-                    import numpy
-                except ImportError:
-                    numpy = None
-
-                type_obj = list(type_set)[0]
-                if type_obj == bool:
-                    type_info[var_name] = TYPE_BOOLEAN
-                elif issubclass(type_obj, int):
-                    type_info[var_name] = TYPE_INTEGER
-                elif issubclass(type_obj, float):
-                    type_info[var_name] = TYPE_FLOATING
-                elif issubclass(type_obj, str):
-                    type_info[var_name] = TYPE_STRING
-                elif issubclass(type_obj, datetime):
-                    type_info[var_name] = TYPE_DATE_TIME
-                elif numpy and issubclass(type_obj, numpy.datetime64):
-                    type_info[var_name] = TYPE_DATE_TIME
-                elif numpy and issubclass(type_obj, numpy.timedelta64):
-                    type_info[var_name] = TYPE_DATE_TIME
-                elif numpy and issubclass(type_obj, numpy.integer):
-                    type_info[var_name] = TYPE_INTEGER
-                elif numpy and issubclass(type_obj, numpy.floating):
-                    type_info[var_name] = TYPE_FLOATING
-                else:
-                    type_info[var_name] = 'unknown(python:' + str(type_obj) + ')'
+            type_info[var_name] = _infer_type_dict(var_name, var_content)
 
     return type_info
+
+
+def _infer_type_pandas_dataframe(var_name: str, var_content) -> str:
+    if var_content.empty:
+        return TYPE_UNKNOWN
+    elif var_content.isna().all():
+        return TYPE_UNKNOWN
+
+    lp_dtype = TYPE_UNKNOWN
+    time_zone = None
+    pandas_dtype = pandas.api.types.infer_dtype(var_content.values, skipna=True)
+
+    if pandas_dtype == "categorical":
+        dtype = var_content.cat.categories.dtype
+
+        if numpy.issubdtype(dtype, numpy.integer):
+            lp_dtype = TYPE_INTEGER
+        elif numpy.issubdtype(dtype, numpy.floating):
+            lp_dtype = TYPE_FLOATING
+        elif numpy.issubdtype(dtype, numpy.object_):
+            # Check if all elements are strings
+            if all(isinstance(x, str) for x in var_content.cat.categories):
+                lp_dtype = TYPE_STRING
+    else:
+        # see https://pandas.pydata.org/docs/reference/api/pandas.api.types.infer_dtype.html
+        if pandas_dtype == 'string':
+            lp_dtype = TYPE_STRING
+        elif pandas_dtype == 'floating':
+            lp_dtype = TYPE_FLOATING
+        elif pandas_dtype == 'integer':
+            lp_dtype = TYPE_INTEGER
+        elif pandas_dtype == 'boolean':
+            lp_dtype = TYPE_BOOLEAN
+
+        elif pandas_dtype == 'datetime64' or pandas_dtype == 'datetime':
+            lp_dtype = TYPE_DATE_TIME
+        elif pandas_dtype == "date":
+            lp_dtype = TYPE_DATE
+        elif pandas_dtype == "time":
+            lp_dtype = TYPE_TIME
+
+        elif pandas_dtype == 'empty':  # for columns with all None values
+            lp_dtype = TYPE_UNKNOWN
+        else:
+            lp_dtype = 'unknown(pandas:' + pandas_dtype + ')'
+
+    return lp_dtype
+
+
+def _infer_type_polars_dataframe(var_name: str, var_type) -> str:
+    lp_dtype = TYPE_UNKNOWN
+
+    # https://docs.pola.rs/api/python/stable/reference/datatypes.html
+    if var_type in PL_FLOAT_DTYPES:
+        lp_dtype = TYPE_FLOATING
+    elif var_type in PL_INTEGER_DTYPES:
+        lp_dtype = TYPE_INTEGER
+    elif var_type == pl.datatypes.String:
+        lp_dtype = TYPE_STRING
+    elif var_type == pl.datatypes.Boolean:
+        lp_dtype = TYPE_BOOLEAN
+
+    elif var_type == pl.datatypes.Datetime:
+        lp_dtype = TYPE_DATE_TIME
+    elif var_type == pl.datatypes.Date:
+        lp_dtype = TYPE_DATE
+    elif var_type == pl.datatypes.Time:
+        lp_dtype = TYPE_TIME
+
+    else:
+        lp_dtype = 'unknown(polars:' + str(var_type) + ')'
+
+    return lp_dtype
+
+
+def _infer_type_dict(var_name: str, var_content) -> str:
+    if isinstance(var_content, Iterable):
+        if not any(True for _ in var_content):  # empty
+            return TYPE_UNKNOWN
+    else:
+        return TYPE_UNKNOWN
+
+    type_set = set(type(val) for val in var_content)
+    if type(None) in type_set:
+        type_set.remove(type(None))
+
+    if len(type_set) == 0:
+        return TYPE_UNKNOWN
+
+    if len(type_set) > 1:
+        if all(issubclass(type_obj, int) or issubclass(type_obj, float) for type_obj in type_set):
+            return TYPE_FLOATING
+        else:
+            return 'unknown(mixed types)'
+
+    lp_dtype = TYPE_UNKNOWN
+    type_obj = list(type_set)[0]
+    if type_obj == bool:
+        lp_dtype = TYPE_BOOLEAN
+    elif issubclass(type_obj, int):
+        lp_dtype = TYPE_INTEGER
+    elif issubclass(type_obj, float):
+        lp_dtype = TYPE_FLOATING
+    elif issubclass(type_obj, str):
+        lp_dtype = TYPE_STRING
+
+    elif issubclass(type_obj, datetime):
+        lp_dtype = TYPE_DATE_TIME
+    elif issubclass(type_obj, date) and not issubclass(type_obj, datetime):
+        lp_dtype = TYPE_DATE
+    elif issubclass(type_obj, time):
+        lp_dtype = TYPE_TIME
+
+    elif numpy and issubclass(type_obj, numpy.datetime64):
+        lp_dtype = TYPE_DATE_TIME
+    elif numpy and issubclass(type_obj, numpy.timedelta64):
+        # ToDo: time delta?
+        # lp_dtype = TYPE_DATE_TIME
+        lp_dtype = 'unknown(python:' + str(type_obj) + ')'
+
+    elif numpy and issubclass(type_obj, numpy.integer):
+        lp_dtype = TYPE_INTEGER
+    elif numpy and issubclass(type_obj, numpy.floating):
+        lp_dtype = TYPE_FLOATING
+    else:
+        lp_dtype = 'unknown(python:' + str(type_obj) + ')'
+
+    return lp_dtype
+
+
+def _detect_time_zone(var_name: str, data: Union[Dict, 'pandas.DataFrame', 'polars.DataFrame']) -> Optional[str]:
+    if is_pandas_data_frame(data):
+        if var_name in data:
+            var_content = data[var_name]
+            if hasattr(var_content, 'dt') and hasattr(var_content.dt, 'tz') and var_content.dt.tz is not None:
+                return str(var_content.dt.tz)
+    elif is_polars_dataframe(data):
+        if var_name in data.columns:
+            col_dtype = data[var_name].dtype
+            if hasattr(col_dtype, 'time_zone'):
+                if col_dtype.time_zone is not None:
+                    return str(col_dtype.time_zone)
+    elif isinstance(data, dict):
+        if var_name in data:
+            var_content = data[var_name]
+            if isinstance(var_content, Iterable):
+                for val in var_content:
+                    if isinstance(val, datetime) and val.tzinfo is not None:
+                        return str(val.tzinfo)
+
+                    # NumPy datetime64 objects don't store timezone information,
+                    # so we can't extract it from them.
+
+    return None

lets_plot/plot/stat.py

@@ -32,7 +32,7 @@ def stat_summary(mapping=None, *, data=None, geom=None,
         The geometry to display the summary stat for this layer, as a string.
     position : str or `FeatureSpec`, default='identity'
         Position adjustment.
-        Either a position adjustment name: 'dodge', 'dodgev', 'jitter', 'nudge', 'jitterdodge', 'fill',
+        Either a position adjustment name: 'dodge', 'jitter', 'nudge', 'jitterdodge', 'fill',
         'stack' or 'identity', or the result of calling a position adjustment function (e.g., `position_dodge()` etc.).
     show_legend : bool, default=True
         False - do not show legend for this layer.
@@ -184,7 +184,7 @@ def stat_summary_bin(mapping=None, *, data=None, geom=None,
         The geometry to display the summary stat for this layer, as a string.
     position : str or `FeatureSpec`, default='identity'
         Position adjustment.
-        Either a position adjustment name: 'dodge', 'dodgev', 'jitter', 'nudge', 'jitterdodge', 'fill',
+        Either a position adjustment name: 'dodge', 'jitter', 'nudge', 'jitterdodge', 'fill',
         'stack' or 'identity', or the result of calling a position adjustment function (e.g., `position_dodge()` etc.).
     show_legend : bool, default=True
         False - do not show legend for this layer.
@@ -344,7 +344,7 @@ def stat_ecdf(mapping=None, *, data=None, geom=None,
         The geometry to display the ecdf stat for this layer, as a string.
     position : str or `FeatureSpec`, default='identity'
         Position adjustment.
-        Either a position adjustment name: 'dodge', 'dodgev', 'jitter', 'nudge', 'jitterdodge', 'fill',
+        Either a position adjustment name: 'dodge', 'jitter', 'nudge', 'jitterdodge', 'fill',
         'stack' or 'identity', or the result of calling a position adjustment function (e.g., `position_dodge()` etc.).
     show_legend : bool, default=True
         False - do not show legend for this layer.
@@ -485,7 +485,7 @@ def stat_sum(mapping=None, *, data=None, geom=None, position=None, show_legend=N
         The geometry to display the sum stat for this layer, as a string.
     position : str or `FeatureSpec`, default='identity'
         Position adjustment.
-        Either a position adjustment name: 'dodge', 'dodgev', 'jitter', 'nudge', 'jitterdodge', 'fill',
+        Either a position adjustment name: 'dodge', 'jitter', 'nudge', 'jitterdodge', 'fill',
         'stack' or 'identity', or the result of calling a position adjustment function (e.g., `position_dodge()` etc.).
     show_legend : bool, default=True
         False - do not show legend for this layer.

lets_plot/plot/subplots.py

@@ -221,10 +221,10 @@ class SupPlotsSpec(FeatureSpec):
         h : float, default=None
             Height of the output image in units.
             Only applicable when exporting to PNG or PDF.
-        unit : {'in', 'cm', 'mm'}, default=None
+        unit : {'in', 'cm', 'mm'}, default='in'
             Unit of the output image. One of: 'in', 'cm', 'mm'.
             Only applicable when exporting to PNG or PDF.
-        dpi : int, default=None
+        dpi : int, default=300
             Resolution in dots per inch.
             Only applicable when exporting to PNG or PDF.
 
@@ -282,10 +282,10 @@ class SupPlotsSpec(FeatureSpec):
         h : float, default=None
             Height of the output image in units.
             Only applicable when exporting to PNG or PDF.
-        unit : {'in', 'cm', 'mm'}, default=None
+        unit : {'in', 'cm', 'mm'}, default='in'
             Unit of the output image. One of: 'in', 'cm', 'mm'.
             Only applicable when exporting to PNG or PDF.
-        dpi : int, default=None
+        dpi : int, default=300
             Resolution in dots per inch.
             Only applicable when exporting to PNG or PDF.