vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/util/tests/test_fourier.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+import numpy as np
+
+from vispy.util.fourier import stft, fft_freqs
+from vispy.testing import assert_raises, run_tests_if_main
+
+
+def test_stft():
+    """Test STFT calculation"""
+    assert_raises(ValueError, stft, 0)
+    assert_raises(ValueError, stft, [], window='foo')
+    assert_raises(ValueError, stft, [[]])
+    result = stft([])
+    assert np.allclose(result, np.zeros_like(result))
+    n_fft = 256
+    step = 128
+    for n_samples, n_estimates in ((256, 1),
+                                   (383, 1), (384, 2),
+                                   (511, 2), (512, 3)):
+        result = stft(np.ones(n_samples), n_fft=n_fft, step=step, window=None)
+        assert result.shape[1] == n_estimates
+        expected = np.zeros(n_fft // 2 + 1)
+        expected[0] = 1
+        for res in result.T:
+            assert np.allclose(expected, np.abs(res))
+            assert np.allclose(expected, np.abs(res))
+    for n_pts, last_freq in zip((256, 255), (500., 498.)):
+        freqs = fft_freqs(n_pts, 1000)
+        assert freqs[0] == 0
+        assert np.allclose(freqs[-1], last_freq, atol=1e-1)
+
+run_tests_if_main()

vispy/util/tests/test_gallery_scraper.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""Test the sphinx-gallery custom scraper."""
+
+import os
+
+from vispy.testing import TestingCanvas, requires_application
+
+import pytest
+
+try:
+    from sphinx_gallery.gen_gallery import DEFAULT_GALLERY_CONF
+except ImportError:
+    pytest.skip("Skipping sphinx-gallery tests", allow_module_level=True)
+
+from ..gallery_scraper import VisPyGalleryScraper
+
+pytest.importorskip("PyQt5", reason="Gallery scraper only supports PyQt5")
+
+
+def _create_fake_block_vars(canvas):
+    block_vars = {
+        "example_globals": {
+            "canvas": canvas,
+        },
+        "src_file": "example.py",
+        "image_path_iterator": (f"{x}.png" for x in range(10)),
+    }
+    return block_vars
+
+
+def _create_fake_gallery_conf(src_dir):
+    gallery_conf = {}
+    gallery_conf.update(DEFAULT_GALLERY_CONF)
+    gallery_conf.update({
+        "compress_images": "images",
+        "compress_images_args": [],
+        "src_dir": src_dir,
+        "gallery_dirs": src_dir,
+    })
+    return gallery_conf
+
+
+@requires_application()
+@pytest.mark.parametrize("include_gallery_comment", [False, True])
+def test_single_frame(include_gallery_comment, tmpdir):
+    canvas = TestingCanvas()
+    block_vars = _create_fake_block_vars(canvas)
+    gallery_conf = _create_fake_gallery_conf(str(tmpdir))
+    script = "\n# vispy: gallery 30\n" if include_gallery_comment else ""
+    with tmpdir.as_cwd():
+        with open("example.py", "w") as example_file:
+            example_file.write(script)
+        scraper = VisPyGalleryScraper()
+        rst = scraper(None, block_vars, gallery_conf)
+        if include_gallery_comment:
+            assert "0.png" in rst
+            assert os.path.isfile("0.png")
+        else:
+            assert "0.png" not in rst
+            assert not os.path.isfile("0.png")
+        assert not os.path.isfile("1.png")  # only one file created
+
+
+@requires_application()
+def test_single_animation(tmpdir):
+    canvas = TestingCanvas()
+    block_vars = _create_fake_block_vars(canvas)
+    gallery_conf = _create_fake_gallery_conf(str(tmpdir))
+    with tmpdir.as_cwd():
+        with open("example.py", "w") as example_file:
+            example_file.write("""# vispy: gallery 10:50:5
+            """)
+        scraper = VisPyGalleryScraper()
+        rst = scraper(None, block_vars, gallery_conf)
+        assert "0.gif" in rst
+        assert os.path.isfile("0.gif")
+        assert not os.path.isfile("0.png")  # only gif file created
+        assert not os.path.isfile("1.png")  # only one file created
+
+
+@requires_application()
+@pytest.mark.parametrize(
+    "exported_files",
+    [
+        ("example.png",),
+        ("example.gif",),
+        ("example1.png", "example2.png"),
+    ])
+def test_single_export(exported_files, tmpdir):
+    canvas = TestingCanvas()
+    block_vars = _create_fake_block_vars(canvas)
+    gallery_conf = _create_fake_gallery_conf(str(tmpdir))
+    with tmpdir.as_cwd():
+        # create the files that the example should have created
+        for fn in exported_files:
+            open(fn, "w").close()
+
+        with open("example.py", "w") as example_file:
+            example_file.write("""# vispy: gallery-exports {}
+            """.format(" ".join(exported_files)))
+
+        scraper = VisPyGalleryScraper()
+        rst = scraper(None, block_vars, gallery_conf)
+        for idx, fn in enumerate(exported_files):
+            # the original file should have been moved
+            assert not os.path.isfile(fn)
+            # the new name should from the sphinx-gallery iterator
+            new_name = str(idx) + os.path.splitext(fn)[1]
+            assert os.path.isfile(new_name)
+            assert new_name in rst

vispy/util/tests/test_import.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""Test that importing vispy subpackages do not pull
+in any more vispy submodules than strictly necessary.
+"""
+
+import sys
+import os
+
+from vispy.testing import (assert_in, assert_not_in, requires_pyopengl,
+                           run_tests_if_main, assert_equal)
+from vispy.util import run_subprocess
+import vispy
+
+
+# minimum that will be imported when importing vispy
+_min_modules = ['vispy', 'vispy.util', 'vispy.ext', 'vispy.version']
+
+
+def loaded_vispy_modules(import_module, depth=None, all_modules=False):
+    """Import the given module in subprocess and return loaded modules
+
+    Import a certain module in a clean subprocess and return the
+    vispy modules that are subsequently loaded. The given depth
+    indicates the module level (i.e. depth=1 will only yield 'vispy.app'
+    but not 'vispy.app.backends').
+    """
+    vispy_dir = os.path.dirname(os.path.dirname(vispy.__file__))
+
+    # Get the loaded modules in a clean interpreter
+    code = "import sys, %s; print(', '.join(sys.modules))" % import_module
+    res = run_subprocess([sys.executable, '-c', code], cwd=vispy_dir)[0]
+    loaded_modules = [name.strip() for name in res.split(',')]
+
+    if all_modules:
+        return loaded_modules
+
+    # Get only vispy modules at the given depth
+    vispy_modules = set()
+    for m in loaded_modules:
+        # pkg_resources from vispy/__init__.py shows up as vispy.pkg_resources in python 2.7
+        if m.startswith('vispy') and '__future__' not in m and 'pkg_resources' not in m:
+            if depth:
+                parts = m.split('.')
+                m = '.'.join(parts[:depth])
+            vispy_modules.add(m)
+
+    return vispy_modules
+
+
+def test_import_nothing():
+    """Not importing vispy should not import any vispy modules."""
+    modnames = loaded_vispy_modules('os', 2)
+    assert_equal(modnames, set())
+
+
+def test_import_vispy():
+    """Importing vispy should only pull in other vispy.util submodule."""
+    modnames = loaded_vispy_modules('vispy', 2)
+    assert_equal(modnames, set(_min_modules))
+
+
+def test_import_vispy_util():
+    """Importing vispy.util should not pull in other vispy submodules."""
+    modnames = loaded_vispy_modules('vispy.util', 2)
+    assert_equal(modnames, set(_min_modules))
+
+
+def test_import_vispy_app1():
+    """Importing vispy.app should not pull in other vispy submodules."""
+    # Since the introduction of the GLContext to gloo, app depends on gloo
+    modnames = loaded_vispy_modules('vispy.app', 2)
+    assert_equal(modnames, set(_min_modules + ['vispy.app', 'vispy.gloo',
+                                               'vispy.glsl', 'vispy.color']))
+
+
+def test_import_vispy_app2():
+    """Importing vispy.app should not pull in any backend toolkit."""
+    allmodnames = loaded_vispy_modules('vispy.app', 2, True)
+    assert_not_in('PySide', allmodnames)
+    assert_not_in('PySide2', allmodnames)
+    assert_not_in('PySide6', allmodnames)
+    assert_not_in('PyQt4', allmodnames)
+    assert_not_in('PyQt5', allmodnames)
+    assert_not_in('PyQt6', allmodnames)
+    assert_not_in('pyglet', allmodnames)
+
+
+def test_import_vispy_gloo():
+    """Importing vispy.gloo should not pull in other vispy submodules."""
+    modnames = loaded_vispy_modules('vispy.gloo', 2)
+    assert_equal(modnames, set(_min_modules + ['vispy.gloo',
+                                               'vispy.glsl',
+                                               'vispy.color']))
+
+
+def test_import_vispy_no_pyopengl():
+    """Importing vispy.gloo.gl.gl2 should not import PyOpenGL."""
+    # vispy.gloo desktop backend
+    allmodnames = loaded_vispy_modules('vispy.gloo.gl.gl2', 2, True)
+    assert_not_in('OpenGL', allmodnames)
+    # vispy.app
+    allmodnames = loaded_vispy_modules('vispy.app', 2, True)
+    assert_not_in('OpenGL', allmodnames)
+    # vispy.scene
+    allmodnames = loaded_vispy_modules('vispy.scene', 2, True)
+    assert_not_in('OpenGL', allmodnames)
+
+
+@requires_pyopengl()
+def test_import_vispy_pyopengl():
+    """Importing vispy.gloo.gl.pyopengl2 should import PyOpenGL."""
+    allmodnames = loaded_vispy_modules('vispy.gloo.gl.pyopengl2', 2, True)
+    assert_in('OpenGL', allmodnames)
+
+
+def test_import_vispy_scene():
+    """Importing vispy.gloo.gl.desktop should not import PyOpenGL."""
+    modnames = loaded_vispy_modules('vispy.scene', 2)
+    more_modules = ['vispy.app', 'vispy.gloo', 'vispy.glsl', 'vispy.scene',
+                    'vispy.color',
+                    'vispy.io', 'vispy.geometry', 'vispy.visuals']
+    assert_equal(modnames, set(_min_modules + more_modules))
+
+
+run_tests_if_main()

vispy/util/tests/test_key.py

@@ -0,0 +1,22 @@
+# -*- 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.util.keys import Key, ENTER
+from vispy.testing import (run_tests_if_main, assert_raises, assert_true,
+                           assert_equal)
+
+
+def test_key():
+    """Test basic key functionality"""
+    def bad():
+        return (ENTER == dict())
+    assert_raises(ValueError, bad)
+    assert_true(not (ENTER == None))  # noqa
+    assert_equal('Return', ENTER)
+    print(ENTER.name)
+    print(ENTER)  # __repr__
+    assert_equal(Key('1'), 49)  # ASCII code
+
+
+run_tests_if_main()

vispy/util/tests/test_logging.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+import logging
+
+from vispy.util import logger, use_log_level
+from vispy.testing import (assert_in, assert_not_in, run_tests_if_main,
+                           assert_equal)
+
+
+def test_logging():
+    """Test logging context manager"""
+    ll = logger.level
+    with use_log_level('warning', print_msg=False):
+        assert_equal(logger.level, logging.WARN)
+    assert_equal(logger.level, ll)
+    with use_log_level('debug', print_msg=False):
+        assert_equal(logger.level, logging.DEBUG)
+    assert_equal(logger.level, ll)
+
+
+def test_debug_logging():
+    """Test advanced debugging logging"""
+    with use_log_level('debug', 'Selected', True, False) as emit_list:
+        logger.debug('Selected foo')
+    assert_equal(len(emit_list), 1)
+    assert_in('test_logging', emit_list[0])  # can't really parse this location
+
+    with use_log_level('debug', record=True, print_msg=False) as emit_list:
+        logger.debug('foo')
+    assert_equal(len(emit_list), 1)
+    assert_in('test_logging', emit_list[0])
+
+    with use_log_level('debug', 'foo', True, False) as emit_list:
+        logger.debug('bar')
+    assert_equal(len(emit_list), 0)
+
+    with use_log_level('info', record=True, print_msg=False) as emit_list:
+        logger.debug('foo')
+        logger.info('bar')
+    assert_equal(len(emit_list), 1)
+    assert_not_in('unknown', emit_list[0])
+
+
+run_tests_if_main()

vispy/util/tests/test_run.py

@@ -0,0 +1,14 @@
+# -*- 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.util import run_subprocess
+from vispy.testing import run_tests_if_main, assert_raises
+
+
+def test_run():
+    """Test running subprocesses"""
+    bad_name = 'foo_nonexist_test'
+    assert_raises(Exception, run_subprocess, [bad_name])
+
+
+run_tests_if_main()

vispy/util/tests/test_transforms.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+import numpy as np
+from numpy.testing import assert_allclose
+
+from vispy.util.transforms import (translate, scale, rotate, ortho, frustum,
+                                   perspective)
+from vispy.testing import run_tests_if_main, assert_equal
+
+
+def test_transforms():
+    """Test basic transforms"""
+    xfm = np.random.randn(4, 4).astype(np.float32)
+
+    # Do a series of rotations that should end up into the same orientation
+    # again, to ensure the order of computation is all correct
+    # i.e. if rotated would return the transposed matrix this would not work
+    # out (the translation part would be incorrect)
+    new_xfm = xfm.dot(rotate(180, (1, 0, 0)).dot(rotate(-90, (0, 1, 0))))
+    new_xfm = new_xfm.dot(rotate(90, (0, 0, 1)).dot(rotate(90, (0, 1, 0))))
+    new_xfm = new_xfm.dot(rotate(90, (1, 0, 0)))
+    assert_allclose(xfm, new_xfm)
+
+    new_xfm = translate((1, -1, 1)).dot(translate((-1, 1, -1))).dot(xfm)
+    assert_allclose(xfm, new_xfm)
+
+    new_xfm = scale((1, 2, 3)).dot(scale((1, 1. / 2., 1. / 3.))).dot(xfm)
+    assert_allclose(xfm, new_xfm)
+
+    # These could be more complex...
+    xfm = ortho(-1, 1, -1, 1, -1, 1)
+    assert_equal(xfm.shape, (4, 4))
+
+    xfm = frustum(-1, 1, -1, 1, -1, 1)
+    assert_equal(xfm.shape, (4, 4))
+
+    xfm = perspective(1, 1, -1, 1)
+    assert_equal(xfm.shape, (4, 4))
+
+
+run_tests_if_main()

vispy/util/tests/test_vispy.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""Tests to ensure that base vispy namespace functions correctly,
+including configuration options.
+"""
+
+import vispy.app
+from vispy.testing import (requires_application, run_tests_if_main,
+                           assert_raises, assert_equal, assert_not_equal)
+
+
+@requires_application('pyside')
+def test_use():
+
+    # Set default app to None, so we can test the use function
+    vispy.app.use_app()
+    default_app = vispy.app._default_app.default_app
+    vispy.app._default_app.default_app = None
+
+    app_name = default_app.backend_name.split(' ')[0]
+
+    try:
+        # With no arguments, should do nothing
+        assert_raises(TypeError, vispy.use)
+        assert_equal(vispy.app._default_app.default_app, None)
+
+        # With only gl args, should do nothing to app
+        vispy.use(gl='gl2')
+        assert_equal(vispy.app._default_app.default_app, None)
+
+        # Specify app (one we know works)
+        vispy.use(app_name)
+        assert_not_equal(vispy.app._default_app.default_app, None)
+
+        # Again, but now wrong app
+        wrong_name = 'glfw' if app_name.lower() != 'glfw' else 'pyqt4'
+        assert_raises(RuntimeError, vispy.use, wrong_name)
+
+        # And both
+        vispy.use(app_name, 'gl2')
+
+    finally:
+        # Restore
+        vispy.app._default_app.default_app = default_app
+
+
+run_tests_if_main()

vispy/util/transforms.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Very simple transformation library that is needed for some examples."""
+
+from __future__ import division
+
+# Note: we use functions (e.g. sin) from math module because they're faster
+
+import math
+import numpy as np
+
+
+def translate(offset, dtype=None):
+    """Translate by an offset (x, y, z) .
+
+    Parameters
+    ----------
+    offset : array-like, shape (3,)
+        Translation in x, y, z.
+    dtype : dtype | None
+        Output type (if None, don't cast).
+
+    Returns
+    -------
+    M : ndarray
+        Transformation matrix describing the translation.
+    """
+    assert len(offset) == 3
+    x, y, z = offset
+    M = np.array([[1., 0., 0., 0.],
+                  [0., 1., 0., 0.],
+                  [0., 0., 1., 0.],
+                  [x, y, z, 1.0]], dtype)
+    return M
+
+
+def scale(s, dtype=None):
+    """Non-uniform scaling along the x, y, and z axes
+
+    Parameters
+    ----------
+    s : array-like, shape (3,)
+        Scaling in x, y, z.
+    dtype : dtype | None
+        Output type (if None, don't cast).
+
+    Returns
+    -------
+    M : ndarray
+        Transformation matrix describing the scaling.
+    """
+    assert len(s) == 3
+    return np.array(np.diag(np.concatenate([s, (1.,)])), dtype)
+
+
+def rotate(angle, axis, dtype=None):
+    """The 4x4 rotation matrix for rotation about a vector.
+
+    Parameters
+    ----------
+    angle : float
+        The angle of rotation, in degrees.
+    axis : ndarray
+        The x, y, z coordinates of the axis direction vector.
+
+    Returns
+    -------
+    M : ndarray
+        Transformation matrix describing the rotation.
+    """
+    angle = np.radians(angle)
+    assert len(axis) == 3
+    x, y, z = axis / np.linalg.norm(axis)
+    c, s = math.cos(angle), math.sin(angle)
+    cx, cy, cz = (1 - c) * x, (1 - c) * y, (1 - c) * z
+    M = np.array([[cx * x + c, cy * x - z * s, cz * x + y * s, .0],
+                  [cx * y + z * s, cy * y + c, cz * y - x * s, 0.],
+                  [cx * z - y * s, cy * z + x * s, cz * z + c, 0.],
+                  [0., 0., 0., 1.]], dtype).T
+    return M
+
+
+def ortho(left, right, bottom, top, znear, zfar):
+    """Create orthographic projection matrix
+
+    Parameters
+    ----------
+    left : float
+        Left coordinate of the field of view.
+    right : float
+        Right coordinate of the field of view.
+    bottom : float
+        Bottom coordinate of the field of view.
+    top : float
+        Top coordinate of the field of view.
+    znear : float
+        Near coordinate of the field of view.
+    zfar : float
+        Far coordinate of the field of view.
+
+    Returns
+    -------
+    M : ndarray
+        Orthographic projection matrix (4x4).
+    """
+    assert(right != left)
+    assert(bottom != top)
+    assert(znear != zfar)
+
+    M = np.zeros((4, 4), dtype=np.float32)
+    M[0, 0] = +2.0 / (right - left)
+    M[3, 0] = -(right + left) / float(right - left)
+    M[1, 1] = +2.0 / (top - bottom)
+    M[3, 1] = -(top + bottom) / float(top - bottom)
+    M[2, 2] = -2.0 / (zfar - znear)
+    M[3, 2] = -(zfar + znear) / float(zfar - znear)
+    M[3, 3] = 1.0
+    return M
+
+
+def frustum(left, right, bottom, top, znear, zfar):
+    """Create view frustum
+
+    Parameters
+    ----------
+    left : float
+        Left coordinate of the field of view.
+    right : float
+        Right coordinate of the field of view.
+    bottom : float
+        Bottom coordinate of the field of view.
+    top : float
+        Top coordinate of the field of view.
+    znear : float
+        Near coordinate of the field of view.
+    zfar : float
+        Far coordinate of the field of view.
+
+    Returns
+    -------
+    M : ndarray
+        View frustum matrix (4x4).
+    """
+    assert(right != left)
+    assert(bottom != top)
+    assert(znear != zfar)
+
+    M = np.zeros((4, 4), dtype=np.float32)
+    M[0, 0] = +2.0 * znear / float(right - left)
+    M[2, 0] = (right + left) / float(right - left)
+    M[1, 1] = +2.0 * znear / float(top - bottom)
+    M[2, 1] = (top + bottom) / float(top - bottom)
+    M[2, 2] = -(zfar + znear) / float(zfar - znear)
+    M[3, 2] = -2.0 * znear * zfar / float(zfar - znear)
+    M[2, 3] = -1.0
+    return M
+
+
+def perspective(fovy, aspect, znear, zfar):
+    """Create perspective projection matrix
+
+    Parameters
+    ----------
+    fovy : float
+        The field of view along the y axis.
+    aspect : float
+        Aspect ratio of the view.
+    znear : float
+        Near coordinate of the field of view.
+    zfar : float
+        Far coordinate of the field of view.
+
+    Returns
+    -------
+    M : ndarray
+        Perspective projection matrix (4x4).
+    """
+    assert(znear != zfar)
+    h = math.tan(fovy / 360.0 * math.pi) * znear
+    w = h * aspect
+    return frustum(-w, w, -h, h, znear, zfar)
+
+
+def affine_map(points1, points2):
+    """Find a 3D transformation matrix that maps points1 onto points2.
+
+    Arguments are specified as arrays of four 3D coordinates, shape (4, 3).
+    """
+    A = np.ones((4, 4))
+    A[:, :3] = points1
+    B = np.ones((4, 4))
+    B[:, :3] = points2
+
+    # solve 3 sets of linear equations to determine
+    # transformation matrix elements
+    matrix = np.eye(4)
+    for i in range(3):
+        # solve Ax = B; x is one row of the desired transformation matrix
+        matrix[i] = np.linalg.solve(A, B[:, i])
+
+    return matrix