Robust fix

Author: cvanelteren

ultraplot/axes/plot.py

@@ -2477,52 +2477,43 @@ def _parse_cycle(
             Whether to simply return the property cycle or apply it. The cycle is
             only applied (and therefore reset) if it differs from the current one.
         """
+        cycle_kw = cycle_kw or {}
+        cycle_manually = cycle_manually or {}
+        cycle_kw.setdefault("N", ncycle)
+
+        # Match-case for cycle resolution
+        match cycle:
+            case None if not cycle_kw:
+                resolved_cycle = None
+            case True:
+                resolved_cycle = constructor.Cycle(rc["axes.prop_cycle"])
+            case str() if cycle.lower() == "none":
+                resolved_cycle = None
+            case str() | int():
+                resolved_cycle = constructor.Cycle(cycle, **cycle_kw)
+            case _:
+                resolved_cycle = None
+
+        # Ignore cycle for single-column plotting
+        resolved_cycle = None if ncycle == 1 else resolved_cycle
+
+        # Return or apply cycle
+        if return_cycle:
+            return resolved_cycle, kwargs
 
-        # Create/update cycler only if needed
-
-        if cycle is not None or cycle_kw or not hasattr(self, "_current_cycler"):
-            cycle_kw = cycle_kw or {}
-            if ncycle != 1:
-                cycle_kw.setdefault("N", ncycle)
-            # Convert string or list to Cycle object
-            if isinstance(cycle, (str, list)):
-                cycle = constructor.Cycle(cycle, **cycle_kw)
-            elif cycle is True:
-                cycle = constructor.Cycle(rc["axes.prop_cycle"], **cycle_kw)
-            elif cycle is False:
-                cycle = None
-            elif cycle is not None and not isinstance(cycle, constructor.Cycle):
-                cycle = constructor.Cycle(cycle, **cycle_kw)
-
-            if not hasattr(self, "_current_cycler"):
-                self._current_cycler = cycle
-
-            # Update the current cycler if it changed
-            if cycle != self._current_cycler:
-                self._current_cycle = cycle
-                if not return_cycle and self._current_cycler != self._active_cycle:
-                    self.set_prop_cycle(cycle)
-
-
-        # Use existing cycler if none specified
-        if cycle is None:
-            cycle = self._current_cycler
-
-        # Get next set of properties
-        if cycle is not None:
-            props = cycle.get_next()
-            if cycle_manually:
-                mapped_props = {}
-                for prop, value in props.items():
-                    if mapped_key := cycle_manually.get(prop):
-                        mapped_props[mapped_key] = value
-                for prop in props:
-                    if prop in cycle_manually:
-                        kwargs.pop(prop, None)
-                kwargs.update(mapped_props)
+        if resolved_cycle and resolved_cycle != self._active_cycle:
+            self.set_prop_cycle(resolved_cycle)
 
-        if return_cycle:
-            return cycle, kwargs
+        # Apply manual cycle properties
+        if cycle_manually:
+            current_prop = self._get_lines._cycler_items[self._get_lines._idx]
+            self._get_lines._idx = (self._get_lines._idx + 1) % len(
+                self._get_lines._cycler_items
+            )
+            for prop, key in cycle_manually.items():
+                if kwargs.get(key) is None and prop in current_prop:
+                    value = current_prop[prop]
+                    kwargs[key] = pcolors.to_hex(value) if key == "c" else value
         return kwargs
 
     def _parse_level_lim(
@@ -3458,8 +3449,6 @@ def _apply_scatter(self, xs, ys, ss, cc, *, vert=True, **kwargs):
         ys, kw = inputs._dist_reduce(ys, **kw)
         ss, kw = self._parse_markersize(ss, **kw)  # parse 's'
 
-
-
         # Only parse color if explicitly provided
         infer_rgb = True
         if cc is not None:
@@ -3480,15 +3469,16 @@ def _apply_scatter(self, xs, ys, ss, cc, *, vert=True, **kwargs):
                 infer_rgb=infer_rgb,
                 **kw,
             )
-        # Move _parse_cycle before _parse_color
+        # Create the cycler object by manually cycling and sanitzing the inputs
         kw = self._parse_cycle(
-                xs.shape[1] if xs.ndim > 1 else 1, cycle_manually=cycle_manually, **kw
-            )
+            xs.shape[1] if xs.ndim > 1 else 1, cycle_manually=cycle_manually, **kw
+        )
 
         guide_kw = _pop_params(kw, self._update_guide)
         objs = []
         for _, n, x, y, s, c, kw in self._iter_arg_cols(xs, ys, ss, cc, **kw):
-            # Don't set 'c' explicitly unless it was provided
+            # Cycle s and c as they are in cycle_manually
+            # Note: they could be None
             kw["s"], kw["c"] = s, c
             kw = self._parse_cycle(n, cycle_manually=cycle_manually, **kw)
             *eb, kw = self._add_error_bars(x, y, vert=vert, default_barstds=True, **kw)
@@ -4030,6 +4020,7 @@ def _apply_violinplot(
         bodies = artists.pop("bodies", ())  # should be no other entries
         if bodies:
             bodies = cbook.silent_list(type(bodies[0]).__name__, bodies)
+
         for i, body in enumerate(bodies):
             body.set_alpha(1.0)  # change default to 1.0
             if fillcolor[i] is not None:

ultraplot/constructor.py

@@ -30,7 +30,13 @@
 from . import ticker as pticker
 from .config import rc
 from .internals import ic  # noqa: F401
-from .internals import _not_none, _pop_props, _version_cartopy, _version_mpl, warnings
+from .internals import (
+    _not_none,
+    _pop_props,
+    _version_cartopy,
+    _version_mpl,
+    warnings,
+)
 from .utils import get_colors, to_hex, to_rgba
 
 try:
@@ -235,7 +241,12 @@
         "height": 15000e3,
     },
     "tmerc": {"lon_0": 0, "lat_0": 0, "width": 10000e3, "height": 10000e3},
-    "merc": {"llcrnrlat": -80, "urcrnrlat": 84, "llcrnrlon": -180, "urcrnrlon": 180},
+    "merc": {
+        "llcrnrlat": -80,
+        "urcrnrlat": 84,
+        "llcrnrlon": -180,
+        "urcrnrlon": 180,
+    },
     "omerc": {
         "lat_0": 0,
         "lon_0": 0,
@@ -763,93 +774,87 @@ def _pop_modification(key):
 
 
 class Cycle(cycler.Cycler):
+    """
+    Generate and merge `~cycler.Cycler` instances in a variety of ways. The new generated class can be used to internally map keywords to the properties of the `~cycler.Cycler` instance. It is used by various plot functions to cycle through colors, linestyles, markers, etc.
+
+    Parameters
+    ----------
+    *args : colormap-spec or cycle-spec, optional
+        Positional arguments control the *colors* in the `~cycler.Cycler`
+        object. If zero arguments are passed, the single color ``'black'``
+        is used. If more than one argument is passed, the resulting cycles
+        are merged. Arguments are interpreted as follows:
+
+        * If a `~cycler.Cycler`, nothing more is done.
+        * If a sequence of RGB tuples or color strings, these colors are used.
+        * If a `~ultraplot.colors.DiscreteColormap`, colors from the ``colors``
+        attribute are used.
+        * If a string cycle name, that `~ultraplot.colors.DiscreteColormap`
+        is looked up and its ``colors`` are used.
+        * In all other cases, the argument is passed to `Colormap`, and
+        colors from the resulting `~ultraplot.colors.ContinuousColormap`
+        are used. See the `samples` argument.
+
+        If the last positional argument is numeric, it is used for the
+        `samples` keyword argument.
+    N
+        Shorthand for `samples`.
+    samples : float or sequence of float, optional
+        For `~ultraplot.colors.DiscreteColormap`\\ s, this is the number of
+        colors to select. For example, ``Cycle('538', 4)`` returns the first 4
+        colors of the ``'538'`` color cycle.
+        For `~ultraplot.colors.ContinuousColormap`\\ s, this is either a
+        sequence of sample coordinates used to draw colors from the colormap, or
+        an integer number of colors to draw. If the latter, the sample coordinates
+        are ``np.linspace(0, 1, samples)``. For example, ``Cycle('Reds', 5)``
+        divides the ``'Reds'`` colormap into five evenly spaced colors.
+
+    Other parameters
+    ----------------
+    c, color, colors : sequence of color-spec, optional
+        A sequence of colors passed as keyword arguments. This is equivalent
+        to passing a sequence of colors as the first positional argument and is
+        included for consistency with `~matplotlib.axes.Axes.set_prop_cycle`.
+        If positional arguments were passed, the colors in this list are
+        appended to the colors resulting from the positional arguments.
+    lw, ls, d, a, m, ms, mew, mec, mfc
+        Shorthands for the below keywords.
+    linewidth, linestyle, dashes, alpha, marker, markersize, markeredgewidth, \
+markeredgecolor, markerfacecolor : object or sequence of object, optional
+        Lists of `~matplotlib.lines.Line2D` properties that can be added to the
+        `~cycler.Cycler` instance. If the input was already a `~cycler.Cycler`,
+        these are added or appended to the existing cycle keys. If the lists have
+        unequal length, they are repeated to their least common multiple (unlike
+        `~cycler.cycler`, which throws an error in this case). For more info
+        on cyclers see `~matplotlib.axes.Axes.set_prop_cycle`. Also see
+        the `line style reference \
+<https://matplotlib.org/2.2.5/gallery/lines_bars_and_markers/line_styles_reference.html>`__,
+        the `marker reference \
+<https://matplotlib.org/stable/gallery/lines_bars_and_markers/marker_reference.html>`__,
+        and the `custom dashes reference \
+<https://matplotlib.org/stable/gallery/lines_bars_and_markers/line_demo_dash_control.html>`__.
+    linewidths, linestyles, dashes, alphas, markers, markersizes, markeredgewidths, \
+markeredgecolors, markerfacecolors
+        Aliases for the above keywords.
+    **kwargs
+        If the input is not already a `~cycler.Cycler` instance, these are passed
+        to `Colormap` and used to build the `~ultraplot.colors.DiscreteColormap`
+        from which the cycler will draw its colors.
+
+    See also
+    --------
+    cycler.cycler
+    cycler.Cycler
+    matplotlib.axes.Axes.set_prop_cycle
+    ultraplot.constructor.Colormap
+    ultraplot.constructor.Norm
+    ultraplot.utils.get_colors
+    """
+
     def __init__(self, *args, N=None, samples=None, name=None, **kwargs):
-        """
-        Generate and merge `~cycler.Cycler` instances in a variety of ways.
-
-        Parameters
-        ----------
-        *args : colormap-spec or cycle-spec, optional
-            Positional arguments control the *colors* in the `~cycler.Cycler`
-            object. If zero arguments are passed, the single color ``'black'``
-            is used. If more than one argument is passed, the resulting cycles
-            are merged. Arguments are interpreted as follows:
-
-            * If a `~cycler.Cycler`, nothing more is done.
-            * If a sequence of RGB tuples or color strings, these colors are used.
-            * If a `~ultraplot.colors.DiscreteColormap`, colors from the ``colors``
-            attribute are used.
-            * If a string cycle name, that `~ultraplot.colors.DiscreteColormap`
-            is looked up and its ``colors`` are used.
-            * In all other cases, the argument is passed to `Colormap`, and
-            colors from the resulting `~ultraplot.colors.ContinuousColormap`
-            are used. See the `samples` argument.
-
-            If the last positional argument is numeric, it is used for the
-            `samples` keyword argument.
-        N
-            Shorthand for `samples`.
-        samples : float or sequence of float, optional
-            For `~ultraplot.colors.DiscreteColormap`\\ s, this is the number of
-            colors to select. For example, ``Cycle('538', 4)`` returns the first 4
-            colors of the ``'538'`` color cycle.
-            For `~ultraplot.colors.ContinuousColormap`\\ s, this is either a
-            sequence of sample coordinates used to draw colors from the colormap, or
-            an integer number of colors to draw. If the latter, the sample coordinates
-            are ``np.linspace(0, 1, samples)``. For example, ``Cycle('Reds', 5)``
-            divides the ``'Reds'`` colormap into five evenly spaced colors.
-
-        Other parameters
-        ----------------
-        c, color, colors : sequence of color-spec, optional
-            A sequence of colors passed as keyword arguments. This is equivalent
-            to passing a sequence of colors as the first positional argument and is
-            included for consistency with `~matplotlib.axes.Axes.set_prop_cycle`.
-            If positional arguments were passed, the colors in this list are
-            appended to the colors resulting from the positional arguments.
-        lw, ls, d, a, m, ms, mew, mec, mfc
-            Shorthands for the below keywords.
-        linewidth, linestyle, dashes, alpha, marker, markersize, markeredgewidth, \
-    markeredgecolor, markerfacecolor : object or sequence of object, optional
-            Lists of `~matplotlib.lines.Line2D` properties that can be added to the
-            `~cycler.Cycler` instance. If the input was already a `~cycler.Cycler`,
-            these are added or appended to the existing cycle keys. If the lists have
-            unequal length, they are repeated to their least common multiple (unlike
-            `~cycler.cycler`, which throws an error in this case). For more info
-            on cyclers see `~matplotlib.axes.Axes.set_prop_cycle`. Also see
-            the `line style reference \
-    <https://matplotlib.org/2.2.5/gallery/lines_bars_and_markers/line_styles_reference.html>`__,
-            the `marker reference \
-    <https://matplotlib.org/stable/gallery/lines_bars_and_markers/marker_reference.html>`__,
-            and the `custom dashes reference \
-    <https://matplotlib.org/stable/gallery/lines_bars_and_markers/line_demo_dash_control.html>`__.
-        linewidths, linestyles, dashes, alphas, markers, markersizes, markeredgewidths, \
-    markeredgecolors, markerfacecolors
-            Aliases for the above keywords.
-        **kwargs
-            If the input is not already a `~cycler.Cycler` instance, these are passed
-            to `Colormap` and used to build the `~ultraplot.colors.DiscreteColormap`
-            from which the cycler will draw its colors.
-
-        Returns
-        -------
-        cycler.Cycler
-            A `~cycler.Cycler` instance that can be passed
-            to `~matplotlib.axes.Axes.set_prop_cycle`.
-
-        See also
-        --------
-        cycler.cycler
-        cycler.Cycler
-        matplotlib.axes.Axes.set_prop_cycle
-        ultraplot.constructor.Colormap
-        ultraplot.constructor.Norm
-        ultraplot.utils.get_colors
-        """
         self.name = "_no_name"  # default value
         cycler_props = self._parse_basic_properties(kwargs)
         samples = _not_none(samples=samples, N=N)  # trigger Colormap default
-
         if not args:
             self._handle_empty_args(cycler_props, kwargs)
         elif self._is_all_cyclers(args):
@@ -876,7 +881,7 @@ def _parse_basic_properties(self, kwargs):
 
     def _handle_empty_args(self, props, kwargs):
         """Handle case when no positional arguments are provided."""
-        props.setdefault("color", ["black"])
+        props.setdefault("color", "black")
         if kwargs:
             warnings._warn_ultraplot(f"Ignoring Cycle() keyword arg(s) {kwargs}.")
         self._build_cycler(())
@@ -921,11 +926,10 @@ def _build_cycler(self, dicts):
         for dict_ in dicts:
             for key, value in dict_.items():
                 props.setdefault(key, []).extend(value)
-
         # Build cycler with matching property lengths
         # Ensure at least a default color property exists
         if not props:
-            props = {'color': ['black']}
+            props = {"color": ["black"]}
 
         # Build cycler with matching property lengths
         lengths = [len(value) for value in props.values()]