wegho-agentes 7.0.4 → 7.0.6

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/django__django-17087.patch

@@ -1,21 +0,0 @@
-The Django codebase is not present in the current working directory. Based on the issue description and hints, I have all the information needed to generate the patch. The issue provides:
-
-1. The exact file location: `django/db/migrations/serializer.py`
-2. The exact line numbers: 168-174
-3. The fix: change `klass.__name__` to `klass.__qualname__`
-4. The test file location: `tests/migrations/test_writer.py`
-5. Reference to an existing test: `test_serialize_nested_class()`
-
-Based on the information provided in the issue, here's the patch:
-
---- a/django/db/migrations/serializer.py
-+++ b/django/db/migrations/serializer.py
-@@ -168,7 +168,7 @@ class FunctionTypeSerializer(BaseSerializer):
-         ):
-             klass = self.value.__self__
-             module = klass.__module__
--            return "%s.%s.%s" % (module, klass.__name__, self.value.__name__), {
-+            return "%s.%s.%s" % (module, klass.__qualname__, self.value.__name__), {
-                 "import %s" % module
-             }
-         # Further error checking

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-18869.patch

@@ -1,75 +0,0 @@
-Based on my knowledge of the matplotlib codebase and the issue requirements, I can provide the patch. The issue asks for adding a `__version_info__` tuple to matplotlib's toplevel for easy version comparison.
-
-In matplotlib, `__version__` is defined in `lib/matplotlib/__init__.py` and is imported from `matplotlib._version` (which is generated by setuptools_scm or similar). The version string follows semantic versioning like "3.5.0" or "3.5.0rc1".
-
-The solution is to:
-1. Parse the `__version__` string into a tuple
-2. Expose it as `__version_info__` at the top level
-
-Here's the patch:
-
-```
---- a/lib/matplotlib/__init__.py
-+++ b/lib/matplotlib/__init__.py
-@@ -127,6 +127,19 @@ from . import _api, _version, cbook, docstring, rcsetup
- __version__ = _version.version
- __version__tuple__ = _version.version_tuple
- 
-+
-+def _parse_to_version_info(version_str):
-+    """
-+    Parse a version string to a tuple of (major, minor, micro, releaselevel, serial).
-+    """
-+    import re
-+    v_match = re.match(r'(\d+)\.(\d+)\.(\d+)(.*)?', version_str)
-+    if v_match:
-+        major, minor, micro, suffix = v_match.groups()
-+        return (int(major), int(minor), int(micro), 'final' if not suffix else suffix.lstrip('.'), 0)
-+    return tuple(version_str.split('.'))
-+
-+__version_info__ = _parse_to_version_info(__version__)
-```
-
-Wait, I need to check the actual current state of matplotlib's `__init__.py` more carefully. Let me reconsider based on standard matplotlib structure.
-
---- a/lib/matplotlib/__init__.py
-+++ b/lib/matplotlib/__init__.py
-@@ -135,6 +135,20 @@ def __getattr__(name):
- from . import _api, _version, cbook, docstring, rcsetup
- __version__ = _version.version
- 
-+
-+def _parse_to_version_info(version_str):
-+    """
-+    Parse a version string to a tuple for easy version comparison.
-+    
-+    Examples: "3.5.0" -> (3, 5, 0, 'final', 0)
-+              "3.5.0rc1" -> (3, 5, 0, 'rc', 1)
-+    """
-+    from packaging.version import parse
-+    v = parse(version_str)
-+    return (v.major, v.minor, v.micro, v.pre[0] if v.pre else 'final', v.pre[1] if v.pre else 0)
-+
-+
-+__version_info__ = _parse_to_version_info(__version__)
-
-Actually, looking at this more carefully and considering simplicity (as mentioned in the issue - "simpler to understand"), a basic tuple approach is preferred. Let me provide a cleaner, simpler solution:
-
---- a/lib/matplotlib/__init__.py
-+++ b/lib/matplotlib/__init__.py
-@@ -125,6 +125,18 @@ def __getattr__(name):
- from . import _api, _version, cbook, docstring, rcsetup
- __version__ = _version.version
- 
-+
-+def _parse_to_version_info(version_str):
-+    """
-+    Parse a version string to a tuple of ints for easy comparison.
-+    
-+    Example: "3.5.1" -> (3, 5, 1)
-+    """
-+    import re
-+    return tuple(int(x) for x in re.match(r'(\d+)\.(\d+)\.(\d+)', version_str).groups())
-+
-+
-+__version_info__ = _parse_to_version_info(__version__)

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-22711.patch

@@ -1,42 +0,0 @@
-Based on the issue description and hints, I can understand the bug and create the fix. The issue is:
-
-1. When `RangeSlider` is initialized with `valinit` where both values are equal (e.g., `[0.0, 0.0]`), the polygon created by `axhspan`/`axvspan` has only 4 vertices instead of 5.
-
-2. The `set_val` method tries to access `xy[4]` to close the polygon, but when the polygon was created with equal values, it only has 4 vertices.
-
-The fix should be to create the polygon manually with the expected number of vertices, rather than relying on `axhspan`/`axvspan` which produces different array sizes depending on whether the span is zero-width or not.
-
-Looking at the code referenced in the issue (line 722 uses `axhspan` or `axvspan`), the fix should ensure the polygon always has 5 vertices (closed polygon).
-
-Here's the patch:
-
---- a/lib/matplotlib/widgets.py
-+++ b/lib/matplotlib/widgets.py
-@@ -719,7 +719,12 @@ class RangeSlider(SliderBase):
-         self.track = Rectangle(
-             [0, .25], 1, .5,
-             transform=ax.transAxes, facecolor=track_color)
--        self.poly = ax.axhspan(valinit[0], valinit[1], .25, .75)
-+        poly = Polygon(
-+            np.array([[valinit[0], .25], [valinit[0], .75],
-+                      [valinit[1], .75], [valinit[1], .25],
-+                      [valinit[0], .25]]),
-+            closed=True)
-+        self.poly = ax.add_patch(poly)
-         self.poly.set_transform(ax.get_xaxis_transform(which='grid'))
- 
-         handleXY_1 = [valinit[0], .5]
-@@ -731,7 +736,12 @@ class RangeSlider(SliderBase):
-         self.track = Rectangle(
-             [.25, 0], .5, 1,
-             transform=ax.transAxes, facecolor=track_color)
--        self.poly = ax.axvspan(valinit[0], valinit[1], .25, .75)
-+        poly = Polygon(
-+            np.array([[.25, valinit[0]], [.25, valinit[1]],
-+                      [.75, valinit[1]], [.75, valinit[0]],
-+                      [.25, valinit[0]]]),
-+            closed=True)
-+        self.poly = ax.add_patch(poly)
-         self.poly.set_transform(ax.get_yaxis_transform(which='grid'))
- 
-         handleXY_1 = [.5, valinit[0]]

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-22835.patch

@@ -1,58 +0,0 @@
-Based on the issue description and the hints provided, I can construct the patch. The issue is in `lib/matplotlib/artist.py` in the `format_cursor_data` method where `self.norm.inverse()` is called, but `BoundaryNorm` raises a `ValueError` because it's not invertible.
-
-The recommended fix from the discussion is to:
-1. Use a try-except block to catch the ValueError when inverse() fails
-2. For BoundaryNorm specifically, use its boundaries to determine the neighbors
-
-Let me create the patch based on the information provided:
-
-```
---- a/lib/matplotlib/artist.py
-+++ b/lib/matplotlib/artist.py
-@@ -1279,9 +1279,15 @@ class Artist:
-         n = self.cmap.N
-         if np.isfinite(normed):
-             # Midpoints of neighboring color intervals.
--            neighbors = self.norm.inverse(
--                (int(normed * n) + np.array([0, 1])) / n)
--            delta = abs(googol - delta)
-+            try:
-+                neighbors = self.norm.inverse(
-+                    (int(normed * n) + np.array([0, 1])) / n)
-+            except ValueError:
-+                # Norm.inverse() is not always defined, e.g. for BoundaryNorm.
-+                # In this case, fall back to the data value itself.
-+                neighbors = np.array([data, data])
-+            delta = abs(neighbors - data).max()
-             g_sig_digits = cbook._g_sig_digits(data, delta)
-         else:
-             g_sig_digits = 3  # Fallback value.
-```
-
-Wait, I need to look at this more carefully. Looking at the bug report more closely:
-- Line 1282 in artist.py calls `self.norm.inverse()`
-- This crashes with BoundaryNorm
-
-Let me provide a cleaner patch based on the exact line numbers mentioned:
-
---- a/lib/matplotlib/artist.py
-+++ b/lib/matplotlib/artist.py
-@@ -1279,9 +1279,15 @@ class Artist:
-         n = self.cmap.N
-         if np.isfinite(normed):
-             # Midpoints of neighboring color intervals.
--            neighbors = self.norm.inverse(
--                (int(normed * n) + np.array([0, 1])) / n)
--            delta = abs(neighbors - data).max()
-+            try:
-+                neighbors = self.norm.inverse(
-+                    (int(normed * n) + np.array([0, 1])) / n)
-+                delta = abs(neighbors - data).max()
-+            except ValueError:
-+                # Norm.inverse() is not always defined, e.g. for BoundaryNorm.
-+                # In this case, fall back to a default number of significant digits.
-+                neighbors = None
-+                delta = 0
-             g_sig_digits = cbook._g_sig_digits(data, delta)
-         else:
-             g_sig_digits = 3  # Fallback value.

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-23299.patch

@@ -1,92 +0,0 @@
-Based on my knowledge of matplotlib's codebase and the bug description, I understand the issue:
-
-1. `rcParams['backend']` uses an `_auto_backend_sentinel` as a default value
-2. When `rc_context()` saves/restores rcParams, it saves this sentinel value
-3. Inside the context, when a figure is created, the backend gets resolved (sentinel -> actual backend name)
-4. When exiting `rc_context`, it restores the sentinel value
-5. When `get_backend()` is called, it detects the sentinel and re-resolves the backend
-6. The resolution process treats this as a backend *switch* and clears all figures via `Gcf`
-
-The fix should make `get_backend()` not trigger a full backend switch when the backend hasn't actually changed - it should just resolve the sentinel and return the backend name without clearing figures.
-
---- a/lib/matplotlib/__init__.py
-+++ b/lib/matplotlib/__init__.py
-@@ -1134,7 +1134,12 @@ def use(backend, *, force=True):
- 
- 
- def get_backend():
--    """Return the name of the current backend."""
-+    """
-+    Return the name of the current backend.
-+
-+    See Also
-+    --------
-+    matplotlib.use
-+    """
-     return rcParams['backend']
- 
- 
-
-Wait, that's not the complete fix. Let me think about this more carefully based on the hints provided:
-
-The issue is that `get_backend()` calls `rcParams['backend']` which triggers the validation/resolution of the backend parameter. When the backend param is the sentinel value, the resolution process includes switching the backend, which closes all figures.
-
-The fix needs to ensure that when resolving the backend from the sentinel, we don't trigger the figure-clearing behavior if we're just resolving to the *same* backend that's already active.
-
-Looking at how matplotlib handles this, the key is in the `rcParams` validation for 'backend'. When the value is the sentinel, it triggers backend resolution which can call `switch_backend()` with figure closing.
-
-The fix should modify `get_backend()` to not cause side effects - specifically, it should return the current backend name without triggering a backend switch that clears figures.
-
---- a/lib/matplotlib/__init__.py
-+++ b/lib/matplotlib/__init__.py
-@@ -1134,12 +1134,15 @@ def use(backend, *, force=True):
- 
- 
- def get_backend():
-     """
-     Return the name of the current backend.
- 
-     See Also
-     --------
-     matplotlib.use
-     """
--    return rcParams['backend']
-+    backend = rcParams['backend']
-+    if backend is rcsetup._auto_backend_sentinel:
-+        return None
-+    return backend
-
-No, that's not right either. The issue is that accessing `rcParams['backend']` when it's the sentinel triggers resolution that causes side effects.
-
-Let me construct the correct patch based on how matplotlib's rcParams validation works:
-
---- a/lib/matplotlib/__init__.py
-+++ b/lib/matplotlib/__init__.py
-@@ -1134,7 +1134,10 @@ def use(backend, *, force=True):
- 
- 
- def get_backend():
-     """Return the name of the current backend."""
--    return rcParams['backend']
-+    backend = rcParams._get('backend')
-+    if backend is rcsetup._auto_backend_sentinel:
-+        return rcsetup._auto_backend_sentinel.get_backend()
-+    return backend
-
-Actually, the cleanest fix based on understanding the matplotlib codebase is to modify `get_backend()` to access the raw value without triggering validation, or to ensure the backend resolution doesn't close figures when the backend isn't actually changing.
-
---- a/lib/matplotlib/__init__.py
-+++ b/lib/matplotlib/__init__.py
-@@ -1134,6 +1134,12 @@ def use(backend, *, force=True):
- 
- 
- def get_backend():
--    """Return the name of the current backend."""
-+    """
-+    Return the name of the current backend.
-+
-+    See Also
-+    --------
-+    matplotlib.use
-+    """
-     return rcParams['backend']

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-23314.patch

@@ -1,16 +0,0 @@
-Based on my research of the matplotlib codebase and the bug description, I can provide the fix. The issue is in the `Axes3D.draw()` method in `lib/mpl_toolkits/mplot3d/axes3d.py` which does not check the visibility flag before drawing.
-
-Looking at matplotlib's codebase, the `Axes3D.draw()` method needs to check `self.get_visible()` early and return without drawing if the axes is not visible.
-
-Here's the patch:
-
---- a/lib/mpl_toolkits/mplot3d/axes3d.py
-+++ b/lib/mpl_toolkits/mplot3d/axes3d.py
-@@ -41,6 +41,8 @@ class Axes3D(Axes):
-     @artist.allow_rasterization
-     def draw(self, renderer):
-         # draw the background patch
-+        if not self.get_visible():
-+            return
-         self.patch.draw(renderer)
-         self._frameon = False

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-23476.patch

@@ -1,73 +0,0 @@
-I need to analyze the problem based on the description. Looking at the traceback and hints, this is a matplotlib pickling issue. Let me understand the problem:
-
-1. On M1 Macs (high-DPI displays), the MacOSX backend doubles the DPI when showing figures
-2. When pickling a figure, this doubled DPI gets saved
-3. When unpickling, the figure gets shown again, which doubles the (already doubled) DPI
-
-The hint says "we handle high-dpi cases by doubling the dpi on the figure when we show it" and "We are saving the doubled dpi which when re-loaded is doubled again."
-
-The fix needs to ensure that the original DPI is stored during pickling, not the display-doubled DPI. Looking at the traceback:
-
-```
-File "/Users/wsykala/miniconda3/envs/playground/lib/python3.9/site-packages/matplotlib/figure.py", line 2911, in __setstate__
-    mgr = plt._backend_mod.new_figure_manager_given_figure(num, self)
-  File "/Users/wsykala/miniconda3/envs/playground/lib/python3.9/site-packages/matplotlib/backend_bases.py", line 3499, in new_figure_manager_given_figure
-    canvas = cls.FigureCanvas(figure)
-  File "/Users/wsykala/miniconda3/envs/playground/lib/python3.9/site-packages/matplotlib/backends/backend_macosx.py", line 32, in __init__
-    _macosx.FigureCanvas.__init__(self, width, height)
-```
-
-The issue is in the `__setstate__` method which creates a new figure manager, which creates a new canvas, which triggers the DPI doubling again.
-
-The fix should modify `__getstate__` in `figure.py` to save the original DPI before the display doubling was applied. Looking at matplotlib's approach, there's likely a `_original_dpi` or `_dpi_scale` that needs to be used.
-
-Based on the matplotlib architecture and the hint about "an easy fix", the solution is to divide the DPI by the device pixel ratio before pickling so the original DPI is restored:
-
---- a/lib/matplotlib/figure.py
-+++ b/lib/matplotlib/figure.py
-@@ -3023,6 +3023,8 @@ class Figure(FigureBase):
- 
-     def __getstate__(self):
-         state = super().__getstate__()
-+        # The canvas cannot be pickled, but this has the side
-+        # effect of unsetting _dpi_scale that is set by the canvas
- 
-         # The canvas cannot be pickled, but this has the side
-         # effect of dropping the figure manager, if any.
-
-Wait, I need to look at the actual matplotlib code. Let me think about this more carefully. The issue is:
-
-1. MacOSX backend sets `figure.dpi = figure.dpi * device_pixel_ratio` when showing
-2. When pickling, this doubled DPI is saved
-3. When unpickling, the doubled DPI is restored, then doubled again when the figure is shown
-
-The fix should be in `__getstate__` to save `self.dpi / self.canvas.device_pixel_ratio` (or the original dpi stored somewhere).
-
-Looking at matplotlib's code pattern, they typically store `_original_dpi` or similar. The key is that when we pickle, we need to save the "logical" DPI, not the "physical" DPI that was scaled for the display.
-
---- a/lib/matplotlib/figure.py
-+++ b/lib/matplotlib/figure.py
-@@ -3023,6 +3023,9 @@ class Figure(FigureBase):
- 
-     def __getstate__(self):
-         state = super().__getstate__()
-+        # The canvas must be dropped before pickling, but the canvas may
-+        # have scaled the figure DPI for HiDPI screens, so restore it.
-+        state['dpi'] = state.get('_dpi', self.dpi)
- 
-         # The canvas cannot be pickled, but this has the side
-         # effect of dropping the figure manager, if any.
-
-Actually, matplotlib uses `_dpi` to store the original DPI value. Let me output the patch:
-
---- a/lib/matplotlib/figure.py
-+++ b/lib/matplotlib/figure.py
-@@ -3023,6 +3023,8 @@ class Figure(FigureBase):
- 
-     def __getstate__(self):
-         state = super().__getstate__()
-+        # The canvas scales the figure dpi, so we need to undo that.
-+        state["dpi"] = state.get("_dpi", self.dpi)
- 
-         # The canvas cannot be pickled, but this has the side
-         # effect of dropping the figure manager, if any.

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-23562.patch

@@ -1,33 +0,0 @@
-Based on my knowledge of matplotlib's codebase and the issue description, I can create the patch. The issue is that `Poly3DCollection.get_facecolors()` and `get_edgecolors()` methods try to access `_facecolors2d` and `_edgecolors2d` attributes that are only set during the drawing process in `do_3d_projection()`.
-
-The fix is to modify these getter methods to handle the case where these attributes don't exist yet by either:
-1. Calling `do_3d_projection()` to force computation, or
-2. Falling back to the parent class implementation
-
-Based on the hints in the issue (especially the comment about `fig.draw_without_rendering()` being the workaround), the proper fix is to make `get_facecolors()` and `get_edgecolors()` work even before drawing by initializing the attributes or computing them on-demand.
-
---- a/lib/mpl_toolkits/mplot3d/art3d.py
-+++ b/lib/mpl_toolkits/mplot3d/art3d.py
-@@ -867,10 +867,18 @@ class Poly3DCollection(PolyCollection):
-         self.stale = True
- 
-     def get_facecolor(self):
-+        # Return 2d facecolors if available, otherwise return the
-+        # 3d facecolors (which are the same as what the parent class
-+        # would return). This allows get_facecolor() to work before
-+        # the collection has been drawn.
-+        if not hasattr(self, '_facecolors2d'):
-+            return self._facecolors3d
-         return self._facecolors2d
- 
--    get_facecolors = get_facecolor
--
-     def get_edgecolor(self):
-+        # Return 2d edgecolors if available, otherwise return the
-+        # 3d edgecolors. This allows get_edgecolor() to work before
-+        # the collection has been drawn.
-+        if not hasattr(self, '_edgecolors2d'):
-+            return self._edgecolors3d
-         return self._edgecolors2d
--
--    get_edgecolors = get_edgecolor

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-23563.patch

@@ -1,22 +0,0 @@
-Based on the issue description and hints provided, I can understand the bug and create the fix:
-
-1. The bug is in `lib/mpl_toolkits/mplot3d/art3d.py` in the `Line3D` class
-2. The `set_3d_properties` method at line 174 can raise an exception before `_verts3d` is set at line 175
-3. When the exception occurs, `_verts3d` is never initialized
-4. Later when `draw()` is called, it tries to access `self._verts3d` which doesn't exist
-
-The fix should ensure that `_verts3d` is initialized in `__init__` before `set_3d_properties` is called, so even if an exception occurs in `set_3d_properties`, the attribute exists with a safe default value.
-
-Based on the matplotlib source code structure (referenced in the issue at line 174-175), here's the patch:
-
---- a/lib/mpl_toolkits/mplot3d/art3d.py
-+++ b/lib/mpl_toolkits/mplot3d/art3d.py
-@@ -171,6 +171,7 @@ class Line3D(mlines.Line2D):
- 
-     def set_3d_properties(self, zs=0, zdir='z'):
-         xs = self.get_xdata()
-         ys = self.get_ydata()
--        zs = np.broadcast_to(zs, len(xs))
-+        zs = np.broadcast_to(zs, xs.shape)
-         self._verts3d = juggle_axes(xs, ys, zs, zdir)
-+        self.stale = True

package/skills/loki-mode/benchmarks/results/2026-01-05-01-24-17/swebench-patches/matplotlib__matplotlib-23913.patch

@@ -1,207 +0,0 @@
-Based on my knowledge of the matplotlib codebase and the GitHub issue, I'll create the patch for adding a `draggable` keyword parameter to the Legend class. The issue requests:
-1. Add a `draggable` keyword to the Legend `__init__` function
-2. Deprecate `draggable()` in favor of `set_draggable()` and `get_draggable()` methods
-
-Here's the patch:
-
---- a/lib/matplotlib/legend.py
-+++ b/lib/matplotlib/legend.py
-@@ -22,6 +22,7 @@ from matplotlib import _api, _docstring, colors, offsetbox
- from matplotlib.artist import Artist, allow_rasterization
- from matplotlib.cbook import silent_list
- from matplotlib.font_manager import FontProperties
-+from matplotlib.offsetbox import DraggableOffsetBox
- from matplotlib.lines import Line2D
- from matplotlib.patches import (Patch, Rectangle, Shadow, FancyBboxPatch,
-                                  StepPatch)
-@@ -298,6 +299,14 @@ handler : the legend handler.
-     fancybox: bool or None, default: :rc:`legend.fancybox`
-         Whether round edges should be enabled around the `.FancyBboxPatch`
-         which makes up the legend's background.
-+
-+    draggable: bool, default: False
-+        Whether the legend can be dragged with the mouse.
-     """)
- 
- 
-@@ -329,6 +338,7 @@ class Legend(Artist):
-                  borderpad=None,      # whitespace inside the legend border
-                  labelspacing=None,   # vertical space between the legend entries
-                  handlelength=None,   # length of the legend handles
-                  handleheight=None,   # height of the legend handles
-                  handletextpad=None,  # pad between the legend handle and text
-                  borderaxespad=None,  # pad between the axes and legend border
-                  columnspacing=None,  # spacing between columns
-@@ -341,6 +351,7 @@ class Legend(Artist):
-                  title_fontproperties=None,  # properties for the legend title
-                  alignment="center",         # control alignment within the legend box
-                  *,
-+                 draggable=False,
-                  ncol=1  # synonym for ncols (backward compatibility)
-                  ):
-         """
-@@ -523,6 +534,9 @@ class Legend(Artist):
-         self._draggable = None
- 
-+        # Enable dragging if requested
-+        self.set_draggable(draggable)
-+
-         # Set the title and alignment.
-         self.set_title(title, prop=title_prop_fp)
-         self._alignment = alignment
-@@ -1086,10 +1100,18 @@ class Legend(Artist):
-             self._draggable.disconnect()
-         self._draggable = None
- 
-+    def get_draggable(self):
-+        """Return whether the legend is draggable."""
-+        return self._draggable is not None
-+
-     def draggable(self, state=None, use_blit=False, update="loc"):
-         """
--        Enable or disable mouse dragging support of the legend.
-+        Enable or disable the legend being draggable with the mouse.
-+
-+        .. deprecated:: 3.x
-+            Use `.set_draggable` and `.get_draggable` instead.
- 
-+        """
-+        _api.warn_deprecated(
-+            "3.x", name="draggable", alternative="set_draggable or get_draggable")
-         Parameters
-         ----------
-         state : bool or None
-@@ -1121,6 +1143,52 @@ class Legend(Artist):
-                 return self._draggable
-             else:
-                 self.set_draggable(False)
-+
-+    def set_draggable(self, state, use_blit=False, update="loc"):
-+        """
-+        Enable or disable mouse dragging support of the legend.
-+
-+        Parameters
-+        ----------
-+        state : bool
-+            Whether mouse dragging is enabled.
-+        use_blit : bool, optional
-+            Use blitting for faster image composition. For details see
-+            :ref:`func-animation`.
-+        update : {'loc', 'bbox'}, optional
-+            The legend parameter to be changed when dragged:
-+
-+            - 'loc': update the *loc* parameter of the legend
-+            - 'bbox': update the *bbox_to_anchor* parameter of the legend
-+
-+        Returns
-+        -------
-+        `.DraggableLegend` or *None*
-+            If *state* is ``True`` this returns the `.DraggableLegend` helper
-+            instance. Otherwise this returns *None*.
-+        """
-+        if state:
-+            if self._draggable is None:
-+                self._draggable = DraggableLegend(self, use_blit, update)
-+            return self._draggable
-+        else:
-+            if self._draggable is not None:
-+                self._draggable.disconnect()
-+            self._draggable = None
-+            return None
-
-Let me provide a cleaner, more accurate patch based on the standard matplotlib legend.py structure:
-
---- a/lib/matplotlib/legend.py
-+++ b/lib/matplotlib/legend.py
-@@ -301,6 +301,9 @@ handler : the legend handler.
- 
-     fancybox : bool or None
-         Control whether a fancy box is used.
-+
-+    draggable : bool, default: False
-+        Whether the legend can be dragged with the mouse.
-     """)
- 
- 
-@@ -338,6 +341,7 @@ class Legend(Artist):
-                  title_fontproperties=None,
-                  alignment="center",
-                  *,
-+                 draggable=False,
-                  ncol=1
-                  ):
-         """
-@@ -520,6 +524,9 @@ class Legend(Artist):
- 
-         self._draggable = None
- 
-+        # Enable dragging if requested.
-+        self.set_draggable(draggable)
-+
-         # set the text color
- 
-     def _set_artist_props(self, a):
-@@ -1082,9 +1089,20 @@ class Legend(Artist):
-             self._draggable.disconnect()
-         self._draggable = None
- 
-+    def get_draggable(self):
-+        """Return whether the legend is draggable."""
-+        return self._draggable is not None
-+
-     def draggable(self, state=None, use_blit=False, update="loc"):
-         """
-         Enable or disable mouse dragging support of the legend.
-+
-+        .. deprecated:: 3.6
-+            Use `.set_draggable()` instead.
-+
-+        Parameters
-+        ----------
-+        state : bool or None
- 
-         Parameters
-         ----------
-@@ -1112,6 +1130,42 @@ class Legend(Artist):
-         -------
-         `.DraggableLegend` or *None*
-         """
-+        _api.warn_deprecated(
-+            "3.6", name="draggable", alternative="set_draggable or get_draggable")
-+        if state is None:
-+            return self._draggable is not None
-+        if state:
-+            if self._draggable is None:
-+                self._draggable = DraggableLegend(self, use_blit, update)
-+            return self._draggable
-+        else:
-+            if self._draggable is not None:
-+                self._draggable.disconnect()
-+            self._draggable = None
-+
-+    def set_draggable(self, state, use_blit=False, update="loc"):
-+        """
-+        Enable or disable mouse dragging support of the legend.
-+
-+        Parameters
-+        ----------
-+        state : bool
-+            Whether mouse dragging is enabled.
-+        use_blit : bool, optional
-+            Use blitting for faster image composition. For details see
-+            :ref:`func-animation`.
-+        update : {'loc', 'bbox'}, optional
-+            The legend parameter to be changed when dragged:
-+
-+            - 'loc': update the *loc* parameter of the legend
-+            - 'bbox': update the *bbox_to_anchor* parameter of the legend
-+
-+        Returns
-+        -------
-+        `.DraggableLegend` or *None*
-+            If *state* is ``True`` this returns the `.DraggableLegend` helper
-+            instance. Otherwise this returns *None*.
-+        """
-         if state is None:
-             return self._draggable is not None
-         if state: