import functools

import io

import operator

from unittest import mock

import matplotlib as mpl

from matplotlib.backend_bases import DrawEvent, KeyEvent, MouseEvent

import matplotlib.colors as mcolors

import matplotlib.widgets as widgets

import matplotlib.pyplot as plt

from matplotlib.testing.decorators import check_figures_equal, image_comparison

from matplotlib.testing.widgets import click_and_drag, get_ax, noop

import numpy as np

from numpy.testing import assert_allclose

import pytest

@pytest.fixture

def ax():

return get_ax()

def test_save_blitted_widget_as_pdf():

from matplotlib.widgets import CheckButtons, RadioButtons

from matplotlib.cbook import _get_running_interactive_framework

if _get_running_interactive_framework() not in ['headless', None]:

pytest.xfail("Callback exceptions are not raised otherwise.")

fig, ax = plt.subplots(

nrows=2, ncols=2, figsize=(5, 2), width_ratios=[1, 2]

)

default_rb = RadioButtons(ax[0, 0], ['Apples', 'Oranges'])

styled_rb = RadioButtons(

ax[0, 1], ['Apples', 'Oranges'],

label_props={'color': ['red', 'orange'],

'fontsize': [16, 20]},

radio_props={'edgecolor': ['red', 'orange'],

'facecolor': ['mistyrose', 'peachpuff']}

)

default_cb = CheckButtons(ax[1, 0], ['Apples', 'Oranges'],

actives=[True, True])

styled_cb = CheckButtons(

ax[1, 1], ['Apples', 'Oranges'],

actives=[True, True],

label_props={'color': ['red', 'orange'],

'fontsize': [16, 20]},

frame_props={'edgecolor': ['red', 'orange'],

'facecolor': ['mistyrose', 'peachpuff']},

check_props={'color': ['darkred', 'darkorange']}

)

ax[0, 0].set_title('Default')

ax[0, 1].set_title('Stylized')

# force an Agg render

fig.canvas.draw()

# force a pdf save

with io.BytesIO() as result_after:

fig.savefig(result_after, format='pdf')

@pytest.mark.parametrize('kwargs', [

dict(),

dict(useblit=True, button=1),

dict(minspanx=10, minspany=10, spancoords='pixels'),

dict(props=dict(fill=True)),

])

def test_rectangle_selector(ax, kwargs):

onselect = mock.Mock(spec=noop, return_value=None)

tool = widgets.RectangleSelector(ax, onselect=onselect, **kwargs)

MouseEvent._from_ax_coords("button_press_event", ax, (100, 100), 1)._process()

MouseEvent._from_ax_coords("motion_notify_event", ax, (199, 199), 1)._process()

# purposely drag outside of axis for release

MouseEvent._from_ax_coords("button_release_event", ax, (250, 250), 1)._process()

if kwargs.get('drawtype', None) not in ['line', 'none']:

assert_allclose(tool.geometry,

[[100., 100, 199, 199, 100],

[100, 199, 199, 100, 100]],

err_msg=tool.geometry)

onselect.assert_called_once()

(epress, erelease), kwargs = onselect.call_args

assert epress.xdata == 100

assert epress.ydata == 100

assert erelease.xdata == 199

assert erelease.ydata == 199

assert kwargs == {}

@pytest.mark.parametrize('spancoords', ['data', 'pixels'])

@pytest.mark.parametrize('minspanx, x1', [[0, 10], [1, 10.5], [1, 11]])

@pytest.mark.parametrize('minspany, y1', [[0, 10], [1, 10.5], [1, 11]])

def test_rectangle_minspan(ax, spancoords, minspanx, x1, minspany, y1):

onselect = mock.Mock(spec=noop, return_value=None)

x0, y0 = (10, 10)

if spancoords == 'pixels':

minspanx, minspany = (ax.transData.transform((x1, y1)) -

ax.transData.transform((x0, y0)))

tool = widgets.RectangleSelector(ax, onselect=onselect, interactive=True,

spancoords=spancoords,

minspanx=minspanx, minspany=minspany)

# Too small to create a selector

click_and_drag(tool, start=(x0, x1), end=(y0, y1))

assert not tool._selection_completed

onselect.assert_not_called()

click_and_drag(tool, start=(20, 20), end=(30, 30))

assert tool._selection_completed

onselect.assert_called_once()

# Too small to create a selector. Should clear existing selector, and

# trigger onselect because there was a preexisting selector

onselect.reset_mock()

click_and_drag(tool, start=(x0, y0), end=(x1, y1))

assert not tool._selection_completed

onselect.assert_called_once()

(epress, erelease), kwargs = onselect.call_args

assert epress.xdata == x0

assert epress.ydata == y0

assert erelease.xdata == x1

assert erelease.ydata == y1

assert kwargs == {}

@pytest.mark.parametrize('drag_from_anywhere, new_center',

[[True, (60, 75)],

[False, (30, 20)]])

def test_rectangle_drag(ax, drag_from_anywhere, new_center):

tool = widgets.RectangleSelector(ax, interactive=True,

drag_from_anywhere=drag_from_anywhere)

# Create rectangle

click_and_drag(tool, start=(10, 10), end=(90, 120))

assert tool.center == (50, 65)

# Drag inside rectangle, but away from centre handle

#

# If drag_from_anywhere == True, this will move the rectangle by (10, 10),

# giving it a new center of (60, 75)

#

# If drag_from_anywhere == False, this will create a new rectangle with

# center (30, 20)

click_and_drag(tool, start=(25, 15), end=(35, 25))

assert tool.center == new_center

# Check that in both cases, dragging outside the rectangle draws a new

# rectangle

click_and_drag(tool, start=(175, 185), end=(185, 195))

assert tool.center == (180, 190)

def test_rectangle_selector_set_props_handle_props(ax):

tool = widgets.RectangleSelector(ax, interactive=True,

props=dict(facecolor='b', alpha=0.2),

handle_props=dict(alpha=0.5))

# Create rectangle

click_and_drag(tool, start=(0, 10), end=(100, 120))

artist = tool._selection_artist

assert artist.get_facecolor() == mcolors.to_rgba('b', alpha=0.2)

tool.set_props(facecolor='r', alpha=0.3)

assert artist.get_facecolor() == mcolors.to_rgba('r', alpha=0.3)

for artist in tool._handles_artists:

assert artist.get_markeredgecolor() == 'black'

assert artist.get_alpha() == 0.5

tool.set_handle_props(markeredgecolor='r', alpha=0.3)

for artist in tool._handles_artists:

assert artist.get_markeredgecolor() == 'r'

assert artist.get_alpha() == 0.3

def test_rectangle_resize(ax):

tool = widgets.RectangleSelector(ax, interactive=True)

# Create rectangle

click_and_drag(tool, start=(10, 10), end=(100, 120))

assert tool.extents == (10.0, 100.0, 10.0, 120.0)

# resize NE handle

extents = tool.extents

xdata, ydata = extents[1], extents[3]

xdata_new, ydata_new = xdata + 10, ydata + 5

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert tool.extents == (extents[0], xdata_new, extents[2], ydata_new)

# resize E handle

extents = tool.extents

xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2

xdata_new, ydata_new = xdata + 10, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert tool.extents == (extents[0], xdata_new, extents[2], extents[3])

# resize W handle

extents = tool.extents

xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2

xdata_new, ydata_new = xdata + 15, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert tool.extents == (xdata_new, extents[1], extents[2], extents[3])

# resize SW handle

extents = tool.extents

xdata, ydata = extents[0], extents[2]

xdata_new, ydata_new = xdata + 20, ydata + 25

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert tool.extents == (xdata_new, extents[1], ydata_new, extents[3])

def test_rectangle_add_state(ax):

tool = widgets.RectangleSelector(ax, interactive=True)

# Create rectangle

click_and_drag(tool, start=(70, 65), end=(125, 130))

with pytest.raises(ValueError):

tool.add_state('unsupported_state')

with pytest.raises(ValueError):

tool.add_state('clear')

tool.add_state('move')

tool.add_state('square')

tool.add_state('center')

@pytest.mark.parametrize('add_state', [True, False])

def test_rectangle_resize_center(ax, add_state):

tool = widgets.RectangleSelector(ax, interactive=True)

# Create rectangle

click_and_drag(tool, start=(70, 65), end=(125, 130))

assert tool.extents == (70.0, 125.0, 65.0, 130.0)

if add_state:

tool.add_state('center')

use_key = None

else:

use_key = 'control'

# resize NE handle

extents = tool.extents

xdata, ydata = extents[1], extents[3]

xdiff, ydiff = 10, 5

xdata_new, ydata_new = xdata + xdiff, ydata + ydiff

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (extents[0] - xdiff, xdata_new,

extents[2] - ydiff, ydata_new)

# resize E handle

extents = tool.extents

xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2

xdiff = 10

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (extents[0] - xdiff, xdata_new,

extents[2], extents[3])

# resize E handle negative diff

extents = tool.extents

xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2

xdiff = -20

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (extents[0] - xdiff, xdata_new,

extents[2], extents[3])

# resize W handle

extents = tool.extents

xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2

xdiff = 15

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (xdata_new, extents[1] - xdiff,

extents[2], extents[3])

# resize W handle negative diff

extents = tool.extents

xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2

xdiff = -25

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (xdata_new, extents[1] - xdiff,

extents[2], extents[3])

# resize SW handle

extents = tool.extents

xdata, ydata = extents[0], extents[2]

xdiff, ydiff = 20, 25

xdata_new, ydata_new = xdata + xdiff, ydata + ydiff

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (xdata_new, extents[1] - xdiff,

ydata_new, extents[3] - ydiff)

@pytest.mark.parametrize('add_state', [True, False])

def test_rectangle_resize_square(ax, add_state):

tool = widgets.RectangleSelector(ax, interactive=True)

# Create rectangle

click_and_drag(tool, start=(70, 65), end=(120, 115))

assert tool.extents == (70.0, 120.0, 65.0, 115.0)

if add_state:

tool.add_state('square')

use_key = None

else:

use_key = 'shift'

# resize NE handle

extents = tool.extents

xdata, ydata = extents[1], extents[3]

xdiff, ydiff = 10, 5

xdata_new, ydata_new = xdata + xdiff, ydata + ydiff

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (extents[0], xdata_new,

extents[2], extents[3] + xdiff)

# resize E handle

extents = tool.extents

xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2

xdiff = 10

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (extents[0], xdata_new,

extents[2], extents[3] + xdiff)

# resize E handle negative diff

extents = tool.extents

xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2

xdiff = -20

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (extents[0], xdata_new,

extents[2], extents[3] + xdiff)

# resize W handle

extents = tool.extents

xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2

xdiff = 15

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (xdata_new, extents[1],

extents[2], extents[3] - xdiff)

# resize W handle negative diff

extents = tool.extents

xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2

xdiff = -25

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (xdata_new, extents[1],

extents[2], extents[3] - xdiff)

# resize SW handle

extents = tool.extents

xdata, ydata = extents[0], extents[2]

xdiff, ydiff = 20, 25

xdata_new, ydata_new = xdata + xdiff, ydata + ydiff

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new),

key=use_key)

assert tool.extents == (extents[0] + ydiff, extents[1],

ydata_new, extents[3])

def test_rectangle_resize_square_center(ax):

tool = widgets.RectangleSelector(ax, interactive=True)

# Create rectangle

click_and_drag(tool, start=(70, 65), end=(120, 115))

tool.add_state('square')

tool.add_state('center')

assert_allclose(tool.extents, (70.0, 120.0, 65.0, 115.0))

# resize NE handle

extents = tool.extents

xdata, ydata = extents[1], extents[3]

xdiff, ydiff = 10, 5

xdata_new, ydata_new = xdata + xdiff, ydata + ydiff

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert_allclose(tool.extents, (extents[0] - xdiff, xdata_new,

extents[2] - xdiff, extents[3] + xdiff))

# resize E handle

extents = tool.extents

xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2

xdiff = 10

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert_allclose(tool.extents, (extents[0] - xdiff, xdata_new,

extents[2] - xdiff, extents[3] + xdiff))

# resize E handle negative diff

extents = tool.extents

xdata, ydata = extents[1], extents[2] + (extents[3] - extents[2]) / 2

xdiff = -20

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert_allclose(tool.extents, (extents[0] - xdiff, xdata_new,

extents[2] - xdiff, extents[3] + xdiff))

# resize W handle

extents = tool.extents

xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2

xdiff = 5

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert_allclose(tool.extents, (xdata_new, extents[1] - xdiff,

extents[2] + xdiff, extents[3] - xdiff))

# resize W handle negative diff

extents = tool.extents

xdata, ydata = extents[0], extents[2] + (extents[3] - extents[2]) / 2

xdiff = -25

xdata_new, ydata_new = xdata + xdiff, ydata

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert_allclose(tool.extents, (xdata_new, extents[1] - xdiff,

extents[2] + xdiff, extents[3] - xdiff))

# resize SW handle

extents = tool.extents

xdata, ydata = extents[0], extents[2]

xdiff, ydiff = 20, 25

xdata_new, ydata_new = xdata + xdiff, ydata + ydiff

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert_allclose(tool.extents, (extents[0] + ydiff, extents[1] - ydiff,

ydata_new, extents[3] - ydiff))

@pytest.mark.parametrize('selector_class',

[widgets.RectangleSelector, widgets.EllipseSelector])

def test_rectangle_rotate(ax, selector_class):

tool = selector_class(ax, interactive=True)

# Draw rectangle

click_and_drag(tool, start=(100, 100), end=(130, 140))

assert tool.extents == (100, 130, 100, 140)

assert len(tool._state) == 0

# Rotate anticlockwise using top-right corner

KeyEvent("key_press_event", ax.figure.canvas, "r")._process()

assert tool._state == {'rotate'}

assert len(tool._state) == 1

click_and_drag(tool, start=(130, 140), end=(120, 145))

KeyEvent("key_press_event", ax.figure.canvas, "r")._process()

assert len(tool._state) == 0

# Extents shouldn't change (as shape of rectangle hasn't changed)

assert tool.extents == (100, 130, 100, 140)

assert_allclose(tool.rotation, 25.56, atol=0.01)

tool.rotation = 45

assert tool.rotation == 45

# Corners should move

assert_allclose(tool.corners,

np.array([[118.53, 139.75, 111.46, 90.25],

[95.25, 116.46, 144.75, 123.54]]), atol=0.01)

# Scale using top-right corner

click_and_drag(tool, start=(110, 145), end=(110, 160))

assert_allclose(tool.extents, (100, 139.75, 100, 151.82), atol=0.01)

if selector_class == widgets.RectangleSelector:

with pytest.raises(ValueError):

tool._selection_artist.rotation_point = 'unvalid_value'

def test_rectangle_add_remove_set(ax):

tool = widgets.RectangleSelector(ax, interactive=True)

# Draw rectangle

click_and_drag(tool, start=(100, 100), end=(130, 140))

assert tool.extents == (100, 130, 100, 140)

assert len(tool._state) == 0

for state in ['rotate', 'square', 'center']:

tool.add_state(state)

assert len(tool._state) == 1

tool.remove_state(state)

assert len(tool._state) == 0

@pytest.mark.parametrize('use_data_coordinates', [False, True])

def test_rectangle_resize_square_center_aspect(ax, use_data_coordinates):

ax.set_aspect(0.8)

tool = widgets.RectangleSelector(ax, interactive=True,

use_data_coordinates=use_data_coordinates)

# Create rectangle

click_and_drag(tool, start=(70, 65), end=(120, 115))

assert tool.extents == (70.0, 120.0, 65.0, 115.0)

tool.add_state('square')

tool.add_state('center')

if use_data_coordinates:

# resize E handle

extents = tool.extents

xdata, ydata, width = extents[1], extents[3], extents[1] - extents[0]

xdiff, ycenter = 10, extents[2] + (extents[3] - extents[2]) / 2

xdata_new, ydata_new = xdata + xdiff, ydata

ychange = width / 2 + xdiff

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert_allclose(tool.extents, [extents[0] - xdiff, xdata_new,

ycenter - ychange, ycenter + ychange])

else:

# resize E handle

extents = tool.extents

xdata, ydata = extents[1], extents[3]

xdiff = 10

xdata_new, ydata_new = xdata + xdiff, ydata

ychange = xdiff * 1 / tool._aspect_ratio_correction

click_and_drag(tool, start=(xdata, ydata), end=(xdata_new, ydata_new))

assert_allclose(tool.extents, [extents[0] - xdiff, xdata_new,

46.25, 133.75])

def test_axeswidget_del_on_failed_init():

"""

Test that an unraisable exception is not created when initialization

fails.

"""

# Pytest would fail the test if such an exception occurred.

fig, ax = plt.subplots()

with pytest.raises(TypeError, match="unexpected keyword argument 'undefined'"):

widgets.Button(ax, undefined='bar')

def test_ellipse(ax):

"""For ellipse, test out the key modifiers"""

tool = widgets.EllipseSelector(ax, grab_range=10, interactive=True)

tool.extents = (100, 150, 100, 150)

# drag the rectangle

click_and_drag(tool, start=(125, 125), end=(145, 145))

assert tool.extents == (120, 170, 120, 170)

# create from center

click_and_drag(tool, start=(100, 100), end=(125, 125), key='control')

assert tool.extents == (75, 125, 75, 125)

# create a square

click_and_drag(tool, start=(10, 10), end=(35, 30), key='shift')

extents = [int(e) for e in tool.extents]

assert extents == [10, 35, 10, 35]

# create a square from center

click_and_drag(tool, start=(100, 100), end=(125, 130), key='ctrl+shift')

extents = [int(e) for e in tool.extents]

assert extents == [70, 130, 70, 130]

assert tool.geometry.shape == (2, 73)

assert_allclose(tool.geometry[:, 0], [70., 100])

def test_rectangle_handles(ax):

tool = widgets.RectangleSelector(ax, grab_range=10, interactive=True,

handle_props={'markerfacecolor': 'r',

'markeredgecolor': 'b'})

tool.extents = (100, 150, 100, 150)

assert_allclose(tool.corners, ((100, 150, 150, 100), (100, 100, 150, 150)))

assert tool.extents == (100, 150, 100, 150)

assert_allclose(tool.edge_centers,

((100, 125.0, 150, 125.0), (125.0, 100, 125.0, 150)))

assert tool.extents == (100, 150, 100, 150)

# grab a corner and move it

click_and_drag(tool, start=(100, 100), end=(120, 120))

assert tool.extents == (120, 150, 120, 150)

# grab the center and move it

click_and_drag(tool, start=(132, 132), end=(120, 120))

assert tool.extents == (108, 138, 108, 138)

# create a new rectangle

click_and_drag(tool, start=(10, 10), end=(100, 100))

assert tool.extents == (10, 100, 10, 100)

# Check that marker_props worked.

assert mcolors.same_color(

tool._corner_handles.artists[0].get_markerfacecolor(), 'r')

assert mcolors.same_color(

tool._corner_handles.artists[0].get_markeredgecolor(), 'b')

@pytest.mark.parametrize('interactive', [True, False])

def test_rectangle_selector_onselect(ax, interactive):

# check when press and release events take place at the same position

onselect = mock.Mock(spec=noop, return_value=None)

tool = widgets.RectangleSelector(ax, onselect=onselect, interactive=interactive)

# move outside of axis

click_and_drag(tool, start=(100, 110), end=(150, 120))

onselect.assert_called_once()

assert tool.extents == (100.0, 150.0, 110.0, 120.0)

onselect.reset_mock()

click_and_drag(tool, start=(10, 100), end=(10, 100))

onselect.assert_called_once()

@pytest.mark.parametrize('ignore_event_outside', [True, False])

def test_rectangle_selector_ignore_outside(ax, ignore_event_outside):

onselect = mock.Mock(spec=noop, return_value=None)

tool = widgets.RectangleSelector(ax, onselect=onselect,

ignore_event_outside=ignore_event_outside)

click_and_drag(tool, start=(100, 110), end=(150, 120))

onselect.assert_called_once()

assert tool.extents == (100.0, 150.0, 110.0, 120.0)

onselect.reset_mock()

# Trigger event outside of span

click_and_drag(tool, start=(150, 150), end=(160, 160))

if ignore_event_outside:

# event have been ignored and span haven't changed.

onselect.assert_not_called()

assert tool.extents == (100.0, 150.0, 110.0, 120.0)

else:

# A new shape is created

onselect.assert_called_once()

assert tool.extents == (150.0, 160.0, 150.0, 160.0)

@pytest.mark.parametrize('orientation, onmove_callback, kwargs', [

('horizontal', False, dict(minspan=10, useblit=True)),

('vertical', True, dict(button=1)),

('horizontal', False, dict(props=dict(fill=True))),

('horizontal', False, dict(interactive=True)),

])

def test_span_selector(ax, orientation, onmove_callback, kwargs):

# Also test that span selectors work in the presence of twin axes or for

# outside-inset axes on top of the axes that contain the selector. Note

# that we need to unforce the axes aspect here, otherwise the twin axes

# forces the original axes' limits (to respect aspect=1) which makes some

# of the values below go out of bounds.

ax.set_aspect("auto")

ax.twinx()

child = ax.inset_axes([0, 1, 1, 1], xlim=(0, 200), ylim=(0, 200))

for target in [ax, child]:

selected = []

def onselect(*args): selected.append(args)

moved = []

def onmove(*args): moved.append(args)

if onmove_callback:

kwargs['onmove_callback'] = onmove

tool = widgets.SpanSelector(target, onselect, orientation, **kwargs)

MouseEvent._from_ax_coords(

"button_press_event", target, (100, 100), 1)._process()

# move outside of axis

MouseEvent._from_ax_coords(

"motion_notify_event", target, (199, 199), 1)._process()

MouseEvent._from_ax_coords(

"button_release_event", target, (250, 250), 1)._process()

# tol is set by pixel size (~100 pixels & span of 200 data units)

assert_allclose(selected, [(100, 199)], atol=.5)

if onmove_callback:

assert_allclose(moved, [(100, 199)], atol=.5)

@pytest.mark.parametrize('interactive', [True, False])

def test_span_selector_onselect(ax, interactive):

onselect = mock.Mock(spec=noop, return_value=None)

tool = widgets.SpanSelector(ax, onselect, 'horizontal',

interactive=interactive)

# move outside of axis

click_and_drag(tool, start=(100, 100), end=(150, 100))

onselect.assert_called_once()

assert tool.extents == (100, 150)

onselect.reset_mock()

click_and_drag(tool, start=(10, 100), end=(10, 100))

onselect.assert_called_once()

@pytest.mark.parametrize('ignore_event_outside', [True, False])

def test_span_selector_ignore_outside(ax, ignore_event_outside):

onselect = mock.Mock(spec=noop, return_value=None)

onmove = mock.Mock(spec=noop, return_value=None)

tool = widgets.SpanSelector(ax, onselect, 'horizontal',

onmove_callback=onmove,

ignore_event_outside=ignore_event_outside)

click_and_drag(tool, start=(100, 100), end=(125, 125))

onselect.assert_called_once()

onmove.assert_called_once()

assert tool.extents == (100, 125)

onselect.reset_mock()

onmove.reset_mock()

# Trigger event outside of span

click_and_drag(tool, start=(150, 150), end=(160, 160))

if ignore_event_outside:

# event have been ignored and span haven't changed.

onselect.assert_not_called()

onmove.assert_not_called()

assert tool.extents == (100, 125)

else:

# A new shape is created

onselect.assert_called_once()

onmove.assert_called_once()

assert tool.extents == (150, 160)

@pytest.mark.parametrize('drag_from_anywhere', [True, False])

def test_span_selector_drag(ax, drag_from_anywhere):

# Create span

tool = widgets.SpanSelector(ax, onselect=noop, direction='horizontal',

interactive=True,

drag_from_anywhere=drag_from_anywhere)

click_and_drag(tool, start=(10, 10), end=(100, 120))

assert tool.extents == (10, 100)

# Drag inside span

#

# If drag_from_anywhere == True, this will move the span by 10,

# giving new value extents = 20, 110

#

# If drag_from_anywhere == False, this will create a new span with

# value extents = 25, 35

click_and_drag(tool, start=(25, 15), end=(35, 25))

if drag_from_anywhere:

assert tool.extents == (20, 110)

else:

assert tool.extents == (25, 35)

# Check that in both cases, dragging outside the span draws a new span

click_and_drag(tool, start=(175, 185), end=(185, 195))

assert tool.extents == (175, 185)

def test_span_selector_direction(ax):

tool = widgets.SpanSelector(ax, onselect=noop, direction='horizontal',

interactive=True)

assert tool.direction == 'horizontal'

assert tool._edge_handles.direction == 'horizontal'

with pytest.raises(ValueError):

tool = widgets.SpanSelector(ax, onselect=noop,

direction='invalid_direction')

tool.direction = 'vertical'

assert tool.direction == 'vertical'

assert tool._edge_handles.direction == 'vertical'

with pytest.raises(ValueError):

tool.direction = 'invalid_string'

def test_span_selector_set_props_handle_props(ax):

tool = widgets.SpanSelector(ax, onselect=noop, direction='horizontal',

interactive=True,

props=dict(facecolor='b', alpha=0.2),

handle_props=dict(alpha=0.5))

# Create rectangle

click_and_drag(tool, start=(0, 10), end=(100, 120))

artist = tool._selection_artist

assert artist.get_facecolor() == mcolors.to_rgba('b', alpha=0.2)

tool.set_props(facecolor='r', alpha=0.3)

assert artist.get_facecolor() == mcolors.to_rgba('r', alpha=0.3)

for artist in tool._handles_artists:

assert artist.get_color() == 'b'

assert artist.get_alpha() == 0.5

tool.set_handle_props(color='r', alpha=0.3)

for artist in tool._handles_artists:

assert artist.get_color() == 'r'

assert artist.get_alpha() == 0.3

@pytest.mark.parametrize('selector', ['span', 'rectangle'])

def test_selector_clear(ax, selector):

kwargs = dict(ax=ax, interactive=True)

if selector == 'span':

Selector = widgets.SpanSelector

kwargs['direction'] = 'horizontal'

kwargs['onselect'] = noop

else:

Selector = widgets.RectangleSelector

tool = Selector(**kwargs)

click_and_drag(tool, start=(10, 10), end=(100, 120))

# press-release event outside the selector to clear the selector

click_and_drag(tool, start=(130, 130), end=(130, 130))

assert not tool._selection_completed

kwargs['ignore_event_outside'] = True

tool = Selector(**kwargs)

assert tool.ignore_event_outside

click_and_drag(tool, start=(10, 10), end=(100, 120))

# press-release event outside the selector ignored

click_and_drag(tool, start=(130, 130), end=(130, 130))

assert tool._selection_completed

KeyEvent("key_press_event", ax.figure.canvas, "escape")._process()

assert not tool._selection_completed

@pytest.mark.parametrize('selector', ['span', 'rectangle'])

def test_selector_clear_method(ax, selector):

if selector == 'span':

tool = widgets.SpanSelector(ax, onselect=noop, direction='horizontal',

interactive=True,

ignore_event_outside=True)

else:

tool = widgets.RectangleSelector(ax, interactive=True)

click_and_drag(tool, start=(10, 10), end=(100, 120))

assert tool._selection_completed

assert tool.get_visible()

if selector == 'span':

assert tool.extents == (10, 100)

tool.clear()

assert not tool._selection_completed

assert not tool.get_visible()

# Do another cycle of events to make sure we can

click_and_drag(tool, start=(10, 10), end=(50, 120))

assert tool._selection_completed

assert tool.get_visible()

if selector == 'span':

assert tool.extents == (10, 50)

def test_span_selector_add_state(ax):

tool = widgets.SpanSelector(ax, noop, 'horizontal',

interactive=True)

with pytest.raises(ValueError):

tool.add_state('unsupported_state')

with pytest.raises(ValueError):

tool.add_state('center')

with pytest.raises(ValueError):

tool.add_state('square')

tool.add_state('move')

def test_tool_line_handle(ax):

positions = [20, 30, 50]

tool_line_handle = widgets.ToolLineHandles(ax, positions, 'horizontal',

useblit=False)

for artist in tool_line_handle.artists:

assert not artist.get_animated()

assert not artist.get_visible()

tool_line_handle.set_visible(True)

tool_line_handle.set_animated(True)

for artist in tool_line_handle.artists:

assert artist.get_animated()

assert artist.get_visible()

assert tool_line_handle.positions == positions

@pytest.mark.parametrize('direction', ("horizontal", "vertical"))

def test_span_selector_bound(direction):

fig, ax = plt.subplots(1, 1)

ax.plot([10, 20], [10, 30])

fig.canvas.draw()

x_bound = ax.get_xbound()

y_bound = ax.get_ybound()

tool = widgets.SpanSelector(ax, print, direction, interactive=True)

assert ax.get_xbound() == x_bound

assert ax.get_ybound() == y_bound

bound = x_bound if direction == 'horizontal' else y_bound

assert tool._edge_handles.positions == list(bound)

press_data = (10.5, 11.5)

move_data = (11, 13) # Updating selector is done in onmove

release_data = move_data

click_and_drag(tool, start=press_data, end=move_data)

assert ax.get_xbound() == x_bound

assert ax.get_ybound() == y_bound

index = 0 if direction == 'horizontal' else 1

handle_positions = [press_data[index], release_data[index]]

assert tool._edge_handles.positions == handle_positions

@pytest.mark.backend('QtAgg', skip_on_importerror=True)

def test_span_selector_animated_artists_callback():

"""Check that the animated artists changed in callbacks are updated."""

x = np.linspace(0, 2 * np.pi, 100)

values = np.sin(x)

fig, ax = plt.subplots()

ln, = ax.plot(x, values, animated=True)

ln2, = ax.plot([], animated=True)

# spin the event loop to let the backend process any pending operations

# before drawing artists

# See blitting tutorial

plt.pause(0.1)

ax.draw_artist(ln)

fig.canvas.blit(fig.bbox)

def mean(vmin, vmax):

# Return mean of values in x between *vmin* and *vmax*

indmin, indmax = np.searchsorted(x, (vmin, vmax))

v = values[indmin:indmax].mean()

ln2.set_data(x, np.full_like(x, v))

span = widgets.SpanSelector(ax, mean, direction='horizontal',

onmove_callback=mean,

interactive=True,

drag_from_anywhere=True,

useblit=True)

# Add span selector and check that the line is draw after it was updated

# by the callback

MouseEvent._from_ax_coords("button_press_event", ax, (1, 2), 1)._process()

MouseEvent._from_ax_coords("motion_notify_event", ax, (2, 2), 1)._process()

assert span._get_animated_artists() == (ln, ln2)

assert ln.stale is False

assert ln2.stale

assert_allclose(ln2.get_ydata(), 0.9547335049088455)

span.update()

assert ln2.stale is False

# Change span selector and check that the line is drawn/updated after its

# value was updated by the callback

MouseEvent._from_ax_coords("button_press_event", ax, (4, 0), 1)._process()

MouseEvent._from_ax_coords("motion_notify_event", ax, (5, 2), 1)._process()

assert ln.stale is False

assert ln2.stale

assert_allclose(ln2.get_ydata(), -0.9424150707548072)

MouseEvent._from_ax_coords("button_release_event", ax, (5, 2), 1)._process()

assert ln2.stale is False

def test_snapping_values_span_selector(ax):

def onselect(*args):

pass

tool = widgets.SpanSelector(ax, onselect, direction='horizontal',)

snap_function = tool._snap

snap_values = np.linspace(0, 5, 11)

values = np.array([-0.1, 0.1, 0.2, 0.5, 0.6, 0.7, 0.9, 4.76, 5.0, 5.5])

expect = np.array([00.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 5.00, 5.0, 5.0])

values = snap_function(values, snap_values)

assert_allclose(values, expect)

def test_span_selector_snap(ax):

def onselect(vmin, vmax):

ax._got_onselect = True

snap_values = np.arange(50) * 4

tool = widgets.SpanSelector(ax, onselect, direction='horizontal',

snap_values=snap_values)

tool.extents = (17, 35)

assert tool.extents == (16, 36)

tool.snap_values = None

assert tool.snap_values is None

tool.extents = (17, 35)

assert tool.extents == (17, 35)

def test_span_selector_extents(ax):

tool = widgets.SpanSelector(

ax, lambda a, b: None, "horizontal", ignore_event_outside=True

)

tool.extents = (5, 10)

assert tool.extents == (5, 10)

assert tool._selection_completed

# Since `ignore_event_outside=True`, this event should be ignored

press_data = (12, 14)

release_data = (20, 14)

click_and_drag(tool, start=press_data, end=release_data)

assert tool.extents == (5, 10)

@pytest.mark.parametrize('kwargs', [

dict(),

dict(useblit=False, props=dict(color='red')),

dict(useblit=True, button=1),

])

def test_lasso_selector(ax, kwargs):