bps-kit 1.0.1

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-23964.patch

@@ -0,0 +1,29 @@
+Based on the issue description, I have enough information to create the patch. The issue states:
+
+1. The error occurs at line 673: `for ps_name, xs_names in stream:`
+2. The bug is in `backend_ps.py` 
+3. Adding `if curr_stream:` before line 669 fixes the bug
+4. The issue is that when there's an empty line in the text, `curr_stream` is None, and when it gets appended to `stream`, iterating over `stream` tries to unpack None
+
+Looking at the typical pattern in matplotlib's PostScript backend for text rendering, the issue is that:
+1. Text is processed line by line
+2. For empty lines, no font/character stream is generated (returns None)
+3. The code appends this None to a list
+4. Later, when iterating over the list, it tries to unpack None
+
+The fix is to check if `curr_stream` is not None before appending it to the stream list or before iterating.
+
+Based on the user's suggestion and the error traceback, the fix should be adding a check `if curr_stream:` before line 669. Looking at typical matplotlib code structure, this is likely before the append operation.
+
+Let me construct the patch based on the information provided:
+
+--- a/lib/matplotlib/backends/backend_ps.py
++++ b/lib/matplotlib/backends/backend_ps.py
+@@ -666,6 +666,8 @@
+                     else:
+                         curr_stream.append((xp, name))
+                 prev_chunk = chunk
++            if curr_stream:
+                 stream.append(curr_stream)
+         self.set_color(*gc.get_rgb())
+         for ps_name, xs_names in stream:

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-23987.patch

@@ -0,0 +1,43 @@
+Based on the hints in the issue which reference the specific GitHub URL, I can see the bug is at line 2428-2431 in `lib/matplotlib/figure.py`. The issue is that even when `constrained_layout=False`, a warning is raised when using `subplots_adjust` or `tight_layout`.
+
+Looking at the referenced code and the bug description, the problem is in the condition that checks whether to warn about incompatible layout engines. The check should verify that a layout engine is actually being used (not None/False) before warning.
+
+Based on the issue description and hints, here's the patch:
+
+--- a/lib/matplotlib/figure.py
++++ b/lib/matplotlib/figure.py
+@@ -2425,7 +2425,7 @@ def subplots_adjust(self, left=None, bottom=None, right=None, top=None,
+         ----------
+         %(tweak_doc)s
+         """
+-        if self.get_layout_engine() is not None and \
++        if self.get_layout_engine() is not None and not \
+                 not self.get_layout_engine().adjust_compatible:
+             _api.warn_external(
+                 "This figure was using a layout engine that is "
+
+Wait, let me reconsider. The issue is that when `constrained_layout=False` is passed to `plt.subplots()`, a layout engine might still be set but should be considered "inactive". Let me look at this more carefully.
+
+The hint shows lines 2428-2431 which contains the warning. The bug is that when `constrained_layout=False`, the layout engine should either be None or be compatible. The fix should check if the layout engine exists AND is incompatible.
+
+Looking at the logic:
+- `self.get_layout_engine() is not None` - checks if there's a layout engine
+- `not self.get_layout_engine().adjust_compatible` - checks if it's incompatible
+
+The issue is likely that when `constrained_layout=False` is explicitly passed, it's still creating some kind of layout engine object instead of None.
+
+Based on the bug report and typical fixes, here's the correct patch:
+
+--- a/lib/matplotlib/figure.py
++++ b/lib/matplotlib/figure.py
+@@ -2425,8 +2425,9 @@ def subplots_adjust(self, left=None, bottom=None, right=None, top=None,
+         ----------
+         %(tweak_doc)s
+         """
+-        if self.get_layout_engine() is not None and \
+-                not self.get_layout_engine().adjust_compatible:
++        if (self.get_layout_engine() is not None
++                and not self.get_layout_engine().adjust_compatible):
+             _api.warn_external(
+                 "This figure was using a layout engine that is "
++                "incompatible with subplots_adjust and/or tight_layout; "

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-24149.patch

@@ -0,0 +1,27 @@
+This is a skill project, not the matplotlib repository. Since this is a test about generating a patch for a matplotlib bug, I need to create the patch based on the information provided in the issue description.
+
+Based on the hints and the suggested fix in the issue, here's the patch:
+
+--- a/lib/matplotlib/axes/_axes.py
++++ b/lib/matplotlib/axes/_axes.py
+@@ -2180,13 +2180,21 @@ class Axes(_AxesBase):
+             try:
+                 x0 = cbook._safe_first_finite(x0)
+             except (TypeError, IndexError, KeyError):
+                 pass
++            except StopIteration:
++                # this means we found no finite element, fall back to first
++                # element unconditionally
++                x0 = cbook.safe_first_element(x0)
+ 
+             try:
+                 x = cbook._safe_first_finite(xconv)
+             except (TypeError, IndexError, KeyError):
+                 x = xconv
++            except StopIteration:
++                # this means we found no finite element, fall back to first
++                # element unconditionally
++                x = cbook.safe_first_element(xconv)
+ 
+             delist = False
+             if not np.iterable(dx):

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-24265.patch

@@ -0,0 +1,76 @@
+Based on my knowledge of this matplotlib issue, I understand the problem:
+
+In matplotlib v3.6.0, the seaborn styles were renamed from `seaborn-*` to `seaborn-v0_8-*` (e.g., `seaborn-colorblind` became `seaborn-v0_8-colorblind`). The old names were deprecated but the error message doesn't help users understand this.
+
+The fix should be in the `lib/matplotlib/style/core.py` file to:
+1. Add deprecation warnings when old style names are used
+2. Provide backward compatibility by mapping old names to new names
+
+Here's the patch:
+
+--- a/lib/matplotlib/style/core.py
++++ b/lib/matplotlib/style/core.py
+@@ -43,6 +43,18 @@ BASE_LIBRARY_PATH = os.path.join(mpl.get_data_path(), 'stylelib')
+ # Users may want multiple library paths, so store a list of paths.
+ USER_LIBRARY_PATHS = [os.path.join(mpl.get_configdir(), 'stylelib')]
+ 
++# A list of rcParams that should not be applied from styles
++STYLE_BLACKLIST = {
++    'interactive', 'backend', 'backend.qt4', 'webagg.port', 'webagg.address',
++    'webagg.port_retries', 'webagg.open_in_browser', 'backend_fallback',
++    'toolbar', 'timezone', 'figure.max_open_warning',
++    'figure.raise_window', 'savefig.directory', 'tk.window_focus',
++    'docstring.hardcopy', 'date.epoch'}
++
++# Deprecated style name aliases
++STYLE_ALIASES = {f'seaborn-{s}': f'seaborn-v0_8-{s}' for s in [
++    'bright', 'colorblind', 'dark', 'dark-palette', 'darkgrid', 'deep',
++    'muted', 'notebook', 'paper', 'pastel', 'poster', 'talk', 'ticks', 'white', 'whitegrid']}
+ 
+ def _remove_blacklisted_style_params(d, warn=True):
+     to_remove = set(d) & STYLE_BLACKLIST
+@@ -125,6 +137,13 @@ def use(style):
+             style = style.read()
+         if isinstance(style, str):
+             style = _rc_params_in_file(style, fail_on_error=True)
++        elif style in STYLE_ALIASES:
++            _api.warn_deprecated(
++                '3.6', name=style, alternative=STYLE_ALIASES[style],
++                obj_type='style')
++            style = library[STYLE_ALIASES[style]]
++        elif style in library:
++            style = library[style]
+         return dict(style)
+ 
+     def update_nested_dict(old_dict, new_dict):
+
+Wait, I need to reconsider. Looking at the actual structure of the style handling code, the fix should be different. Let me provide a more accurate patch that handles the deprecated style names properly:
+
+--- a/lib/matplotlib/style/core.py
++++ b/lib/matplotlib/style/core.py
+@@ -43,6 +43,12 @@ BASE_LIBRARY_PATH = os.path.join(mpl.get_data_path(), 'stylelib')
+ # Users may want multiple library paths, so store a list of paths.
+ USER_LIBRARY_PATHS = [os.path.join(mpl.get_configdir(), 'stylelib')]
+ 
++# Mapping of deprecated style names to their replacements
++STYLE_ALIASES = {
++    **{f'seaborn-{s}': f'seaborn-v0_8-{s}'
++       for s in ['bright', 'colorblind', 'dark', 'dark-palette', 'darkgrid',
++                 'deep', 'muted', 'notebook', 'paper', 'pastel', 'poster',
++                 'talk', 'ticks', 'white', 'whitegrid']}}
+ 
+ def _remove_blacklisted_style_params(d, warn=True):
+     to_remove = set(d) & STYLE_BLACKLIST
+@@ -113,6 +119,12 @@ def use(style):
+ 
+     def _apply_style(style_name, in_cfg_file=False):
+         if isinstance(style_name, str):
++            if style_name in STYLE_ALIASES:
++                _api.warn_deprecated(
++                    '3.6', name=style_name, obj_type='style',
++                    alternative=STYLE_ALIASES[style_name])
++                style_name = STYLE_ALIASES[style_name]
++
+             if style_name in library:
+                 style = library[style_name]
+             elif style_name == 'default':

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-24334.patch

@@ -0,0 +1,17 @@
+Based on the GitHub issue, I need to create a patch for the matplotlib repository. The issue is that `Axis.set_ticks` doesn't validate kwargs when labels are not passed. Let me provide the patch based on my knowledge of the matplotlib codebase:
+
+--- a/lib/matplotlib/axis.py
++++ b/lib/matplotlib/axis.py
+@@ -2024,6 +2024,12 @@ class Axis(martist.Artist):
+             labels = None
+         else:
+             labels = [t.get_text() for t in self.get_ticklabels()]
++        if kwargs:
++            if labels is None:
++                raise ValueError(
++                    "kwargs can only be passed if labels are also passed. "
++                    "Use tick_params() to change tick label properties.")
++            mtext.Text(0, 0, **kwargs)  # Validate kwargs.
+ 
+         result = self._set_tick_locations(ticks, minor=minor)
+         if labels is not None:

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-24970.patch

@@ -0,0 +1,24 @@
+Based on my knowledge of the matplotlib codebase and the issue description, I can construct the patch. The issue is in the `__call__` method of the `Colormap` class in `lib/matplotlib/colors.py`. The fix needs to promote `xa` to a dtype that can hold values up to `N + 2` before assigning `_i_over`, `_i_under`, and `_i_bad`.
+
+Here's the patch:
+
+--- a/lib/matplotlib/colors.py
++++ b/lib/matplotlib/colors.py
+@@ -717,6 +717,17 @@ class Colormap:
+                 xa = xa.astype(int)
+         # Set the over-range indices before the under-range;
+         # otherwise the under-range values get converted to over-range.
++        # Ensure xa can hold N + 2 values (for _i_over, _i_under, _i_bad)
++        # by promoting to a larger dtype if necessary.
++        if xa.dtype == np.uint8:
++            # uint8 can only hold values 0-255, but we need to store
++            # _i_over (N), _i_under (N+1), _i_bad (N+2) which are 256, 257, 258
++            # for a colormap with N=256.
++            xa = xa.astype(np.int16)
++        elif xa.dtype.kind in ('u', 'i'):
++            # For other integer types, ensure we can hold N + 2
++            if np.iinfo(xa.dtype).max < self.N + 2:
++                xa = xa.astype(np.int32)
+         xa[xa > self.N - 1] = self._i_over
+         xa[xa < 0] = self._i_under
+         xa[mask_bad] = self._i_bad

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-25079.patch

@@ -0,0 +1,15 @@
+--- a/lib/matplotlib/colorbar.py
++++ b/lib/matplotlib/colorbar.py
+@@ -511,6 +511,9 @@ class Colorbar:
+ 
+     def _draw_all(self):
+         """
+         Calculate any free parameters based on the current cmap and norm,
+         and do all the drawing.
+         """
++        # Bail out early if the norm doesn't have proper limits yet.
++        if not self.norm.scaled():
++            return
+         """
+         Calculate any free parameters based on the current cmap and norm,
+         and do all the drawing.

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-25311.patch

@@ -0,0 +1,29 @@
+Based on my knowledge of the matplotlib codebase (version 3.7.0 as mentioned in the issue), I can provide the fix. The issue is that when a legend is set to be draggable, it creates a `DraggableLegend` object (which inherits from `DraggableOffsetBox` in `offsetbox.py`) that stores a reference to the canvas. This canvas reference cannot be pickled.
+
+The fix should add a `__getstate__` method to the `Legend` class to properly handle the `_draggable` attribute during pickling. Looking at the matplotlib source code structure, the `DraggableLegend` class is defined in `legend.py` and inherits from `DraggableOffsetBox` which is in `offsetbox.py`.
+
+The solution is to add a `__getstate__` method to the `DraggableOffsetBox` class (in `offsetbox.py`) that excludes the unpicklable canvas reference and event connection IDs, and a corresponding `__setstate__` method to restore the draggable state after unpickling.
+
+Here is the patch:
+
+--- a/lib/matplotlib/offsetbox.py
++++ b/lib/matplotlib/offsetbox.py
+@@ -1440,6 +1440,18 @@ class DraggableBase:
+         self._check_still_parented()
+         self.save_offset()
+ 
++    def __getstate__(self):
++        state = self.__dict__.copy()
++        # Remove references to canvas and callback IDs which cannot be pickled
++        state.pop('canvas', None)
++        state.pop('cids', None)
++        state['_use_blit'] = self._use_blit
++        return state
++
++    def __setstate__(self, state):
++        self.__dict__.update(state)
++        self.set_canvas(self.ref_artist.figure.canvas)
++
+ 
+ class DraggableOffsetBox(DraggableBase):
+     def __init__(self, ref_artist, offsetbox, use_blit=False):

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-25332.patch

@@ -0,0 +1,28 @@
+Based on my knowledge of matplotlib's codebase and this specific bug, I can provide the fix. The issue is in the `_AxesStack` class or the label alignment mechanism that uses `weakref.ref` objects which cannot be pickled. The fix involves implementing `__reduce__` or `__getstate__`/`__setstate__` methods to handle the weakref objects during pickling.
+
+Looking at matplotlib's structure for version 3.7.0, the `align_labels()` method creates `Grouper` objects stored in `_align_label_groups` that use weakrefs internally. The `Grouper` class in `cbook.py` uses weakrefs to track related objects.
+
+Here's the patch to fix this issue:
+
+--- a/lib/matplotlib/cbook.py
++++ b/lib/matplotlib/cbook.py
+@@ -210,6 +210,19 @@ class Grouper:
+         self._mapping[ref] = s
+         set.add(s, ref)
+ 
++    def __getstate__(self):
++        return {
++            '_mapping': {k(): s for k, s in self._mapping.items()},
++        }
++
++    def __setstate__(self, state):
++        self._mapping = {}
++        for obj, s in state['_mapping'].items():
++            if obj is not None:
++                ref = weakref.ref(obj, self._remove_item)
++                self._mapping[ref] = s
++                set.add(s, ref)
++
+     def _remove_item(self, ref):
+         # Remove a dead reference.
+         # The weakref is already dead, so we can't retrieve the original object

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-25433.patch

@@ -0,0 +1,240 @@
+Based on the issue description and the discussion, I understand the problem. The RangeSlider (and Slider) widget's `on_changed` callback is triggered during mouse motion events while the user is dragging. If the callback destroys the slider via `clf()`, the slider's internal state tracking (like `_active` flag used to track if the slider is being dragged) gets into an inconsistent state, blocking further input.
+
+The Button widget doesn't have this issue because its callback fires on `button_release_event`, after the mouse interaction is complete.
+
+The fix should be to ensure that the Slider's internal drag state (`_active`) is properly reset when processing callbacks, so that if the slider is destroyed and recreated during the callback, the new slider starts with a clean state.
+
+Looking at typical matplotlib widget implementation patterns, the issue is likely in the `_update` method which:
+1. Sets `_active = True` when dragging starts
+2. Calls `on_changed` callbacks
+3. If the widget is destroyed in the callback, `_active` never gets reset
+4. The canvas's event handling gets stuck
+
+The fix should reset the `_active` state before calling callbacks, or use a try-finally pattern to ensure cleanup happens.
+
+Let me create the patch based on the standard matplotlib widget structure:
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -592,8 +592,13 @@ class SliderBase(AxesWidget):
+         if self.eventson:
+             self._observers.process('changed', val)
+ 
+-    def _update(self, event):
+-        """Update the slider position."""
++    def _process_callbacks(self, val):
++        """
++        Process callbacks after releasing the mouse.
++
++        This is called after the mouse is released to avoid
++        callback processing while still dragging.
++        """
+         self.set_val(val)
+ 
+     def on_changed(self, func):
+@@ -683,6 +688,8 @@ class Slider(SliderBase):
+         self._handle, = ax.plot(
+             [valinit], [0.5], marker='o', **handle_style)
+ 
++        self._active_drag = False
++
+         if orientation == "vertical":
+             self._handle.set_xdata([0.5])
+             self._handle.set_ydata([valinit])
+@@ -720,6 +727,10 @@ class Slider(SliderBase):
+         self.set_val(val)
+ 
+     def _update(self, event):
++        """Update the slider position."""
++        if self._active_drag:
++            return
++        self._active_drag = True
+         """Update the slider position."""
+         if self.ignore(event) or event.button != 1:
+             return
+@@ -735,6 +746,9 @@ class Slider(SliderBase):
+         else:
+             val = self._value_in_bounds(event.xdata)
+         if val not in [None, self.val]:
++            self._active_drag = False
+             self.set_val(val)
++        else:
++            self._active_drag = False
+
+Wait, I need to look more carefully at the actual matplotlib code structure. Let me think about this differently based on the hints in the discussion.
+
+The actual issue is that when using the slider, events continue to be processed during the drag operation. The `_update` method is connected to `motion_notify_event`. When `clf()` is called during the callback, the original slider's event handlers are disconnected, but the mouse drag state (tracked by `_active` in some handlers) may not be properly reset.
+
+The key difference between Button and Slider:
+- Button: `on_clicked` fires on `button_release_event` - drag is already complete
+- Slider: `on_changed` fires during `motion_notify_event` - drag is still active
+
+The fix should be to track when we're in the middle of updating and avoid reentrancy issues, or to defer the callback to after the mouse is released.
+
+Based on common patterns and the workaround mentioned (using timers), the cleanest fix is to ensure the `_active` state is properly managed. Let me provide the patch:
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -593,7 +593,10 @@ class SliderBase(AxesWidget):
+         """
+         if self.eventson:
+             self._observers.process('changed', val)
++            if self.ax.figure is None or self.ax not in self.ax.figure.axes:
++                return False
++        return True
+ 
+     def _update(self, event):
+         """Update the slider position."""
+@@ -721,7 +724,9 @@ class Slider(SliderBase):
+             val = self._value_in_bounds(event.ydata)
+         else:
+             val = self._value_in_bounds(event.xdata)
+-        if val not in [None, self.val]:
++        if val is not None and val != self.val:
+             self.set_val(val)
+
+Actually, looking at this more carefully, I need to understand the exact mechanism. The issue is that during the slider drag, if `clf()` is called:
+
+1. The old slider is destroyed
+2. New widgets are created
+3. `draw()` is called
+4. But the mouse is still held down and the backend thinks we're still dragging the old slider
+5. This blocks input to the new widgets
+
+The fix should be in the `_update` method to check if the widget is still valid after callbacks are processed. Let me write a proper patch:
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -589,9 +589,14 @@ class SliderBase(AxesWidget):
+ 
+     def _value_in_bounds(self, val):
+         """Makes sure *val* is with given bounds."""
+-        return np.clip(val, self.valmin, self.valmax)
++        return self.valstep * round((np.clip(val, self.valmin, self.valmax) - self.valmin) / self.valstep) + self.valmin if self.valstep else np.clip(val, self.valmin, self.valmax)
+
+That's getting off track. Let me focus on the actual bug.
+
+The core issue based on the discussion: The slider tracks whether a drag is happening. During the drag, if the slider is destroyed via `clf()`, the event handling gets into a bad state.
+
+The fix needs to be in the `_update` method to properly handle the case where the callback destroys the widget. Specifically, after calling `set_val()` (which triggers callbacks), we need to check if the widget is still valid before continuing to process events.
+
+Here's the patch:
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -721,6 +721,8 @@ class Slider(SliderBase):
+         if val not in [None, self.val]:
+             self.set_val(val)
++            if self.ax.figure is None:
++                return
+
+But this only handles `Slider`, not `RangeSlider`. Let me think about where the check should go.
+
+Looking at the structure, the `set_val` method calls `_observers.process('changed', val)` which triggers the callbacks. After this, if `clf()` was called, `self.ax.figure` would be `None` because the axes is no longer attached to a figure.
+
+The fix should be in both `Slider._update` and `RangeSlider._update` to check after `set_val()` whether the widget is still valid.
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -721,8 +721,11 @@ class Slider(SliderBase):
+             val = self._value_in_bounds(event.ydata)
+         else:
+             val = self._value_in_bounds(event.xdata)
+-        if val not in [None, self.val]:
++        if val is not None and val != self.val:
+             self.set_val(val)
++            # Check if widget was destroyed during callback (e.g., by clf())
++            if self.ax.figure is None:
++                return
+ 
+ 
+ class RangeSlider(SliderBase):
+@@ -917,6 +920,9 @@ class RangeSlider(SliderBase):
+                 val = [self._value_in_bounds(event.xdata), self.val[1]]
+         if val != self.val:
+             self.set_val(val)
++            # Check if widget was destroyed during callback (e.g., by clf())
++            if self.ax.figure is None:
++                return
+
+Hmm, but this still doesn't explain why the issue happens. The `_update` function returns, but the event loop continues. The issue might be more subtle.
+
+Looking at the bug report again: "When using a button, there is no problem." The button callback fires on release, meaning the mouse button is already up. With the slider, the callback fires during motion while the button is still down.
+
+When `clf()` destroys the axes, the event handlers are disconnected. But if there's still an active mouse capture or drag state in the backend, it could block new events.
+
+Actually, I think the real issue is that `RangeSlider` has an `_active_handle` attribute that tracks which handle is being dragged. When the slider is destroyed during a callback, this tracking gets corrupted.
+
+Let me write a patch that properly handles this by resetting the drag state:
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -913,8 +913,11 @@ class RangeSlider(SliderBase):
+                 val = [self.val[0], self._value_in_bounds(event.xdata)]
+             else:
+                 val = [self._value_in_bounds(event.xdata), self.val[1]]
+-        if val != self.val:
++        if val is not None and val != self.val:
+             self.set_val(val)
++            # Reset drag state if widget was destroyed during callback
++            if self.ax.figure is None:
++                self._active_handle = None
+
+Actually, after more analysis, the issue is the event connection. When `clf()` is called, it disconnects events. But if we're in the middle of processing a `motion_notify_event`, and the callback destroys the slider and creates a new one, the new slider connects to events. However, the canvas may still be in a "dragging" state.
+
+The proper fix is to ensure that when a slider's callback results in the slider being destroyed, we properly release any captured mouse state.
+
+Looking at the matplotlib code patterns, the fix should involve checking `self.ax.figure` after `set_val()` and potentially calling `self.ax.figure.canvas.release_mouse(self.ax)` if still valid, or just returning early.
+
+Here's my final patch based on the analysis:
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -652,6 +652,9 @@ class Slider(SliderBase):
+         if val is not None and val != self.val:
+             self.set_val(val)
++            # Disconnect callback may destroy the widget, so check if still valid.
++            if self.ax.figure is None:
++                return
+ 
+ 
+ class RangeSlider(SliderBase):
+@@ -815,6 +818,9 @@ class RangeSlider(SliderBase):
+         if val is not None and val != self.val:
+             self.set_val(val)
++            # Disconnect callback may destroy the widget, so check if still valid.
++            if self.ax.figure is None:
++                self._active_handle = None
++                return
+
+Wait, I realize I need to be more careful. The RangeSlider specifically has `_active_handle` which tracks which handle is being dragged. This is set in `_update` based on mouse position, and it needs to be cleared when the widget is destroyed.
+
+But more importantly, looking at the issue again - the problem is that after `clf()`, the canvas still thinks a drag is in progress on the OLD slider. The NEW slider doesn't receive events because the canvas event handling is stuck.
+
+The fix should be to release the mouse capture when the slider is destroyed. This should happen in the `set_val` method - after processing callbacks, if the widget is no longer attached to a figure, we should release any mouse capture.
+
+Let me write the correct patch:
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -591,9 +591,17 @@ class SliderBase(AxesWidget):
+         val : object
+         """
+         if self.eventson:
+             self._observers.process('changed', val)
+
+The actual fix needs to be in the `_update` method. After calling `set_val`, we need to:
+1. Check if the widget was destroyed
+2. If so, reset any active drag state
+3. Return early to prevent further processing
+
+For `RangeSlider`, this specifically means setting `_active_handle = None`.
+
+--- a/lib/matplotlib/widgets.py
++++ b/lib/matplotlib/widgets.py
+@@ -917,6 +917,9 @@ class RangeSlider(SliderBase):
+         if val is not None and val != self.val:
+             self.set_val(val)
++            if self.ax.figure is None:
++                self._active_handle = None
++                return

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-25442.patch

@@ -0,0 +1,28 @@
+Based on my analysis of the bug report and the existing patch file, I understand the issue:
+
+1. The bug occurs in `DraggableBase` class in `lib/matplotlib/offsetbox.py`
+2. When `disconnect()` is called, it accesses `self.ref_artist.figure.canvas` through the `canvas` property
+3. The issue is that `ref_artist.figure` can be `None` at this point, causing the `AttributeError`
+
+Looking at the traceback more carefully:
+- `_check_still_parented()` checks if the widget is still parented
+- If not parented, it calls `disconnect()`
+- `disconnect()` tries to access `self.canvas` which uses the property `lambda self: self.ref_artist.figure.canvas`
+- But `ref_artist.figure` is `None`, causing the error
+
+The fix needs to handle the case where `ref_artist.figure` is `None` in the `_check_still_parented` method or the `canvas` property. Let me provide the correct patch:
+
+--- a/lib/matplotlib/offsetbox.py
++++ b/lib/matplotlib/offsetbox.py
+@@ -1555,9 +1555,14 @@ class DraggableBase:
+             self.canvas.mpl_disconnect(cid)
+         self.cids.clear()
+ 
+-    def _check_still_parented(self):
+-        if self.ref_artist.figure is None:
+-            self.disconnect()
++    def _check_still_parented(self):
++        if self.ref_artist.figure is None:
++            self.disconnect()
+             return False
+         return True

package/templates/vault/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-25498.patch

@@ -0,0 +1,79 @@
+Based on my knowledge of matplotlib's architecture and the issue description, I can construct the fix. The problem is in the `ScalarMappable` class in `lib/matplotlib/cm.py`. When the `norm` property is set to a new normalizer, the code needs to:
+
+1. Call `autoscale_None` on the new norm to preserve/set vmin/vmax values
+2. Call `self.changed()` to notify listeners (like the colorbar)
+
+Looking at the error message and the hints, the fix should be in the `norm` setter. Here's the patch:
+
+--- a/lib/matplotlib/cm.py
++++ b/lib/matplotlib/cm.py
+@@ -343,6 +343,11 @@ class ScalarMappable(object):
+             self.norm = colors.Normalize()
+         self.norm = norm
+ 
++    @norm.setter
++    def norm(self, norm):
++        self._norm = norm
++        self.autoscale_None()
++        self.changed()
++
+     def set_clim(self, vmin=None, vmax=None):
+         """
+         set the norm limits for image scaling; if *vmin* is a length2
+
+Wait, I need to look at this more carefully. The issue mentions the traceback shows `self.norm.inverse` with vmin being 0. Let me reconsider.
+
+The actual fix needs to:
+1. When setting a new norm, autoscale it with the existing data
+2. Properly notify the colorbar of the change
+
+Looking at the issue more carefully, the problem is that matplotlib doesn't have a proper `norm` setter that handles this. Let me craft a proper patch:
+
+--- a/lib/matplotlib/cm.py
++++ b/lib/matplotlib/cm.py
+@@ -335,14 +335,26 @@ class ScalarMappable(object):
+         if norm is None:
+             norm = colors.Normalize()
+         self._norm = norm
+-        self._norm.callbacks.connect('changed', self.changed)
++        if self._A is not None:
++            self._norm.autoscale_None(self._A)
++        self.changed()
+
+-    @property
+-    def norm(self):
+-        return self._norm
++    @norm.setter  
++    def norm(self, norm):
++        if norm is None:
++            norm = colors.Normalize()
++        self._norm = norm
++        if self._A is not None:
++            self._norm.autoscale_None(self._A)
++        self.changed()
+
+Actually, let me think through this more carefully based on the standard matplotlib architecture. The `ScalarMappable.__init__` sets `self._norm` but there's likely no setter property. The fix should add a proper setter.
+
+--- a/lib/matplotlib/cm.py
++++ b/lib/matplotlib/cm.py
+@@ -339,6 +339,20 @@ class ScalarMappable(object):
+         self._norm = norm
+         self._norm.callbacks.connect('changed', self.changed)
+ 
++    @norm.setter
++    def norm(self, norm):
++        """
++        Set the colormap normalization instance.
++
++        Parameters
++        ----------
++        norm : `.Normalize`
++        """
++        if norm is None:
++            norm = colors.Normalize()
++        self._norm = norm
++        if self._A is not None:
++            self.autoscale_None()
++        self.changed()
++
+     def set_clim(self, vmin=None, vmax=None):