vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/util/svg/transformable.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+from . element import Element
+from . transform import Transform
+
+
+class Transformable(Element):
+    """Transformable SVG element"""
+
+    def __init__(self, content=None, parent=None):
+        Element.__init__(self, content, parent)
+
+        if isinstance(content, str):
+            self._transform = Transform()
+            self._computed_transform = self._transform
+        else:
+            self._transform = Transform(content.get("transform", None))
+            self._computed_transform = self._transform
+            if parent:
+                self._computed_transform = self._transform + \
+                    self.parent.transform
+
+    @property
+    def transform(self):
+        return self._computed_transform

vispy/util/svg/viewport.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+
+from . length import XLength, YLength
+
+
+class Viewport(object):
+
+    def __init__(self, content=None, parent=None):
+
+        self._x = None
+        self._computed_x = 0
+        if content.get('x'):
+            self._x = XLength(content.get('x'), parent)
+            self._computed_x = float(self._x)
+
+        self._y = None
+        self._computed_y = 0
+        if content.get('y'):
+            self._y = XLength(content.get('y'), parent)
+            self._computed_y = float(self._y)
+
+        self._width = None
+        self._computed_width = 800
+        if content.get('width'):
+            self._width = XLength(content.get('width'), parent)
+            self._computed_width = float(self._width)
+
+        self._height = None
+        self._computed_height = 800
+        if content.get('height'):
+            self._height = YLength(content.get('height'), parent)
+            self._computed_height = float(self._height)
+
+    @property
+    def x(self):
+        return self._computed_x
+
+    @property
+    def y(self):
+        return self._computed_y
+
+    @property
+    def width(self):
+        return self._computed_width
+
+    @property
+    def height(self):
+        return self._computed_height
+
+    def __repr__(self):
+        s = repr((self._x, self._y, self._width, self._height))
+        return s
+
+    @property
+    def xml(self):
+        return self._xml
+
+    @property
+    def _xml(self, prefix=""):
+        s = ""
+        if self._x:
+            s += 'x="%s" ' % repr(self._x)
+        if self._y:
+            s += 'y="%s" ' % repr(self._y)
+        if self._width:
+            s += 'width="%s" ' % repr(self._width)
+        if self._height:
+            s += 'height="%s" ' % repr(self._height)
+        return s

vispy/util/tests/test_config.py

@@ -0,0 +1,58 @@
+# -*- 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 os
+
+from vispy.util import (config, sys_info, _TempDir, set_data_dir, save_config,
+                        load_data_file)
+from vispy.testing import (assert_in, requires_application, run_tests_if_main,
+                           assert_raises, assert_equal, assert_true,
+                           requires_ssl)
+temp_dir = _TempDir()
+
+
+@requires_application()
+def test_sys_info():
+    """Test printing of system information"""
+    fname = op.join(temp_dir, 'info.txt')
+    sys_info(fname)
+    assert_raises(IOError, sys_info, fname)  # no overwrite
+    with open(fname, 'r') as fid:
+        out = ''.join(fid.readlines())
+    keys = ['GL version', 'Python', 'Backend', 'pyglet', 'Platform:']
+    for key in keys:
+        assert_in(key, out)
+    print(out)
+    assert_true('Info-gathering error' not in out)
+
+
+@requires_ssl()
+def test_config():
+    """Test vispy config methods and file downloading"""
+    assert_raises(TypeError, config.update, data_path=dict())
+    assert_raises(KeyError, config.update, foo='bar')  # bad key
+    data_dir = op.join(temp_dir, 'data')
+    assert_raises(IOError, set_data_dir, data_dir)  # didn't say to create
+    orig_val = os.environ.get('_VISPY_CONFIG_TESTING', None)
+    os.environ['_VISPY_CONFIG_TESTING'] = 'true'
+    try:
+        assert_raises(IOError, set_data_dir, data_dir)  # doesn't exist yet
+        set_data_dir(data_dir, create=True, save=True)
+        assert_equal(config['data_path'], data_dir)
+        config['data_path'] = data_dir
+        print(config)  # __repr__
+        load_data_file('CONTRIBUTING.txt')
+        fid = open(op.join(data_dir, 'test-faked.txt'), 'w')
+        fid.close()
+        load_data_file('test-faked.txt')  # this one shouldn't download
+        assert_raises(RuntimeError, load_data_file, 'foo-nonexist.txt')
+        save_config()
+    finally:
+        if orig_val is not None:
+            os.environ['_VISPY_CONFIG_TESTING'] = orig_val
+        else:
+            del os.environ['_VISPY_CONFIG_TESTING']
+
+
+run_tests_if_main()

vispy/util/tests/test_docstring_parameters.py

@@ -0,0 +1,123 @@
+# TODO inspect for Cython (see sagenb.misc.sageinspect)
+
+import re
+import inspect
+import pytest
+
+import vispy.scene.cameras.magnify
+from vispy.testing import run_tests_if_main, requires_numpydoc
+
+
+public_modules = [
+    # the list of modules users need to access for all functionality
+    'vispy',
+    'vispy.color',
+    'vispy.geometry',
+    'vispy.gloo',
+    'vispy.io',
+    'vispy.plot',
+    'vispy.scene',
+    'vispy.util',
+    'vispy.visuals',
+]
+
+
+def _func_name(func, cls=None):
+    """Get the name."""
+    parts = []
+    if cls is not None:
+        module = inspect.getmodule(cls)
+    else:
+        module = inspect.getmodule(func)
+    if module:
+        parts.append(module.__name__)
+    if cls is not None:
+        parts.append(cls.__name__)
+    parts.append(func.__name__)
+    return '.'.join(parts)
+
+
+# functions to ignore
+docstring_ignores = [
+    'vispy.scene.visuals',  # not parsed properly by this func, copies anyway
+]
+error_ignores = {
+    # These we do not live by:
+    'GL01',  # Docstring should start in the line immediately after the quotes
+    'EX01', 'EX02',  # examples failed (we test them separately)
+    'ES01',  # no extended summary
+    'SA01',  # no see also
+    'YD01',  # no yields section
+    'SA04',  # no description in See Also
+    'PR04',  # Parameter "shape (n_channels" has no type
+    'RT02',  # The first line of the Returns section should contain only the type, unless multiple values are being returned  # noqa
+    # XXX should also verify that | is used rather than , to separate params
+    # XXX should maybe also restore the parameter-desc-length < 800 char check
+}
+error_ignores_specific = {}
+subclass_name_ignores = (
+    (vispy.scene.cameras.magnify.MagnifyCamera, {'MagnifyTransform', 'Magnify1DTransform'}),
+)
+
+
+def check_parameters_match(func, cls=None):
+    """Check docstring, return list of incorrect results."""
+    from numpydoc.validate import validate
+    name = _func_name(func, cls)
+    skip = (not name.startswith('vispy.') or
+            any(re.match(d, name) for d in docstring_ignores) or
+            'deprecation_wrapped' in getattr(
+                getattr(func, '__code__', None), 'co_name', ''))
+    if skip:
+        return list()
+    if cls is not None:
+        for subclass, ignores in subclass_name_ignores:
+            if issubclass(cls, subclass) and name.split('.')[-1] in ignores:
+                return list()
+    incorrect = ['%s : %s : %s' % (name, err[0], err[1])
+                 for err in validate(name)['errors']
+                 if err[0] not in error_ignores and
+                 (name.split('.')[-1], err[0]) not in error_ignores_specific]
+    return incorrect
+
+
+@pytest.mark.xfail
+@requires_numpydoc()
+def test_docstring_parameters():
+    """Test module docstring formatting."""
+    from numpydoc import docscrape
+    incorrect = []
+    for name in public_modules:
+        # Assert that by default we import all public names with `import vispy`
+        # if name not in ('vispy'):
+        #    extra = name.split('.')[1]
+        #    assert hasattr(vispy, extra)
+        with pytest.warns(None):  # traits warnings
+            module = __import__(name, globals())
+        for submod in name.split('.')[1:]:
+            module = getattr(module, submod)
+        classes = inspect.getmembers(module, inspect.isclass)
+        for cname, cls in classes:
+            if cname.startswith('_'):
+                continue
+            incorrect += check_parameters_match(cls)
+            cdoc = docscrape.ClassDoc(cls)
+            for method_name in cdoc.methods:
+                method = getattr(cls, method_name)
+                incorrect += check_parameters_match(method, cls=cls)
+            if hasattr(cls, '__call__') and \
+                    'of type object' not in str(cls.__call__):
+                incorrect += check_parameters_match(cls.__call__, cls)
+        functions = inspect.getmembers(module, inspect.isfunction)
+        for fname, func in functions:
+            if fname.startswith('_'):
+                continue
+            incorrect += check_parameters_match(func)
+    incorrect = sorted(list(set(incorrect)))
+    msg = '\n' + '\n'.join(incorrect)
+    msg += '\n%d error%s' % (len(incorrect), 's' if len(incorrect) == 1 else '')
+    if len(incorrect) > 0:
+        raise AssertionError(msg)
+
+
+run_tests_if_main()

vispy/util/tests/test_emitter_group.py

@@ -0,0 +1,262 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+import unittest
+import copy
+
+from vispy.util.event import Event, EventEmitter, EmitterGroup
+from vispy.util import use_log_level
+from vispy.testing import run_tests_if_main, assert_true, assert_raises
+
+
+class BasicEvent(Event):
+    pass
+
+
+class TypedEvent(Event):
+
+    def __init__(self, **kwargs):
+        kwargs['type'] = 'typed_event'
+        Event.__init__(self, **kwargs)
+
+
+class TestGroups(unittest.TestCase):
+
+    def test_group_construction(self):
+        """The EmitterGroup basic construction"""
+        grp = EmitterGroup(em1=Event,
+                           em2=BasicEvent,
+                           em3=TypedEvent)
+
+        grp.em1.connect(self.record_event)
+        grp.em2.connect(self.record_event)
+        grp.em3.connect(self.record_event)
+        self.result = None
+        ev = grp.em1()
+        self.assert_result(event=ev, type='em1', event_class=Event)
+        ev = grp.em2()
+        self.assert_result(event=ev, type='em2', event_class=BasicEvent)
+        ev = grp.em3()
+        self.assert_result(
+            event=ev,
+            type='typed_event',
+            event_class=TypedEvent)
+
+    def test_group_add_emitter(self):
+        """The EmitterGroup.add"""
+        grp = EmitterGroup(em1=Event)
+        grp.em1.connect(self.record_event)
+        self.result = None
+        ev = grp.em1()
+        self.assert_result(event=ev, type='em1')
+
+        grp.add(em2=BasicEvent)
+        grp.em2.connect(self.record_event)
+        ev = grp.em2()
+        self.assert_result(event=ev, type='em2', event_class=BasicEvent)
+
+        grp.add(em3=TypedEvent)
+        grp.em3.connect(self.record_event)
+        ev = grp.em3(test_key=2)
+        self.assert_result(
+            event=ev,
+            type='typed_event',
+            event_class=TypedEvent,
+            test_key=2)
+
+        try:
+            grp.add(em3=Event)
+            assert False, "Double-added emitter"
+        except ValueError:
+            pass
+
+        try:
+            grp.add(add=Event)
+            assert False, "Added event with invalid name"
+        except ValueError:
+            pass
+
+    def test_group_block(self):
+        """EmitterGroup.block_all"""
+        grp = EmitterGroup(em1=Event, em2=Event)
+
+        def cb(ev):
+            self.result = 1
+        grp.em1.connect(self.record_event)
+        grp.em2.connect(self.record_event)
+        grp.connect(cb)
+
+        self.result = None
+        grp.block_all()
+        try:
+            grp.em1()
+            grp.em2()
+            grp(type='test_event')
+        finally:
+            grp.unblock_all()
+        assert self.result is None
+
+    def test_group_ignore(self):
+        """EmitterGroup.block_all"""
+        grp = EmitterGroup(em1=Event)
+        grp.em1.connect(self.error_event)
+        with use_log_level('warning',
+                           record=True, print_msg=False) as emit_list:
+            grp.em1()
+        assert_true(len(emit_list) >= 1)
+        grp.ignore_callback_errors = False
+        assert_raises(RuntimeError, grp.em1)
+        grp.ignore_callback_errors = True
+        with use_log_level('warning',
+                           record=True, print_msg=False) as emit_list:
+            grp.em1()
+        assert_true(len(emit_list) >= 1)
+
+    def test_group_disconnect(self):
+        """EmitterGroup.disconnect"""
+        grp = EmitterGroup(em1=Event)
+
+        assert len(grp.em1.callbacks) == 0, grp.em1.callbacks
+        grp.connect(self.record_event)
+        assert len(grp.em1.callbacks) == 1
+        grp.add(em2=Event)
+        assert len(grp.em2.callbacks) == 1
+        grp.disconnect()
+        assert len(grp.em1.callbacks) == 0
+        assert len(grp.em2.callbacks) == 0
+
+    def test_group_autoconnect(self):
+        """The EmitterGroup auto-connect"""
+        class Source:
+
+            def on_em1(self, ev):
+                self.result = 1
+
+            def em2_event(self, ev):
+                self.result = 2
+
+            def em3_event(self, ev):
+                self.result = 3
+        src = Source()
+        grp = EmitterGroup(source=src, em1=Event, auto_connect=False)
+        src.result = None
+        grp.em1()
+        assert src.result is None
+
+        grp = EmitterGroup(source=src, em1=Event, auto_connect=True)
+        src.result = None
+        grp.em1()
+        assert src.result == 1
+
+        grp.auto_connect_format = "%s_event"
+        grp.add(em2=Event)
+        src.result = None
+        grp.em2()
+        assert src.result == 2
+
+        grp.add(em3=Event, auto_connect=False)
+        src.result = None
+        grp.em3()
+        assert src.result is None
+
+    def test_add_custom_emitter(self):
+        class Emitter(EventEmitter):
+
+            def _prepare_event(self, *args, **kwargs):
+                ev = super(Emitter, self)._prepare_event(*args, **kwargs)
+                ev.test_key = 1
+                return ev
+
+        class Source:
+            pass
+        src = Source()
+
+        grp = EmitterGroup(source=src, em1=Emitter(type='test_event1'))
+        grp.em1.connect(self.record_event)
+        self.result = None
+        ev = grp.em1()
+        self.assert_result(
+            event=ev,
+            test_key=1,
+            type='test_event1',
+            source=src)
+
+        grp.add(em2=Emitter(type='test_event2'))
+        grp.em2.connect(self.record_event)
+        self.result = None
+        ev = grp.em2()
+        self.assert_result(
+            event=ev,
+            test_key=1,
+            type='test_event2',
+            source=src)
+
+    def test_group_connect(self):
+        grp = EmitterGroup(source=self, em1=Event)
+        grp.connect(self.record_event)
+        self.result = None
+        ev = grp.em1(test_key=1)
+        self.assert_result(
+            event=ev,
+            source=self,
+            sources=[
+                self,
+                self],
+            test_key=1)
+
+    def record_event(self, ev, key=None):
+        # get a copy of all event attributes because these may change
+        # as the event is passed around; we want to know exactly what the event
+        # looked like when it reached this callback.
+        names = [name for name in dir(ev) if name[0] != '_']
+        attrs = {}
+        for name in names:
+            val = getattr(ev, name)
+            if name == 'source':
+                attrs[name] = val
+            elif name == 'sources':
+                attrs[name] = val[:]
+            else:
+                try:
+                    attrs[name] = copy.deepcopy(val)
+                except Exception:
+                    try:
+                        attrs[name] = copy.copy(val)
+                    except Exception:
+                        attrs[name] = val
+        if key is None:
+            self.result = ev, attrs
+        else:
+            if not hasattr(self, 'result') or self.result is None:
+                self.result = {}
+            self.result[key] = ev, attrs
+
+    def error_event(self, ev, key=None):
+        raise RuntimeError('Errored')
+
+    def assert_result(self, key=None, **kwargs):
+        assert (hasattr(self, 'result') and self.result is not None), \
+            "No event recorded"
+
+        if key is None:
+            event, event_attrs = self.result
+        else:
+            event, event_attrs = self.result[key]
+
+        assert isinstance(event, Event), "Emitted object is not Event instance"
+
+        for name, val in kwargs.items():
+            if name == 'event':
+                assert event is val, "Event objects do not match"
+
+            elif name == 'event_class':
+                assert isinstance(event, val), \
+                    "Emitted object is not instance of %s" % val.__name__
+
+            else:
+                attr = event_attrs[name]
+                assert (attr == val), "Event.%s != %s  (%s)" % (
+                    name, str(val), str(attr))
+
+
+run_tests_if_main()