vispy 0.16.1__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl

vispy/__init__.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""=====
+Vispy
+=====
+
+Vispy is a **high-performance interactive 2D/3D data visualization
+library**. Vispy leverages the computational power of modern **Graphics
+Processing Units (GPUs)** through the **OpenGL** library to display very
+large datasets.
+
+For more information, see http://vispy.org.
+"""
+
+from __future__ import division
+
+__all__ = ['use', 'sys_info', 'set_log_level', 'test']
+
+try:
+    from .version import version as __version__  # noqa
+except ImportError:
+    # package is not installed
+    pass
+
+from .util import config, set_log_level, keys, sys_info  # noqa
+from .util.wrappers import use, test  # noqa
+
+
+def _get_sg_image_scraper():
+    from .util.gallery_scraper import VisPyGalleryScraper
+    return VisPyGalleryScraper()

vispy/app/__init__.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""The app module defines three classes: Application, Canvas, and Timer.
+On loading, vispy creates a default Application instance which can be used
+via functions in the module's namespace.
+"""
+
+from __future__ import division
+
+from .application import Application  # noqa
+from ._default_app import use_app, create, run, quit, process_events  # noqa
+from .canvas import Canvas, MouseEvent, KeyEvent  # noqa
+from .timer import Timer  # noqa
+from . import base  # noqa

vispy/app/_default_app.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+from .application import Application
+
+# Initialize default app
+# Only for use within *this* module.
+# One should always call use_app() to obtain the default app.
+default_app = None
+
+
+def use_app(backend_name=None, call_reuse=True):
+    """Get/create the default Application object
+
+    It is safe to call this function multiple times, as long as
+    backend_name is None or matches the already selected backend.
+
+    Parameters
+    ----------
+    backend_name : str | None
+        The name of the backend application to use. If not specified, Vispy
+        tries to select a backend automatically. See ``vispy.use()`` for
+        details.
+    call_reuse : bool
+        Whether to call the backend's `reuse()` function (True by default).
+        Not implemented by default, but some backends need it. For example,
+        the notebook backends need to inject some JavaScript in a notebook as
+        soon as `use_app()` is called.
+
+    """
+    global default_app
+
+    # If we already have a default_app, raise error or return
+    if default_app is not None:
+        names = default_app.backend_name.lower().replace('(', ' ').strip(') ')
+        names = [name for name in names.split(' ') if name]
+        if backend_name and backend_name.lower() not in names:
+            raise RuntimeError('Can only select a backend once, already using '
+                               '%s.' % names)
+        else:
+            if call_reuse:
+                default_app.reuse()
+            return default_app  # Current backend matches backend_name
+
+    # Create default app
+    default_app = Application(backend_name)
+    return default_app
+
+
+def create():
+    """Create the native application."""
+    use_app(call_reuse=False)
+    return default_app.create()
+
+
+def run():
+    """Enter the native GUI event loop."""
+    use_app(call_reuse=False)
+    return default_app.run()
+
+
+def quit():
+    """Quit the native GUI event loop."""
+    use_app(call_reuse=False)
+    return default_app.quit()
+
+
+def process_events():
+    """Process all pending GUI events
+
+    If the mainloop is not running, this should be done regularly to
+    keep the visualization interactive and to keep the event system going.
+    """
+    use_app(call_reuse=False)
+    return default_app.process_events()

vispy/app/_detect_eventloop.py

@@ -0,0 +1,148 @@
+# Taken from Matplotlib to automatically detect any event loop currently
+# in use.
+# This code is copyright of Matplotlib, and their license is inlcuded at the
+# bottom of this file.
+
+import sys
+import os
+
+
+def _get_running_interactive_framework():
+    """
+    Return the interactive framework whose event loop is currently running, if
+    any, or "headless" if no event loop can be started, or None.
+    Returns
+    -------
+    Optional[str]
+        One of the following values: "qt5", "qt4", "gtk3", "wx", "tk",
+        "macosx", "headless", ``None``.
+    """
+    QtWidgets = (sys.modules.get("PyQt5.QtWidgets")
+                 or sys.modules.get("PySide2.QtWidgets"))
+    if QtWidgets and QtWidgets.QApplication.instance():
+        return "qt5"
+    QtGui = (sys.modules.get("PyQt4.QtGui")
+             or sys.modules.get("PySide.QtGui"))
+    if QtGui and QtGui.QApplication.instance():
+        return "qt4"
+    Gtk = sys.modules.get("gi.repository.Gtk")
+    if Gtk and Gtk.main_level():
+        return "gtk3"
+    wx = sys.modules.get("wx")
+    if wx and wx.GetApp():
+        return "wx"
+    tkinter = sys.modules.get("tkinter")
+    if tkinter:
+        for frame in sys._current_frames().values():
+            while frame:
+                if frame.f_code == tkinter.mainloop.__code__:
+                    return "tk"
+                frame = frame.f_back
+    if 'matplotlib.backends._macosx' in sys.modules:
+        if sys.modules["matplotlib.backends._macosx"].event_loop_is_running():
+            return "macosx"
+    if sys.platform.startswith("linux") and not os.environ.get("DISPLAY"):
+        return "headless"
+    return None
+
+"""
+License agreement for matplotlib versions 1.3.0 and later
+=========================================================
+
+1. This LICENSE AGREEMENT is between the Matplotlib Development Team
+("MDT"), and the Individual or Organization ("Licensee") accessing and
+otherwise using matplotlib software in source or binary form and its
+associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, MDT
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that MDT's
+License Agreement and MDT's notice of copyright, i.e., "Copyright (c)
+2012- Matplotlib Development Team; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib .
+
+4. MDT is making matplotlib available to Licensee on an "AS
+IS" basis.  MDT MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, MDT MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. MDT SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between MDT and
+Licensee.  This License Agreement does not grant permission to use MDT
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib ,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.
+
+License agreement for matplotlib versions prior to 1.3.0
+========================================================
+
+1. This LICENSE AGREEMENT is between John D. Hunter ("JDH"), and the
+Individual or Organization ("Licensee") accessing and otherwise using
+matplotlib software in source or binary form and its associated
+documentation.
+
+2. Subject to the terms and conditions of this License Agreement, JDH
+hereby grants Licensee a nonexclusive, royalty-free, world-wide license
+to reproduce, analyze, test, perform and/or display publicly, prepare
+derivative works, distribute, and otherwise use matplotlib
+alone or in any derivative version, provided, however, that JDH's
+License Agreement and JDH's notice of copyright, i.e., "Copyright (c)
+2002-2011 John D. Hunter; All Rights Reserved" are retained in
+matplotlib  alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+incorporates matplotlib  or any part thereof, and wants to
+make the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to matplotlib.
+
+4. JDH is making matplotlib  available to Licensee on an "AS
+IS" basis.  JDH MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, JDH MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF MATPLOTLIB
+WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. JDH SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF MATPLOTLIB
+ FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR
+LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING
+MATPLOTLIB , OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF
+THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between JDH and
+Licensee.  This License Agreement does not grant permission to use JDH
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using matplotlib,
+Licensee agrees to be bound by the terms and conditions of this License
+Agreement.
+"""

vispy/app/application.py

@@ -0,0 +1,263 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""Implements the global singleton app object."""
+
+from __future__ import division
+
+import builtins
+import os
+import sys
+
+from . import backends
+from .backends import CORE_BACKENDS, BACKEND_NAMES, BACKENDMAP, TRIED_BACKENDS
+from .. import config
+from .base import BaseApplicationBackend as ApplicationBackend  # noqa
+from ._detect_eventloop import _get_running_interactive_framework
+from ..util import logger
+
+
+class Application(object):
+    """Representation of the vispy application
+
+    This wraps a native GUI application instance. Vispy has a default
+    instance of this class that can be created/obtained via
+    `vispy.app.use_app()`.
+
+    Parameters
+    ----------
+    backend_name : str | None
+        The name of the backend application to use. If not specified,
+        Vispy tries to select a backend automatically. See ``vispy.use()``
+        for details.
+
+    Notes
+    -----
+    Upon creating an Application object, a backend is selected, but the
+    native backend application object is only created when `create()`
+    is called or `native` is used. The Canvas and Timer do this
+    automatically.
+
+    """
+
+    def __init__(self, backend_name=None):
+        self._backend_module = None
+        self._backend = None
+        self._use(backend_name)
+
+    def __repr__(self):
+        name = self.backend_name
+        if not name:
+            return '<Vispy app with no backend>'
+        else:
+            return '<Vispy app, wrapping the %s GUI toolkit>' % name
+
+    @property
+    def backend_name(self):
+        """The name of the GUI backend that this app wraps."""
+        if self._backend is not None:
+            return self._backend._vispy_get_backend_name()
+        else:
+            return ''
+
+    @property
+    def backend_module(self):
+        """The module object that defines the backend."""
+        return self._backend_module
+
+    def process_events(self):
+        """Process all pending GUI events. If the mainloop is not
+        running, this should be done regularly to keep the visualization
+        interactive and to keep the event system going.
+        """
+        return self._backend._vispy_process_events()
+
+    def sleep(self, duration_sec):
+        """Sleep for the given duration in seconds.
+
+        This is used to reduce
+        CPU stress when VisPy is run in interactive mode.
+
+        Parameters
+        ----------
+        duration_sec: float
+            Time to sleep in seconds
+        """
+        self._backend._vispy_sleep(duration_sec)
+
+    def create(self):
+        """Create the native application."""
+        # Ensure that the native app exists
+        self.native
+
+    def is_interactive(self):
+        """Determine if the user requested interactive mode."""
+        # The Python interpreter sets sys.flags correctly, so use them!
+        if sys.flags.interactive:
+            return True
+
+        # IPython does not set sys.flags when -i is specified, so first
+        # check it if it is already imported.
+        if not hasattr(builtins, '__IPYTHON__'):
+            return False
+
+        # Then we check the application singleton and determine based on
+        # a variable it sets.
+        try:
+            try:
+                # ipython >=3.0
+                from traitlets.config.application import Application as App
+            except ImportError:
+                # ipython <3.0
+                from IPython.config.application import Application as App
+            return App.initialized() and App.instance().interact
+        except (ImportError, AttributeError):
+            return False
+
+    def is_notebook(self):
+        """Determine if the user is executing in a Jupyter Notebook"""
+        try:
+            # 'get_ipython' is available in globals when running from
+            # IPython/Jupyter
+            ip = get_ipython()
+            if ip.has_trait('kernel'):
+                # There doesn't seem to be an easy way to detect the frontend
+                # That said, if using a kernel, the user can choose to have an
+                # event loop, we therefore make sure the event loop isn't
+                # specified before assuming it is a notebook
+                # https://github.com/vispy/vispy/issues/1708
+                # https://github.com/ipython/ipython/issues/11920
+                return _get_running_interactive_framework() is None
+            else:
+                # `jupyter console` is used
+                return False
+        except NameError:
+            return False
+
+    def run(self, allow_interactive=True):
+        """Enter the native GUI event loop.
+
+        Parameters
+        ----------
+        allow_interactive : bool
+            Is the application allowed to handle interactive mode for console
+            terminals?  By default, typing ``python -i main.py`` results in
+            an interactive shell that also regularly calls the VisPy event
+            loop.  In this specific case, the run() function will terminate
+            immediately and rely on the interpreter's input loop to be run
+            after script execution.
+        """
+        if os.getenv("_VISPY_RUNNING_GALLERY_EXAMPLES"):
+            # Custom sphinx-gallery scraper in doc/conf.py will handle
+            # rendering/running the application. To make example scripts look
+            # like what a user actually has to run to view the window, we let
+            # them run "app.run()" but immediately return here.
+            # Without this the application would block until someone closed the
+            # window that opens.
+            return 0
+        elif not allow_interactive or not self.is_interactive():
+            return self._backend._vispy_run()
+
+    def reuse(self):
+        """Called when the application is reused in an interactive session.
+        This allow the backend to do stuff in the client when `use_app()` is
+        called multiple times by the user. For example, the notebook backends
+        need to inject JavaScript code as soon as `use_app()` is called.
+        """
+        return self._backend._vispy_reuse()
+
+    def quit(self):
+        """Quit the native GUI event loop."""
+        return self._backend._vispy_quit()
+
+    @property
+    def native(self):
+        """The native GUI application instance."""
+        return self._backend._vispy_get_native_app()
+
+    def _use(self, backend_name=None):
+        """Select a backend by name. See class docstring for details."""
+        # See if we're in a specific testing mode, if so DONT check to see
+        # if it's a valid backend. If it isn't, it's a good thing we
+        # get an error later because we should have decorated our test
+        # with requires_application()
+        test_name = os.getenv('_VISPY_TESTING_APP', None)
+
+        # Check whether the given name is valid
+        if backend_name is not None:
+            if backend_name.lower() == 'default':
+                backend_name = None  # Explicitly use default, avoid using test
+            elif backend_name.lower() not in BACKENDMAP:
+                raise ValueError('backend_name must be one of %s or None, not '
+                                 '%r' % (BACKEND_NAMES, backend_name))
+        elif test_name is not None:
+            backend_name = test_name.lower()
+            assert backend_name in BACKENDMAP
+        elif self.is_notebook():
+            backend_name = 'jupyter_rfb'
+
+        # Should we try and load any backend, or just this specific one?
+        try_others = backend_name is None
+
+        # Get backends to try ...
+        imported_toolkits = []  # Backends for which the native lib is imported
+        backends_to_try = []
+        if not try_others:
+            # We should never hit this, since we check above
+            assert backend_name.lower() in BACKENDMAP.keys()
+            # Add it
+            backends_to_try.append(backend_name.lower())
+        else:
+            # See if a backend is loaded
+            for name, module_name, native_module_name in CORE_BACKENDS:
+                if native_module_name and native_module_name in sys.modules:
+                    imported_toolkits.append(name.lower())
+                    backends_to_try.append(name.lower())
+            # See if a default is given
+            default_backend = config['default_backend'].lower()
+            if default_backend.lower() in BACKENDMAP.keys():
+                if default_backend not in backends_to_try:
+                    backends_to_try.append(default_backend)
+            # After this, try each one
+            for name, module_name, native_module_name in CORE_BACKENDS:
+                name = name.lower()
+                if name not in backends_to_try:
+                    backends_to_try.append(name)
+
+        # Now try each one
+        for key in backends_to_try:
+            name, module_name, native_module_name = BACKENDMAP[key]
+            TRIED_BACKENDS.append(name)
+            mod_name = 'backends.' + module_name
+            __import__(mod_name, globals(), level=1)
+            mod = getattr(backends, module_name)
+            if not mod.available:
+                msg = ('Could not import backend "%s":\n%s'
+                       % (name, str(mod.why_not)))
+                if not try_others:
+                    # Fail if user wanted to use a specific backend
+                    raise RuntimeError(msg)
+                elif key in imported_toolkits:
+                    # Warn if were unable to use an already imported toolkit
+                    msg = ('Although %s is already imported, the %s backend '
+                           'could not\nbe used ("%s"). \nNote that running '
+                           'multiple GUI toolkits simultaneously can cause '
+                           'side effects.' %
+                           (native_module_name, name, str(mod.why_not)))
+                    logger.warning(msg)
+                elif backend_name is not None:
+                    # Inform only if one isn't available
+                    logger.warning(msg)
+            else:
+                # Success!
+                self._backend_module = mod
+                logger.info('Selected backend %s' % module_name)
+                break
+        else:
+            raise RuntimeError('Could not import any of the backends. '
+                               'You need to install any of %s. We recommend '
+                               'PyQt' % [b[0] for b in CORE_BACKENDS])
+
+        # Store classes for app backend and canvas backend
+        self._backend = self.backend_module.ApplicationBackend()

vispy/app/backends/__init__.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""vispy.app.backends
+
+The backend modules are dynamically imported when needed. This module
+defines a small description of each supported backend, so that for
+instance we can test whether the GUI toolkit for a backend is already
+imported. This stuff is mostly used in the Application.use method.
+"""
+
+# Define backends: name, vispy.app.backends.xxx module, native module name.
+# This is the order in which they are attempted to be imported.
+CORE_BACKENDS = [
+    ('PyQt4', '_pyqt4', 'PyQt4'),
+    ('PyQt5', '_pyqt5', 'PyQt5'),
+    ('PyQt6', '_pyqt6', 'PyQt6'),
+    ('PySide', '_pyside', 'PySide'),
+    ('PySide2', '_pyside2', 'PySide2'),
+    ('PySide6', '_pyside6', 'PySide6'),
+    ('Pyglet', '_pyglet', 'pyglet'),
+    ('Glfw', '_glfw', 'vispy.ext.glfw'),
+    ('SDL2', '_sdl2', 'sdl2'),
+    ('wx', '_wx', 'wx'),
+    ('EGL', '_egl', 'vispy.ext.egl'),
+    ('osmesa', '_osmesa', 'vispy.ext.osmesa'),
+    ('tkinter', '_tk', 'tkinter'),
+]
+
+# Whereas core backends really represents libraries that can create a
+# canvas, the pseudo backends act more like a proxy.
+PSEUDO_BACKENDS = [
+    ('jupyter_rfb', '_jupyter_rfb', None),
+    ('_test', '_test', 'vispy.app.backends._test'),  # add one that will fail
+]
+
+# Combine
+BACKENDS = CORE_BACKENDS + PSEUDO_BACKENDS
+
+# Get list of backend names
+BACKEND_NAMES = [b[0].lower() for b in BACKENDS]
+
+# Map of the lowercase backend names to the backend descriptions above
+# so that we can look up its properties if we only have a name.
+BACKENDMAP = dict([(be[0].lower(), be) for be in BACKENDS])
+
+# List of attempted backends. For logging.
+TRIED_BACKENDS = []
+
+# Flag for _pyside, _pyside2 _pyqt4 and _qt modules to communicate.
+qt_lib = None