vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/app/tests/test_backends.py

@@ -0,0 +1,164 @@
+"""Tests to quickly see if the backends look good.
+This tests only to see if all the necessary methods are implemented,
+whether all the right events are mentioned, and whether the keymap
+contains all keys that should be supported.
+
+This test basically checks whether nothing was forgotten, not that the
+implementation is corect.
+
+"""
+
+import vispy
+from vispy import keys
+from vispy.testing import (requires_application, assert_in, run_tests_if_main,
+                           assert_raises)
+from vispy.app import use_app, Application
+from vispy.app.backends import _template
+from vispy.util import _get_args
+
+
+class DummyApplication(Application):
+    def _use(self, backend_namd):
+        pass
+
+
+def _test_module_properties(_module=None):
+    """Test application module"""
+    if _module is None:
+        app = use_app()
+        _module = app.backend_module
+
+    # Test that the keymap contains all keys supported by vispy.
+    module_fname = _module.__name__.split('.')[-1]
+    if module_fname not in ('_egl', '_osmesa'):  # skip keys for EGL, osmesa
+        keymap = _module.KEYMAP
+        vispy_keys = keymap.values()
+        for keyname in dir(keys):
+            if keyname.upper() != keyname:
+                continue
+            key = getattr(keys, keyname)
+            assert_in(key, vispy_keys)
+
+    # For Qt backend, we have a common implementation
+    alt_modname = ''
+    if module_fname in ('_pyside', '_pyqt4', '_pyqt5', '_pyqt6', '_pyside2', '_pyside6'):
+        alt_modname = _module.__name__.rsplit('.', 1)[0] + '._qt'
+
+    # Test that all _vispy_x methods are there.
+    exceptions = (
+        '_vispy_get_native_canvas',
+        '_vispy_get_native_timer',
+        '_vispy_get_native_app',
+        '_vispy_reuse',
+        '_vispy_mouse_move',
+        '_vispy_mouse_press',
+        '_vispy_mouse_release',
+        '_vispy_mouse_double_click',
+        '_vispy_detect_double_click',
+        '_vispy_get_fb_bind_location',
+        '_vispy_get_geometry',
+        '_vispy_get_physical_size',
+        '_vispy_sleep',
+        '_process_backend_kwargs')  # defined in base class
+
+    class KlassRef(vispy.app.base.BaseCanvasBackend):
+        def __init__(self, *args, **kwargs):
+            pass  # Do not call the base class, since it will check for Canvas
+    Klass = _module.CanvasBackend
+    base = KlassRef()
+    for key in dir(KlassRef):
+        if not key.startswith('__'):
+            method = getattr(Klass, key)
+            if key not in exceptions:
+                print(key)
+                args = [None] * (len(_get_args(method)) - 1)
+                assert_raises(NotImplementedError, getattr(base, key), *args)
+                if hasattr(method, '__module__'):
+                    mod_str = method.__module__  # Py3k
+                else:
+                    mod_str = method.im_func.__module__
+                assert_in(mod_str, (_module.__name__, alt_modname),
+                          "Method %s.%s not defined in %s"
+                          % (Klass, key, _module.__name__))
+
+    Klass = _module.TimerBackend
+    KlassRef = vispy.app.timer.TimerBackend
+    for key in dir(KlassRef):
+        if not key.startswith('__'):
+            method = getattr(Klass, key)
+            if key not in exceptions:
+                if hasattr(method, '__module__'):
+                    # Py3k
+                    assert_in(method.__module__,
+                              (_module.__name__, alt_modname))
+                else:
+                    t = method.im_func.__module__ == _module.__name__
+                    assert t
+
+    Klass = _module.ApplicationBackend
+    KlassRef = vispy.app.application.ApplicationBackend
+    for key in dir(KlassRef):
+        if not key.startswith('__'):
+            method = getattr(Klass, key)
+            if key not in exceptions:
+                if hasattr(method, '__module__'):
+                    # Py3k
+                    assert_in(method.__module__,
+                              (_module.__name__, alt_modname))
+                else:
+                    t = method.im_func.__module__ == _module.__name__
+                    assert t
+
+    # Test that all events seem to be emitted.
+    # Get text
+    fname = _module.__file__.rstrip('c')  # "strip" will break windows!
+    with open(fname, 'rb') as fid:
+        text = fid.read().decode('utf-8')
+
+    canvas = vispy.app.Canvas(create_native=False, app=DummyApplication())
+    # Stylus and touch are ignored because they are not yet implemented.
+    # Mouse events are emitted from the CanvasBackend base class.
+    ignore = set(['stylus', 'touch', 'mouse_press', 'paint',
+                  'mouse_move', 'mouse_release', 'mouse_double_click',
+                  'detect_double_click', 'close'])
+    if module_fname in ('_egl', '_osmesa'):
+        ignore = ignore.union(['mouse_wheel', 'key_release', 'key_press'])
+    eventNames = set(canvas.events._emitters.keys()) - ignore
+
+    if not alt_modname:  # Only check for non-proxy modules
+        for name in eventNames:
+            assert_in('events.%s' % name, text,
+                      'events.%s does not appear in %s' % (name, fname))
+
+
+def test_template():
+    """Test application module template"""
+    _test_module_properties(_template)
+    assert_raises(NotImplementedError, _template._set_config, dict())
+    a = _template.ApplicationBackend()
+    print(a._vispy_get_backend_name())
+    for method in (a._vispy_process_events, a._vispy_run, a._vispy_quit,
+                   a._vispy_get_native_app):
+        assert_raises(NotImplementedError, method)
+
+    class TemplateCanvasBackend(_template.CanvasBackend):
+        def __init__(self, *args, **kwargs):
+            pass  # Do not call the base class, since it will check for Canvas
+    c = TemplateCanvasBackend()  # _template.CanvasBackend(None)
+    print(c._vispy_get_native_canvas())
+    for method in (c._vispy_set_current, c._vispy_swap_buffers, c._vispy_close,
+                   c._vispy_update, c._vispy_get_size, c._vispy_get_position):
+        assert_raises(NotImplementedError, method)
+    for method in (c._vispy_set_title, c._vispy_set_visible):
+        assert_raises(NotImplementedError, method, 0)
+    for method in (c._vispy_set_size, c._vispy_set_position):
+        assert_raises(NotImplementedError, method, 0, 0)
+
+
+@requires_application()
+def test_actual():
+    """Test actual application module"""
+    _test_module_properties(None)
+
+
+run_tests_if_main()

vispy/app/tests/test_canvas.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from vispy.app import Canvas, MouseEvent
+from vispy.visuals import ImageVisual
+from vispy.testing import requires_application
+from vispy.visuals.transforms import STTransform
+from vispy import gloo
+
+import numpy as np
+import pytest
+
+
+@requires_application()
+@pytest.mark.parametrize(
+    'blend_func',
+    [
+        ('src_alpha', 'one_minus_src_alpha', 'one', 'one_minus_src_alpha'),
+        ('src_alpha', 'one_minus_src_alpha'),
+        None,
+    ])
+def test_canvas_render(blend_func):
+    """Test rendering a canvas to an array.
+
+    Different blending functions are used to test what various Visuals may
+    produce without actually using different types of Visuals.
+
+    """
+    with Canvas(size=(125, 125), show=True, title='run') as c:
+        im1 = np.zeros((100, 100, 4)).astype(np.float32)
+        im1[:, :, 0] = 1
+        im1[:, :, 3] = 1
+
+        im2 = np.zeros((50, 50, 4)).astype(np.float32)
+        im2[:, :, 1] = 1
+        im2[:, :, 3] = 0.4
+
+        # Create the image
+        image1 = ImageVisual(im1)
+        image1.transform = STTransform(translate=(20, 20, 0))
+        image1.transforms.configure(canvas=c, viewport=(0, 0, 125, 125))
+        image2 = ImageVisual(im2)
+        image2.transform = STTransform(translate=(0, 0, -1))
+        image2.transforms.configure(canvas=c, viewport=(0, 0, 125, 125))
+        if blend_func:
+            image1.set_gl_state(preset='translucent', blend_func=blend_func)
+            image2.set_gl_state(preset='translucent', blend_func=blend_func)
+
+        @c.events.draw.connect
+        def on_draw(ev):
+            gloo.clear('black')
+            gloo.set_viewport(0, 0, *c.physical_size)
+            image1.draw()
+            image2.draw()
+
+        rgba_result = c.render()
+        rgb_result = c.render(alpha=False)
+
+        # the results should be the same except for alpha
+        np.testing.assert_allclose(rgba_result[..., :3], rgb_result)
+        # the image should have something drawn in it
+        assert not np.allclose(rgba_result[..., :3], 0)
+        # the alpha should not be completely transparent
+        assert not np.allclose(rgba_result[..., 3], 0)
+        if blend_func is None or 'one' in blend_func:
+            # no transparency
+            np.testing.assert_allclose(rgba_result[..., 3], 255)
+        else:
+            # the alpha should have some transparency
+            # this part of this test fails on macOS 12 at the moment
+            # see https://github.com/vispy/vispy/pull/2324#issuecomment-1163350672
+            assert (rgba_result[..., 3] != 255).any()
+
+
+@requires_application()
+@pytest.mark.parametrize(
+    'preset',
+    [
+        'opaque', 'additive', 'translucent',
+    ])
+def test_blend_presets(preset):
+    """Test blending presets a canvas to an array.
+
+    Different blending presets are used to test that they properly set
+    blend equations.
+
+    """
+    with Canvas(size=(125, 125), show=True, title='run') as c:
+        im1 = np.zeros((100, 100, 4)).astype(np.float32)
+        im1[:, :, 1] = 1
+        im1[:, :, 3] = .4
+        # Create the image
+        image1 = ImageVisual(im1)
+        image1.transform = STTransform(translate=(20, 20, -1))
+        image1.transforms.configure(canvas=c, viewport=(0, 0, 125, 125))
+        
+        gloo.set_state(blend_equation='min')
+        image1.set_gl_state(preset)
+
+        @c.events.draw.connect
+        def on_draw(ev):
+            gloo.clear('black')
+            gloo.set_viewport(0, 0, *c.physical_size)
+            image1.draw()
+            
+        rgba_result = c.render()
+        assert not np.allclose(rgba_result[..., :3], 0)
+
+
+@requires_application()
+@pytest.mark.parametrize("mouse_event_type, button, buttons, expected_button, expected_buttons", [
+    ('mouse_press', 1, [], 1, [1]),
+    ('mouse_release', 1, [1], 1, [1]),
+    # left click pressed and held, followed by a right click
+    ('mouse_press', 2, [1], 2, [1, 2]),
+    ('mouse_release', 2, [1, 2], 2, [1, 2]),
+])
+def test_mouse_event(mouse_event_type, button, buttons, expected_button, expected_buttons):
+    mev = MouseEvent(type=mouse_event_type, button=button, buttons=buttons)
+    assert mev.buttons == expected_buttons
+    assert mev.button == expected_button

vispy/app/tests/test_context.py

@@ -0,0 +1,92 @@
+import sys
+
+import pytest
+
+from vispy.testing import (requires_application, SkipTest, run_tests_if_main,
+                           assert_raises, IS_CI)
+from vispy.app import Canvas, use_app
+from vispy.gloo import get_gl_configuration, Program
+from vispy.gloo.gl import check_error
+
+
+@requires_application()
+def test_context_properties():
+    """Test setting context properties"""
+    a = use_app()
+    if a.backend_name.lower() == 'pyglet':
+        return  # cannot set more than once on Pyglet
+    if a.backend_name.lower() == 'osmesa':
+        return  # cannot set config on OSMesa
+    if 'pyqt5' in a.backend_name.lower() or 'pyqt6' in a.backend_name.lower() or 'pyside2' in a.backend_name.lower() or 'pyside6' in a.backend_name.lower():
+        pytest.xfail("Context sharing is not supported in PyQt5, PyQt6, PySide2, or PySide6 at this time.")
+
+    # stereo, double buffer won't work on every sys
+    configs = [dict(samples=4), dict(stencil_size=8),
+               dict(samples=4, stencil_size=8)]
+    if a.backend_name.lower() != 'glfw':  # glfw *always* double-buffers
+        configs.append(dict(double_buffer=False, samples=4))
+        configs.append(dict(double_buffer=False))
+    else:
+        assert_raises(RuntimeError, Canvas, app=a,
+                      config=dict(double_buffer=False))
+    if a.backend_name.lower() == 'sdl2' and IS_CI:
+        raise SkipTest('Travis SDL cannot set context')
+    for config in configs:
+        n_items = len(config)
+        with Canvas(config=config):
+            if IS_CI:
+                # Travis and Appveyor cannot handle obtaining these values
+                props = config
+            else:
+                props = get_gl_configuration()
+            assert len(config) == n_items
+            for key, val in config.items():
+                # XXX knownfail for windows samples, and wx/tkinter (all platforms)
+                if key == 'samples':
+                    will_fail_backend = a.backend_name.lower() in ('wx', 'tkinter')
+                    if not (sys.platform.startswith('win') or will_fail_backend):
+                        assert val == props[key], key
+    assert_raises(TypeError, Canvas, config='foo')
+    assert_raises(KeyError, Canvas, config=dict(foo=True))
+    assert_raises(TypeError, Canvas, config=dict(double_buffer='foo'))
+
+
+@requires_application()
+def test_context_sharing():
+    """Test context sharing"""
+    with Canvas() as c1:
+        vert = "attribute vec4 pos;\nvoid main (void) {gl_Position = pos;}"
+        frag = "void main (void) {gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);}"
+        program = Program(vert, frag)
+        program['pos'] = [(1, 2, 3, 1), (4, 5, 6, 1)]
+        program.draw('points')
+
+        def check():
+            # Do something to program and see if it worked
+            program['pos'] = [(1, 2, 3, 1), (4, 5, 6, 1)]  # Do command
+            program.draw('points')
+            check_error()
+
+        # Check while c1 is active
+        check()
+
+        # pyqt5 does not currently support context sharing, pyside6 seg faults on app tests
+        if 'pyqt5' in c1.app.backend_name.lower() or 'pyqt6' in c1.app.backend_name.lower() or 'pyside2' in c1.app.backend_name.lower() or 'pyside6' in c1.app.backend_name.lower():
+            pytest.xfail("Context sharing is not supported in PyQt5, PyQt6, PySide2, or PySide6 at this time.")
+
+        # Tkinter does not currently support context sharing
+        if 'tk' in c1.app.backend_name.lower():
+            pytest.xfail("Context sharing is not supported in Tkinter at this time.")
+
+        # Check while c2 is active (with different context)
+        with Canvas() as c2:
+            # pyglet always shares
+            if 'pyglet' not in c2.app.backend_name.lower():
+                assert_raises(Exception, check)
+
+        # Check while c2 is active (with *same* context)
+        with Canvas(shared=c1.context) as c2:
+            assert c1.context.shared is c2.context.shared  # same object
+            check()
+
+run_tests_if_main()

vispy/app/tests/test_qt.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from os import path as op
+import warnings
+
+from vispy.testing import requires_application
+
+
+@requires_application('pyqt4', has=['uic'])
+def test_qt_designer():
+    """Embed Canvas via Qt Designer"""
+    from PyQt4 import QtGui, uic
+    app = QtGui.QApplication.instance()
+    if app is None:
+        app = QtGui.QApplication([])
+
+    fname = op.join(op.dirname(__file__), 'qt-designer.ui')
+    with warnings.catch_warnings(record=True):  # pyqt4 deprecation warning
+        WindowTemplate, TemplateBaseClass = uic.loadUiType(fname)
+
+    class MainWindow(TemplateBaseClass):
+        def __init__(self):
+            TemplateBaseClass.__init__(self)
+
+            self.ui = WindowTemplate()
+            self.ui.setupUi(self)
+
+    win = MainWindow()
+
+    try:
+        canvas = win.ui.canvas
+        # test we can access properties of the internal canvas:
+        canvas.central_widget.add_view()
+        win.show()
+        app.processEvents()
+    finally:
+        win.close()
+
+    return win
+
+
+# Don't use run_tests_if_main(), because we want to show the win
+if __name__ == '__main__':
+    win = test_qt_designer()
+    win.show()

vispy/app/tests/test_simultaneous.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+
+import sys
+from time import sleep
+
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose
+
+from vispy.app import use_app, Canvas, Timer
+from vispy.testing import requires_application, SkipTest, run_tests_if_main, IS_TRAVIS_CI
+from vispy.util.ptime import time
+from vispy.gloo import gl
+from vispy.gloo.util import _screenshot
+
+_win_size = (200, 50)
+
+
+def _update_process_check(canvas, val, draw=True):
+    """Update, process, and check result"""
+    if draw:
+        canvas.update()
+        canvas.app.process_events()
+        canvas.app.process_events()
+        sleep(0.03)  # give it time to swap (Qt?)
+    canvas._backend._vispy_set_current()
+    print('           check %s' % val)
+    # check screenshot to see if it's all one color
+    ss = _screenshot()
+    try:
+        assert_allclose(ss.shape[:2], _win_size[::-1])
+    except Exception:
+        print('!!!!!!!!!! FAIL  bad size %s' % list(ss.shape[:2]))
+        raise
+    goal = val * np.ones(ss.shape)
+    try:
+        # Get rid of the alpha value before testing
+        # It can be off by 1 due to rounding
+        assert_allclose(ss[:, :, :3], goal[:, :, :3], atol=1)
+    except Exception:
+        print('!!!!!!!!!! FAIL  %s' % np.unique(ss))
+        raise
+
+
+@pytest.mark.xfail(IS_TRAVIS_CI and 'darwin' in sys.platform,
+                   reason='Travis OSX causes segmentation fault on this test for an unknown reason.')
+@requires_application()
+def test_multiple_canvases():
+    """Testing multiple canvases"""
+    n_check = 3
+    app = use_app()
+    with Canvas(app=app, size=_win_size, title='same_0') as c0:
+        with Canvas(app=app, size=_win_size, title='same_1') as c1:
+            ct = [0, 0]
+
+            @c0.events.draw.connect
+            def draw0(event):
+                ct[0] += 1
+                c0.update()
+
+            @c1.events.draw.connect  # noqa, analysis:ignore
+            def draw1(event):
+                ct[1] += 1
+                c1.update()
+
+            c0.show()  # ensure visible
+            c1.show()
+            c0.update()  # force first draw
+            c1.update()
+
+            timeout = time() + 2.0
+            while (ct[0] < n_check or ct[1] < n_check) and time() < timeout:
+                app.process_events()
+            print((ct, n_check))
+            assert n_check <= ct[0] <= n_check + 20  # be quite lenient
+            assert n_check <= ct[1] <= n_check + 20
+
+            # check timer
+            global timer_ran
+            timer_ran = False
+
+            def on_timer(_):
+                global timer_ran
+                timer_ran = True
+            t = Timer(0.1, app=app, connect=on_timer, iterations=1,  # noqa
+                      start=True)
+            app.process_events()
+            sleep(0.5)  # long for slow systems
+            app.process_events()
+            app.process_events()
+            assert timer_ran
+
+    if app.backend_name.lower() == 'wx':
+        raise SkipTest('wx fails test #2')  # XXX TODO Fix this
+
+    kwargs = dict(app=app, autoswap=False, size=_win_size,
+                  show=True)
+    with Canvas(title='0', **kwargs) as c0:
+        with Canvas(title='1', **kwargs) as c1:
+            bgcolors = [None] * 2
+
+            @c0.events.draw.connect
+            def draw00(event):
+                print('  {0:7}: {1}'.format('0', bgcolors[0]))
+                if bgcolors[0] is not None:
+                    gl.glViewport(0, 0, *list(_win_size))
+                    gl.glClearColor(*bgcolors[0])
+                    gl.glClear(gl.GL_COLOR_BUFFER_BIT)
+                    gl.glFinish()
+
+            @c1.events.draw.connect
+            def draw11(event):
+                print('  {0:7}: {1}'.format('1', bgcolors[1]))
+                if bgcolors[1] is not None:
+                    gl.glViewport(0, 0, *list(_win_size))
+                    gl.glClearColor(*bgcolors[1])
+                    gl.glClear(gl.GL_COLOR_BUFFER_BIT)
+                    gl.glFinish()
+
+            for ci, canvas in enumerate((c0, c1)):
+                print('draw %s' % canvas.title)
+                bgcolors[ci] = [0.5, 0.5, 0.5, 1.0]
+                _update_process_check(canvas, 127)
+
+            for ci, canvas in enumerate((c0, c1)):
+                print('test')
+                _update_process_check(canvas, 127, draw=False)
+                bgcolors[ci] = [1., 1., 1., 1.]
+                _update_process_check(canvas, 255)
+                bgcolors[ci] = [0.25, 0.25, 0.25, 0.25]
+                _update_process_check(canvas, 64)
+
+
+run_tests_if_main()