vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/scene/tests/test_canvas.py

@@ -0,0 +1,119 @@
+# -*- 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 import gloo, scene
+from vispy.testing import requires_application, TestingCanvas
+from vispy.visuals.transforms import STTransform
+
+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 TestingCanvas(size=(125, 125), show=True, title='run') as c:
+        view = c.central_widget.add_view()
+
+        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 = scene.visuals.Image(im1, parent=view.scene)
+        image1.transform = STTransform(translate=(20, 20, 0))
+        image2 = scene.visuals.Image(im2, parent=view.scene)
+        image2.transform = STTransform(translate=(0, 0, -1))
+        if blend_func:
+            image1.set_gl_state(preset='translucent', blend_func=blend_func)
+            image2.set_gl_state(preset='translucent', blend_func=blend_func)
+
+        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
+            assert (rgba_result[..., 3] != 255).any()
+
+
+@requires_application()
+def test_picking_basic():
+    """Test basic picking behavior.
+
+    Based on https://github.com/vispy/vispy/issues/2107.
+
+    """
+    with TestingCanvas(size=(125, 125), show=True, title='run') as c:
+        view = c.central_widget.add_view()
+        view.margin = 5  # add empty space where there are no visuals
+        view.camera = 'panzoom'
+
+        x = np.linspace(0, 400, 100)
+        y = np.linspace(0, 200, 100)
+        line = scene.Line(np.array((x, y)).T.astype(np.float32))
+        line.interactive = True
+        view.add(line)
+        view.camera.set_range()
+
+        c.render()  # initial basic draw
+        for _ in range(2):  # run picking twice to make sure it is repeatable
+            # get Visuals on a Canvas point that Line is drawn on
+            picked_visuals = c.visuals_at((100, 25))
+            assert len(picked_visuals) == 2
+            assert any(isinstance(vis, scene.ViewBox) for vis in picked_visuals)
+            assert any(isinstance(vis, scene.Line) for vis in picked_visuals)
+
+
+@requires_application()
+@pytest.mark.parametrize(
+    'preset',
+    [
+        'opaque', 'additive', 'translucent',
+    ])
+def test_blend_presets(preset):
+    """Test blending presets render a canvas to an array.
+
+    Different blending presets are used to test that they properly set
+    blend equations.
+
+    """
+    with TestingCanvas(size=(125, 125), show=True, title='run') as c:
+        view = c.central_widget.add_view()
+        im1 = np.zeros((100, 100, 4)).astype(np.float32)
+        im1[:, :, 1] = 1
+        im1[:, :, 3] = .4
+        # Create the image
+        image1 = scene.visuals.Image(im1, parent=view.scene)
+        image1.transform = STTransform(translate=(20, 20, -1))
+
+        gloo.set_state(blend_equation='min')
+        image1.set_gl_state(preset)
+
+        rgba_result = c.render()
+        assert not np.allclose(rgba_result[..., :3], 0)

vispy/scene/tests/test_node.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+from vispy.scene.node import Node
+from vispy.testing import (requires_application, TestingCanvas,
+                           run_tests_if_main, raises)
+from vispy.visuals.transforms import STTransform
+import numpy as np
+
+
+class EventCheck(object):
+    def __init__(self, emitter):
+        self._events = []
+        self.emitter = emitter
+        emitter.connect(self.callback)
+
+    def callback(self, event):
+        self._events.append(event)
+
+    @property
+    def events(self):
+        ev = self._events
+        self._events = []
+        return ev
+
+
+@requires_application()
+def test_topology():
+    c = TestingCanvas()
+    assert c.scene.canvas is c
+    with raises(AttributeError):
+        c.foo = 'bar'
+
+    w = c.central_widget
+    assert w.parent is c.scene
+    assert w.scene_node is c.scene
+    assert w.document_node is c.scene
+
+    g = w.add_grid()
+    with raises(AttributeError):
+        g.foo = 'bar'
+
+    grid_check = EventCheck(g.events.children_change)
+
+    v1 = g.add_view(row=0, col=0)
+    assert v1.parent is g
+    assert v1.scene_node is c.scene
+
+    assert len(grid_check.events) == 1
+
+    v2 = g.add_view(row=1, col=0)
+    assert v2.parent is g
+    assert v2.scene_node is c.scene
+    assert v2.document_node is c.scene
+
+    assert len(grid_check.events) == 1
+
+    n1 = Node()
+    n1_parent_check = EventCheck(n1.events.parent_change)
+    n1_child_check = EventCheck(n1.events.children_change)
+    v1.add(n1)
+    assert len(n1_parent_check.events) == 1
+    assert n1.parent is v1.scene
+    assert n1.scene_node is v1.scene
+    assert n1.document_node is c.scene
+
+    n2 = Node(parent=n1)
+    n2_parent_check = EventCheck(n2.events.parent_change)
+    assert n2.parent is n1
+    assert n2.scene_node is v1.scene
+    assert n2.document_node is c.scene
+    assert len(n1_child_check.events) == 1
+
+    assert len(grid_check.events) == 2
+
+    v2.add(n1)
+    assert len(grid_check.events) == 2
+    assert len(n1_parent_check.events) == 1
+    assert len(n2_parent_check.events) == 1
+    assert n1.parent is v2.scene
+    assert n2.scene_node is v2.scene
+    assert n2.document_node is c.scene
+
+
+def test_transforms():
+    # test transform mapping between nodes
+    root = Node()
+    n1 = Node(parent=root)
+    n2 = Node(parent=n1)
+    n3 = Node(parent=root)
+    n4 = Node(parent=n3)
+
+    n1.transform = STTransform(scale=(0.1, 0.1), translate=(7, 6))
+    n2.transform = STTransform(scale=(0.2, 0.3), translate=(5, 4))
+    n3.transform = STTransform(scale=(0.4, 0.5), translate=(3, 2))
+    n4.transform = STTransform(scale=(0.6, 0.7), translate=(1, 0))
+
+    assert np.allclose(n1.transform.map((0, 0))[:2], (7, 6))
+    assert np.allclose(n1.node_transform(root).map((0, 0))[:2], (7, 6))
+    assert np.allclose(n2.transform.map((0, 0))[:2], (5, 4))
+    assert np.allclose(n2.node_transform(root).map((0, 0))[:2], 
+                       (5*0.1+7, 4*0.1+6))
+    assert np.allclose(root.node_transform(n1).map((0, 0))[:2],
+                       (-7/0.1, -6/0.1))
+    assert np.allclose(root.node_transform(n2).map((0, 0))[:2],
+                       ((-7/0.1-5)/0.2, (-6/0.1-4)/0.3))
+
+    # just check that we can assemble transforms correctly mapping across the
+    # scenegraph
+    assert n2.node_path(n4) == ([n2, n1, root], [n3, n4])
+    assert n4.node_path(n2) == ([n4, n3, root], [n1, n2])
+    assert n2.node_path(root) == ([n2, n1, root], [])
+    assert root.node_path(n4) == ([root], [n3, n4])
+    assert n2.node_path_transforms(n4) == [n4.transform.inverse, 
+                                           n3.transform.inverse, 
+                                           n1.transform, n2.transform]
+    assert n4.node_path_transforms(n2) == [n2.transform.inverse,
+                                           n1.transform.inverse,
+                                           n3.transform, n4.transform]
+
+    pts = np.array([[0, 0], [1, 1], [-56.3, 800.2]])
+    assert np.all(n2.node_transform(n1).map(pts) == n2.transform.map(pts))
+    assert np.all(n2.node_transform(root).map(pts) == 
+                  n1.transform.map(n2.transform.map(pts)))
+    assert np.all(n1.node_transform(n3).map(pts) == 
+                  n3.transform.inverse.map(n1.transform.map(pts)))
+    assert np.all(n2.node_transform(n3).map(pts) == 
+                  n3.transform.inverse.map(
+                      n1.transform.map(n2.transform.map(pts))))
+    assert np.all(n2.node_transform(n4).map(pts) == 
+                  n4.transform.inverse.map(n3.transform.inverse.map(
+                      n1.transform.map(n2.transform.map(pts)))))
+
+    # test transforms still work after reparenting
+    n3.parent = n1
+    assert np.all(n2.node_transform(n4).map(pts) == n4.transform.inverse.map(
+        n3.transform.inverse.map(n2.transform.map(pts))))
+
+    # test transform simplification
+    assert np.all(n2.node_transform(n4).map(pts) == 
+                  n2.node_transform(n4).simplified.map(pts))    
+
+
+run_tests_if_main()

vispy/scene/tests/test_visuals.py

@@ -0,0 +1,141 @@
+import pytest
+
+from vispy.scene import visuals, Node
+from vispy.scene.visuals import VisualNode
+import vispy.visuals
+
+
+def test_docstrings():
+    # test that docstring insertions worked for all Visual+Node subclasses
+    for name in dir(visuals):
+        obj = getattr(visuals, name)
+        if isinstance(obj, type) and issubclass(obj, Node):
+            if obj is Node or obj is VisualNode:
+                continue
+            assert "This class inherits from visuals." in obj.__doc__
+            assert "parent : Node" in obj.__doc__
+
+
+def test_visual_node_generation():
+    # test that all Visual classes also have Visual+Node classes
+    visuals = []
+    for name in dir(vispy.visuals):
+        obj = getattr(vispy.visuals, name)
+        if isinstance(obj, type) and issubclass(obj, Node):
+            if obj is Node:
+                continue
+            assert name.endswith('Visual')
+            vis_node = getattr(visuals, name[:-6])
+            assert issubclass(vis_node, Node)
+            assert issubclass(vis_node, obj)
+
+
+def test_push_gl_state():
+    node = vispy.visuals.MeshVisual()
+    og_gl_state = node._vshare.gl_state.copy()
+    node.push_gl_state(blend=False, depth_test=False)
+    assert node._vshare.gl_state != og_gl_state
+    # preset is always set, unset kwargs should be absent
+    assert node._vshare.gl_state == {
+        "preset": None,
+        "blend": False,
+        "depth_test": False,
+    }
+    node.pop_gl_state()
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_push_gl_state_update():
+    node = vispy.visuals.MeshVisual()
+    og_gl_state = node._vshare.gl_state.copy()
+    assert "blend" not in og_gl_state
+    assert node._vshare.gl_state["depth_test"]
+
+    node.push_gl_state_update(blend=False, depth_test=False)
+    assert node._vshare.gl_state != og_gl_state
+    assert not node._vshare.gl_state["blend"]
+    assert not node._vshare.gl_state["depth_test"]
+
+    node.pop_gl_state()
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_pop_empty_gl_state():
+    node = vispy.visuals.MeshVisual()
+    assert node._prev_gl_state == []
+    og_gl_state = node._vshare.gl_state.copy()
+    node.pop_gl_state()
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_update_gl_state():
+    node = vispy.visuals.MeshVisual()
+
+    og_gl_state = node._vshare.gl_state.copy()
+    assert og_gl_state
+    og_gl_state["blend"] = False
+
+    node.update_gl_state(blend=True)
+
+    # check that the state was updated
+    assert node._vshare.gl_state.pop("blend") != og_gl_state.pop("blend")
+    # the rest of the state should be unchanged
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_update_gl_state_context_manager():
+    node = vispy.visuals.MeshVisual()
+
+    node.set_gl_state(blend=False)
+    og_gl_state = node._vshare.gl_state.copy()
+
+    with node.update_gl_state(blend=True):
+        # check that the state was updated
+        assert node._vshare.gl_state == {**og_gl_state, "blend": True}
+
+    # the update should be reverted once out of the context
+    assert node._vshare.gl_state == og_gl_state
+
+
+def test_set_gl_state():
+    node = vispy.visuals.MeshVisual()
+
+    node.set_gl_state(blend=False, depth_test=False)
+    # preset is always set, unset kwargs should be absent
+    assert node._vshare.gl_state == {
+        "preset": None,
+        "blend": False,
+        "depth_test": False,
+    }
+
+    node.set_gl_state(blend=False)
+    # preset is always set, unset kwargs should be absent
+    assert node._vshare.gl_state == {"preset": None, "blend": False}
+
+
+def test_set_gl_state_context_manager():
+    node = vispy.visuals.MeshVisual()
+
+    node.set_gl_state(blend=False)
+    og_gl_state = node._vshare.gl_state.copy()
+
+    with node.set_gl_state(blend=True):
+        # preset is always set, unset kwargs should be absent
+        assert node._vshare.gl_state == {"preset": None, "blend": True}
+
+    # the update should be reverted once out of the context
+    assert node._vshare.gl_state == og_gl_state
+
+
+@pytest.mark.parametrize("enable_picking", [True, False])
+def test_picking_context(enable_picking):
+    mesh = visuals.Mesh()
+    mesh.picking = not enable_picking
+
+    assert mesh.picking != enable_picking
+
+    with mesh.set_picking(picking=enable_picking) as p:
+        assert p == enable_picking
+        assert mesh.picking == enable_picking
+
+    assert mesh.picking != enable_picking

vispy/scene/visuals.py

@@ -0,0 +1,276 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""
+The classes in scene.visuals are visuals that may be added to a scenegraph
+using the methods and properties defined in `vispy.scene.Node` such as name,
+visible, parent, children, etc...
+
+These classes are automatically generated by mixing `vispy.scene.Node` with
+the Visual classes found in `vispy.visuals`.
+
+For developing custom visuals, it is recommended to subclass from
+`vispy.visuals.Visual` rather than `vispy.scene.Node`.
+"""
+import re
+import weakref
+
+from .. import visuals
+from .node import Node
+from ..visuals.filters import Alpha, PickingFilter
+from typing import TypeVar
+
+
+_T = TypeVar("_T")
+
+
+class VisualNode(Node):
+    _next_id = 1
+    _visual_ids = weakref.WeakValueDictionary()
+
+    def __init__(self, parent=None, name=None):
+        Node.__init__(self, parent=parent, name=name,
+                      transforms=self.transforms)
+        self.interactive = False
+        self._opacity_filter = Alpha()
+        self.attach(self._opacity_filter)
+
+        self._id = VisualNode._next_id
+        VisualNode._visual_ids[self._id] = self
+        VisualNode._next_id += 1
+        self._picking_filter = PickingFilter(id_=self._id)
+        self.attach(self._picking_filter)
+
+    def _update_opacity(self):
+        self._opacity_filter.alpha = self._opacity
+        self.update()
+
+    def _set_clipper(self, node, clipper):
+        """Assign a clipper that is inherited from a parent node.
+
+        If *clipper* is None, then remove any clippers for *node*.
+        """
+        if node in self._clippers:
+            self.detach(self._clippers.pop(node))
+        if clipper is not None:
+            self.attach(clipper)
+            self._clippers[node] = clipper
+
+    @property
+    def picking(self):
+        """Boolean that determines whether this node (and its children) are
+        drawn in picking mode.
+        """
+        return self._picking
+
+    @picking.setter
+    def picking(self, p):
+        for c in self.children:
+            c.picking = p
+        if self._picking == p:
+            return
+        self._picking = p
+        self._picking_filter.enabled = p
+        if p:
+            self.push_gl_state_update(blend=False)
+        else:
+            self.pop_gl_state()
+
+    def _update_trsys(self, event):
+        """Transform object(s) have changed for this Node; assign these to the
+        visual's TransformSystem.
+        """
+        doc = self.document_node
+        scene = self.scene_node
+        root = self.root_node
+        self.transforms.visual_transform = self.node_transform(scene)
+        self.transforms.scene_transform = scene.node_transform(doc)
+        self.transforms.document_transform = doc.node_transform(root)
+
+        Node._update_trsys(self, event)
+
+    @property
+    def interactive(self):
+        """Whether this widget should be allowed to accept mouse and touch
+        events.
+        """
+        return self._interactive
+
+    @interactive.setter
+    def interactive(self, i):
+        self._interactive = i
+
+    def draw(self):
+        if self.picking and not self.interactive:
+            return
+        self._visual_superclass.draw(self)
+
+
+def create_visual_node(subclass: _T) -> _T:
+    # Create a new subclass of Node.
+
+    # Decide on new class name
+    clsname = subclass.__name__
+    if not (clsname.endswith('Visual') and
+            issubclass(subclass, visuals.BaseVisual)):
+        raise RuntimeError('Class "%s" must end with Visual, and must '
+                           'subclass BaseVisual' % clsname)
+    clsname = clsname[:-6]
+
+    # Generate new docstring based on visual docstring
+    try:
+        doc = generate_docstring(subclass, clsname)
+    except Exception:
+        # If parsing fails, just return the original Visual docstring
+        doc = subclass.__doc__
+
+    # New __init__ method
+    def __init__(self, *args, **kwargs):
+        parent = kwargs.pop('parent', None)
+        name = kwargs.pop('name', None)
+        self.name = name  # to allow __str__ before Node.__init__
+        self._visual_superclass = subclass
+
+        subclass.__init__(self, *args, **kwargs)
+        self.unfreeze()
+        VisualNode.__init__(self, parent=parent, name=name)
+        self.freeze()
+
+    # Create new class
+    cls = type(clsname, (VisualNode, subclass),
+               {'__init__': __init__, '__doc__': doc})
+
+    return cls
+
+
+def generate_docstring(subclass, clsname):
+    # Generate a Visual+Node docstring by modifying the Visual's docstring
+    # to include information about Node inheritance and extra init args.
+
+    sc_doc = subclass.__doc__
+    if sc_doc is None:
+        sc_doc = ""
+
+    # find locations within docstring to insert new parameters
+    lines = sc_doc.split("\n")
+
+    # discard blank lines at start
+    while lines and lines[0].strip() == '':
+        lines.pop(0)
+
+    i = 0
+    params_started = False
+    param_indent = None
+    first_blank = None
+    param_end = None
+    while i < len(lines):
+        line = lines[i]
+        # ignore blank lines and '------' lines
+        if re.search(r'\w', line):
+            indent = len(line) - len(line.lstrip())
+            # If Params section has already started, check for end of params
+            # (that is where we will insert new params)
+            if params_started:
+                if indent < param_indent:
+                    break
+                elif indent == param_indent:
+                    # might be end of parameters block..
+                    if re.match(r'\s*[a-zA-Z0-9_]+\s*:\s*\S+', line) is None:
+                        break
+                param_end = i + 1
+
+            # Check for beginning of params section
+            elif re.match(r'\s*Parameters\s*', line):
+                params_started = True
+                param_indent = indent
+                if first_blank is None:
+                    first_blank = i
+
+        # Check for first blank line
+        # (this is where the Node inheritance description will be
+        # inserted)
+        elif first_blank is None and line.strip() == '':
+            first_blank = i
+
+        i += 1
+        if i == len(lines) and param_end is None:
+            # reached end of docstring; insert here
+            param_end = i
+
+    # If original docstring has no params heading, we need to generate it.
+    if not params_started:
+        lines.extend(["", "    Parameters", "    ----------"])
+        param_end = len(lines)
+        if first_blank is None:
+            first_blank = param_end - 3
+        params_started = True
+
+    # build class and parameter description strings
+    class_desc = ("\n    This class inherits from visuals.%sVisual and "
+                  "scene.Node, allowing the visual to be placed inside a "
+                  "scenegraph.\n" % (clsname))
+    parm_doc = ("    parent : Node\n"
+                "        The parent node to assign to this node (optional).\n"
+                "    name : string\n"
+                "        A name for this node, used primarily for debugging\n"
+                "        (optional).")
+
+    # assemble all docstring parts
+    lines = (lines[:first_blank] +
+             [class_desc] +
+             lines[first_blank:param_end] +
+             [parm_doc] +
+             lines[param_end:])
+
+    doc = '\n'.join(lines)
+    return doc
+
+# This is _not_ automated to help with auto-completion of IDEs,
+# python REPL and IPython.
+# Explicitly initializing these members allow IDEs to lookup
+# and provide auto-completion. One problem is the fact that
+# Docstrings are _not_ looked up correctly by IDEs, since they
+# are attached programatically in the create_visual_node call.
+# However, help(vispy.scene.FooVisual) still works
+
+Arrow = create_visual_node(visuals.ArrowVisual)
+Axis = create_visual_node(visuals.AxisVisual)
+Box = create_visual_node(visuals.BoxVisual)
+ColorBar = create_visual_node(visuals.ColorBarVisual)
+Compound = create_visual_node(visuals.CompoundVisual)
+Cube = create_visual_node(visuals.CubeVisual)
+Ellipse = create_visual_node(visuals.EllipseVisual)
+Graph = create_visual_node(visuals.GraphVisual)
+GridLines = create_visual_node(visuals.GridLinesVisual)
+GridMesh = create_visual_node(visuals.GridMeshVisual)
+Histogram = create_visual_node(visuals.HistogramVisual)
+Image = create_visual_node(visuals.ImageVisual)
+ComplexImage = create_visual_node(visuals.ComplexImageVisual)
+InfiniteLine = create_visual_node(visuals.InfiniteLineVisual)
+InstancedMesh = create_visual_node(visuals.InstancedMeshVisual)
+Isocurve = create_visual_node(visuals.IsocurveVisual)
+Isoline = create_visual_node(visuals.IsolineVisual)
+Isosurface = create_visual_node(visuals.IsosurfaceVisual)
+Line = create_visual_node(visuals.LineVisual)
+LinearRegion = create_visual_node(visuals.LinearRegionVisual)
+LinePlot = create_visual_node(visuals.LinePlotVisual)
+Markers = create_visual_node(visuals.MarkersVisual)
+Mesh = create_visual_node(visuals.MeshVisual)
+MeshNormals = create_visual_node(visuals.MeshNormalsVisual)
+Plane = create_visual_node(visuals.PlaneVisual)
+Polygon = create_visual_node(visuals.PolygonVisual)
+Rectangle = create_visual_node(visuals.RectangleVisual)
+RegularPolygon = create_visual_node(visuals.RegularPolygonVisual)
+ScrollingLines = create_visual_node(visuals.ScrollingLinesVisual)
+Spectrogram = create_visual_node(visuals.SpectrogramVisual)
+Sphere = create_visual_node(visuals.SphereVisual)
+SurfacePlot = create_visual_node(visuals.SurfacePlotVisual)
+Text = create_visual_node(visuals.TextVisual)
+Tube = create_visual_node(visuals.TubeVisual)
+# Visual = create_visual_node(visuals.Visual)  # Should not be created
+Volume = create_visual_node(visuals.VolumeVisual)
+Windbarb = create_visual_node(visuals.WindbarbVisual)
+XYZAxis = create_visual_node(visuals.XYZAxisVisual)
+
+__all__ = [name for (name, obj) in globals().items()
+           if isinstance(obj, type) and issubclass(obj, VisualNode)]

vispy/scene/widgets/__init__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""
+The vispy.scene.widgets namespace provides a range of widgets to allow
+user interaction. Widgets are rectangular Visual objects such as buttons
+and sliders.
+"""
+__all__ = ['AxisWidget', 'Console', 'ColorBarWidget', 'Grid',
+           'Label', 'ViewBox', 'Widget']
+
+from .console import Console  # noqa
+from .grid import Grid  # noqa
+from .viewbox import ViewBox  # noqa
+from .widget import Widget  # noqa
+from .axis import AxisWidget  # noqa
+from .colorbar import ColorBarWidget  # noqa
+from .label import Label  # noqa