vispy 0.15.1__cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.15.2__cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

vispy/scene/widgets/grid.py

@@ -4,7 +4,11 @@
 """Grid widget for providing a gridded layout to child widgets."""
 
 from __future__ import division
+
+from typing import Tuple, Union, Dict
+
 import numpy as np
+from numpy.typing import NDArray
 
 from vispy.geometry import Rect
 from .widget import Widget
@@ -21,17 +25,19 @@ class Grid(Widget):
 
     Parameters
     ----------
-    spacing : int
-        Spacing between widgets.
+    spacing : int | tuple[int, int]
+        Spacing between widgets. If `tuple` then it must be of length two, the first element
+        being `width_spacing` and the second being `height_spacing`.
     **kwargs : dict
         Keyword arguments to pass to `Widget`.
     """
 
-    def __init__(self, spacing=6, **kwargs):
+    def __init__(self, spacing=0, **kwargs):
         """Create solver and basic grid parameters."""
         self._next_cell = [0, 0]  # row, col
         self._cells = {}
         self._grid_widgets = {}
+
         self.spacing = spacing
         self._n_added = 0
         self._default_class = ViewBox  # what to add when __getitem__ is used
@@ -45,9 +51,6 @@ class Grid(Widget):
         self._width_grid = None
         self._height_grid = None
 
-        # self._height_stay = None
-        # self._width_stay = None
-
         Widget.__init__(self, **kwargs)
 
     def __getitem__(self, idxs):
@@ -256,53 +259,129 @@ class Grid(Widget):
             locs[r:r + rs, c:c + cs] = key
         return locs
 
+    @property
+    def spacing(self):
+        """
+        The spacing between individual Viewbox widgets in the grid.
+        """
+        return self._spacing
+
+    @spacing.setter
+    def spacing(self, value: Union[int, Tuple[int, int]]):
+        if not (
+            isinstance(value, int)
+            or isinstance(value, tuple)
+            and len(value) == 2
+            and isinstance(value[0], int)
+            and isinstance(value[1], int)
+        ):
+            raise ValueError('spacing must be of type int | tuple[int, int]')
+
+        self._spacing = value
+        self._need_solver_recreate = True
+
     def __repr__(self):
         return (('<Grid at %s:\n' % hex(id(self))) +
                 str(self.layout_array + 1) + '>')
 
     @staticmethod
-    def _add_total_width_constraints(solver, width_grid, _var_w):
-        for ws in width_grid:
-            width_expr = ws[0]
-            for w in ws[1:]:
-                width_expr += w
-            solver.addConstraint(width_expr == _var_w)
+    def _add_total_dim_length_constraints(solver: Solver, grid_dim_variables: NDArray[Variable],
+                                          n_added: int, _var_dim_length: Variable, spacing: float):
+        """Add constraint: total height == sum(col heights) + sum(spacing).
 
-    @staticmethod
-    def _add_total_height_constraints(solver, height_grid, _var_h):
-        for hs in height_grid:
-            height_expr = hs[0]
-            for h in hs[1:]:
-                height_expr += h
-            solver.addConstraint(height_expr == _var_h)
+        The total height of the grid is constrained to be equal to the sum of the heights of
+        its columns, including spacing between widgets.
+
+        Parameters
+        ----------
+        solver: Solver
+            Solver for a system of linear equations.
+        grid_dim_variables: NDArray[Variable]:
+            The grid of width or height variables of either shape col * row or row * col with each element being a
+            Variable in the solver representing the height or width of each grid box.
+        n_added: int
+            The number of ViewBoxes added to the grid.
+        _var_dim_length: Variable
+            The solver variable representing either total width or height of the grid.
+        spacing: float
+            The amount of spacing between single adjacent Viewbox widgets in the grid.
+        """
+        total_spacing = 0
+        if n_added > 1:
+            for _ in range(grid_dim_variables.shape[1] - 1):
+                total_spacing += spacing
+
+        for ds in grid_dim_variables:
+            dim_length_expr = ds[0]
+            for d in ds[1:]:
+                dim_length_expr += d
+            dim_length_expr += total_spacing
+            solver.addConstraint(dim_length_expr == _var_dim_length)
 
     @staticmethod
-    def _add_gridding_width_constraints(solver, width_grid):
+    def _add_gridding_dim_constraints(solver: Solver, grid_dim_variables: NDArray[Variable]):
+        """Add constraint: all viewbox dims in each dimension are equal.
+
+        With all dims the reserved space for a widget with a col_span and row_span of 1 is meant, e.g. we have 3
+        widgets arranged in columns or rows with col_span or row_span 1 and those are being constrained to all be of
+        width/height 100. In other words the same dim length is reserved for each position in the grid, not taking
+        into account the spacing between grid positions.
+
+        Parameters
+        ----------
+        solver: Solver
+            Solver for a system of linear equations.
+        grid_dim_variables:
+            The grid of width or height variables of either shape col * row or row * col with each element being a
+            Variable in the solver representing the height or width of each grid box.
+        """
         # access widths of one "y", different x
-        for ws in width_grid.T:
-            for w in ws[1:]:
-                solver.addConstraint(ws[0] == w)
+        for ds in grid_dim_variables.T:
+            for d in ds[1:]:
+                solver.addConstraint(ds[0] == d)
 
     @staticmethod
-    def _add_gridding_height_constraints(solver, height_grid):
-        # access heights of one "y"
-        for hs in height_grid.T:
-            for h in hs[1:]:
-                solver.addConstraint(hs[0] == h)
+    def _add_stretch_constraints(solver: Solver, width_grid: NDArray[Variable] , height_grid: NDArray[Variable],
+                                 grid_widgets: Dict[int, Tuple[int, int, int, int, ViewBox]],
+                                 widget_grid: NDArray[ViewBox]):
+        """
+        Add proportional stretch constraints to the linear system solver of the grid.
 
-    @staticmethod
-    def _add_stretch_constraints(solver, width_grid, height_grid,
-                                 grid_widgets, widget_grid):
+        This method enforces that grid rows and columns stretch in proportion
+        to the widgets' specified stretch factors. It uses weak constraints
+        so that proportionality is preserved when possible but can be violated
+        if stronger layout constraints are present.
+
+        Parameters
+        ----------
+        solver : Solver
+            Solver for a system of linear equations.
+        width_grid : NDArray[Variable]
+            The grid of width variables in the linear system of equations to be solved.
+        height_grid : NDArray[Variable]
+            The grid of height variables in the linear system of equations to be solved.
+        grid_widgets : dict[int, tuple[int, int, int, int, ViewBox]]
+            Dictionary mapping order of viewboxes added as int to their grid layout description:
+            (start_y, start_x, span_y, span_x, ViewBox).
+        widget_grid : NDArray[ViewBox]
+            Array of viewboxes in shape n_columns x n_rows.
+
+        Notes
+        -----
+        - Stretch constraints are added with 'weak' strength, allowing them to
+          be overridden by stronger constraints such as fixed sizes or min/max bounds.
+        - The constraint `total_size / stretch_factor` is used to maintain
+          proportional relationships among rows and columns.
+        """
         xmax = len(height_grid)
         ymax = len(width_grid)
 
-        stretch_widths = [[] for _ in range(0, ymax)]
-        stretch_heights = [[] for _ in range(0, xmax)]
+        stretch_widths = [[] for _ in range(ymax)]
+        stretch_heights = [[] for _ in range(xmax)]
 
         for (y, x, ys, xs, widget) in grid_widgets.values():
             for ws in width_grid[y:y+ys]:
                 total_w = np.sum(ws[x:x+xs])
-
                 for sw in stretch_widths[y:y+ys]:
                     sw.append((total_w, widget.stretch[0]))
 
@@ -339,14 +418,36 @@ class Grid(Widget):
                                      'weak')
 
     @staticmethod
-    def _add_widget_dim_constraints(solver, width_grid, height_grid,
-                                    total_var_w, total_var_h, grid_widgets):
+    def _add_widget_dim_constraints(solver: Solver, width_grid: NDArray[Variable], height_grid: NDArray[Variable],
+                                    total_var_w: Variable, total_var_h: Variable,
+                                    grid_widgets: Dict[int, Tuple[int, int, int, int, ViewBox]]):
+        """Add constraints based on min/max width/height of widgets.
+
+        These constraints ensure that each widget's dimensions stay within its
+        specified minimum and maximum values.
+
+        Parameters
+        ----------
+        solver : Solver
+            Solver for a system of linear equations.
+        width_grid : NDArray[Variable]
+            The grid of width variables in the linear system of equations to be solved.
+        height_grid : NDArray[Variable]
+            The grid of height variables in the linear system of equations to be solved.
+        total_var_w : Variable
+            The Variable representing the total width of the grid in the linear system of equations.
+        total_var_w : Variable
+            The Variable representing the total height of the grid in the linear system of equations.
+        grid_widgets : dict[int, tuple[int, int, int, int, ViewBox]]
+            Dictionary mapping order of viewboxes added as int to their grid layout description:
+            (start_y, start_x, span_y, span_x, ViewBox).
+                """
         assert(total_var_w is not None)
         assert(total_var_h is not None)
 
         for ws in width_grid:
             for w in ws:
-                solver.addConstraint(w >= 0,)
+                solver.addConstraint(w >= 0)
 
         for hs in height_grid:
             for h in hs:
@@ -375,6 +476,7 @@ class Grid(Widget):
                     solver.addConstraint(total_h <= total_var_h)
 
     def _recreate_solver(self):
+        """Recreate the linear system solver with all constraints."""
         self._solver.reset()
         self._var_w = Variable("w_rect")
         self._var_h = Variable("h_rect")
@@ -390,43 +492,40 @@ class Grid(Widget):
         self._solver.addConstraint(self._var_w >= 0)
         self._solver.addConstraint(self._var_h >= 0)
 
-        # self._height_stay = None
-        # self._width_stay = None
-
         # add widths
-        self._width_grid = np.array([[Variable("width(x: %s, y: %s)" % (x, y))
-                                      for x in range(0, xmax)]
-                                     for y in range(0, ymax)])
+        self._width_grid = np.array(
+            [
+                [Variable(f"width(x: {x}, y: {y})") for x in range(xmax)]
+                for y in range(ymax)
+            ]
+        )
 
         # add heights
-        self._height_grid = np.array([[Variable("height(x: %s, y: %s" % (x, y))
-                                       for y in range(0, ymax)]
-                                      for x in range(0, xmax)])
-
-        # setup stretch
-        stretch_grid = np.zeros(shape=(xmax, ymax, 2), dtype=float)
-        stretch_grid.fill(1)
-
-        for (_, val) in self._grid_widgets.items():
-            (y, x, ys, xs, widget) = val
-            stretch_grid[x:x+xs, y:y+ys] = widget.stretch
-
+        self._height_grid = np.array(
+            [
+                [Variable(f"height(x: {x}, y: {y})") for y in range(ymax)]
+                for x in range(xmax)
+            ]
+        )
+
+        if isinstance(self.spacing, tuple):
+            width_spacing, height_spacing = self.spacing
+        else:
+            width_spacing = height_spacing = self.spacing
         # even though these are REQUIRED, these should never fail
         # since they're added first, and thus the slack will "simply work".
-        Grid._add_total_width_constraints(self._solver,
-                                          self._width_grid, self._var_w)
-        Grid._add_total_height_constraints(self._solver,
-                                           self._height_grid, self._var_h)
+        Grid._add_total_dim_length_constraints(self._solver,
+                                          self._width_grid, self._n_added, self._var_w, width_spacing)
+        Grid._add_total_dim_length_constraints(self._solver,
+                                           self._height_grid, self._n_added, self._var_h, height_spacing)
 
         try:
             # these are REQUIRED constraints for width and height.
             # These are the constraints which can fail if
             # the corresponding dimension of the widget cannot be fit in the
             # grid.
-            Grid._add_gridding_width_constraints(self._solver,
-                                                 self._width_grid)
-            Grid._add_gridding_height_constraints(self._solver,
-                                                  self._height_grid)
+            Grid._add_gridding_dim_constraints(self._solver, self._width_grid)
+            Grid._add_gridding_dim_constraints(self._solver, self._height_grid)
         except UnsatisfiableConstraint:
             self._need_solver_recreate = True
 
@@ -436,24 +535,27 @@ class Grid(Widget):
                                       self._width_grid,
                                       self._height_grid,
                                       self._grid_widgets,
-                                      self._widget_grid)
+                                      self._widget_grid,
+                                      )
 
         Grid._add_widget_dim_constraints(self._solver,
                                          self._width_grid,
                                          self._height_grid,
                                          self._var_w,
                                          self._var_h,
-                                         self._grid_widgets)
+                                         self._grid_widgets
+                                         )
 
         self._solver.updateVariables()
 
     def _update_child_widget_dim(self):
+        """Solve the linear system of equations in order to assign Viewbox parameters such as position."""
         # think in terms of (x, y). (row, col) makes code harder to read
         ymax, xmax = self.grid_size
         if ymax <= 0 or xmax <= 0:
             return
 
-        rect = self.rect  # .padded(self.padding + self.margin)
+        rect = self.rect.padded(self.padding + self.margin)
         if rect.width <= 0 or rect.height <= 0:
             return
         if self._need_solver_recreate:
@@ -474,22 +576,40 @@ class Grid(Widget):
 
         value_vectorized = np.vectorize(lambda x: x.value())
 
-        for (_, val) in self._grid_widgets.items():
+        if isinstance(self.spacing, tuple):
+            width_spacing, height_spacing = self.spacing
+        else:
+            width_spacing = height_spacing = self.spacing
+
+        for index, (_, val) in enumerate(self._grid_widgets.items()):
             (row, col, rspan, cspan, widget) = val
 
+            # If spacing, always one spacing unit between 2 grid positions, even when span is > 1.
+            # If span is > 1, spacing will be added to the dim length of Viewbox
+            spacing_width_offset = col * width_spacing if self._n_added > 1 else 0
+            spacing_height_offset = row * height_spacing if self._n_added > 1 else 0
+
+            # Add one spacing unit to dim length of the Viewbox per grid positions the ViewBox spans if span > 1.
+            width_increase_spacing = width_spacing * (cspan - 1)
+            height_increase_spacing = height_spacing * (rspan - 1)
+
             width = np.sum(value_vectorized(
-                           self._width_grid[row][col:col+cspan]))
+                           self._width_grid[row][col:col+cspan])) + width_increase_spacing
             height = np.sum(value_vectorized(
-                            self._height_grid[col][row:row+rspan]))
+                            self._height_grid[col][row:row+rspan])) + height_increase_spacing
+
             if col == 0:
                 x = 0
             else:
-                x = np.sum(value_vectorized(self._width_grid[row][0:col]))
+                x = np.sum(value_vectorized(self._width_grid[row][:col])) + spacing_width_offset
 
             if row == 0:
                 y = 0
             else:
-                y = np.sum(value_vectorized(self._height_grid[col][0:row]))
+                y = np.sum(value_vectorized(self._height_grid[col][:row])) + spacing_height_offset
+
+            x += self.padding
+            y += self.padding
 
             if isinstance(widget, ViewBox):
                 widget.rect = Rect(x, y, width, height)

vispy/scene/widgets/widget.py

@@ -312,6 +312,17 @@ class Widget(Compound):
         self._update_line()
         self.update()
 
+    @property
+    def border_width(self):
+        """The width of the border."""
+        return self._border_width
+
+    @border_width.setter
+    def border_width(self, b):
+        self._border_width = float(b)
+        self._update_line()
+        self.update()
+
     @property
     def bgcolor(self):
         """The background color of the Widget."""

vispy/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.15.1'
-__version_tuple__ = version_tuple = (0, 15, 1)
+__version__ = version = '0.15.2'
+__version_tuple__ = version_tuple = (0, 15, 2)

{vispy-0.15.1.dist-info → vispy-0.15.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vispy
-Version: 0.15.1
+Version: 0.15.2
 Summary: Interactive visualization in Python
 Home-page: http://vispy.org
 Download-URL: https://pypi.python.org/pypi/vispy

{vispy-0.15.1.dist-info → vispy-0.15.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 vispy/__init__.py,sha256=Sm3hzOs_-fXTikZnwAFZoLOvETmFCw8BsSoAguXvhdY,902
 vispy/conftest.py,sha256=1qkMPiB5SHGll3Sbvz9iBIAVeyaIuW7YDw8VpfKTMzk,489
-vispy/version.py,sha256=tQzj2BXuQVT8ur10Vpw9erM-ZknJX1RqcwqYbcqo3NY,513
+vispy/version.py,sha256=KRKlaCoLoYRe3lmREqbhkmA_Yhx41a2BsvZ95EM3lt0,513
 vispy/app/__init__.py,sha256=bS3jZwya_8MmPiYQcoERJIoO5PotaahaOaOqVbhbH6Y,625
 vispy/app/_default_app.py,sha256=Iu-ILcsMAP7s6URR_0c7DKw04JtL6m8l01oKQYwvoPo,2421
 vispy/app/_detect_eventloop.py,sha256=hMht958_W6MVGEfJS7UMTRnIHyoODeJ6oVCaDXJZ5H8,6474
@@ -296,10 +296,10 @@ vispy/scene/widgets/anchor.py,sha256=gDhPq73VDtyCZDDEzGNLFW9tIMtAjDpjEToEn2pAXxQ
 vispy/scene/widgets/axis.py,sha256=NBeL6TuebyV5VCexWaOBW0OtNwF8k9r22nu5egDg52g,2954
 vispy/scene/widgets/colorbar.py,sha256=rLryyZim6W0_EYx5QdxW9o7WnBII43yAc_ShnoXvh_E,6158
 vispy/scene/widgets/console.py,sha256=wkon8nst3I0Pkga93QgVORhFicbVCLZE8tv7y9nfEmM,14013
-vispy/scene/widgets/grid.py,sha256=JaNLT0QK5p3ZrqJzaVZgjDqT48wvDHb2HVwj4e0yFvE,18656
+vispy/scene/widgets/grid.py,sha256=AMzQJa6xWrFkEkijBdRNYO73OADN2derhVVsasT8RNE,24800
 vispy/scene/widgets/label.py,sha256=2ynsXsQNgIRFFkLzftVr1p94nLYLRlr_WWATDuJq7-8,1308
 vispy/scene/widgets/viewbox.py,sha256=gZekx8GSoJj8vRvqJ7Hw5Y5L1kVCmQQrF_f5YQOkkE0,6674
-vispy/scene/widgets/widget.py,sha256=tJE2Ohm84GH_L1S9syQKbqYpYwOrm2kdY6CK0StUcL0,13863
+vispy/scene/widgets/widget.py,sha256=ao2Ie47Y-oZBpxgf0ix8RFMe4e4VsZqFepiKLxhnFrM,14124
 vispy/scene/widgets/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/scene/widgets/tests/test_colorbar.py,sha256=Yp1A_nZKC9NTSzdTM6OYKAcMEk0QH1CYUlhpMuxmQ3A,1362
 vispy/testing/__init__.py,sha256=k7KagAl3LhX_2EblFK6x_ekO23Un_9CAIuHdEgHdmps,2437
@@ -500,7 +500,7 @@ vispy/visuals/tests/test_text.py,sha256=-dMbyBkrclEVp_PSmC1LWeUOyBcAa4_bewAR-nf6
 vispy/visuals/tests/test_volume.py,sha256=VY3NBuGjc90d2EWAjbKv-rxPTRKdKZB4LQ8CSheck0I,17578
 vispy/visuals/tests/test_windbarb.py,sha256=NCdMvOBhcL1xoy85efdPEkyUempiTWA6pM6dX674MDo,1102
 vispy/visuals/text/__init__.py,sha256=XyFi9zGWKpgWKC6xm0uMQZD1yzWU5TBi3jzoIehZ-dM,357
-vispy/visuals/text/_sdf_cpu.cpython-311-aarch64-linux-gnu.so,sha256=HOPM7SsHf9X0LhQssi5gixwKnU32WZEwNTjphyPA8aQ,1685128
+vispy/visuals/text/_sdf_cpu.cpython-311-aarch64-linux-gnu.so,sha256=ZHmgvOtBT92Qn6tMkatKtw8SewdYpehI06vEQY6fSr4,1685280
 vispy/visuals/text/_sdf_cpu.pyx,sha256=uXBK9RDoLGfkNjfUvrTbkfdBQ3K06ReReswwN8bKN7M,3810
 vispy/visuals/text/_sdf_gpu.py,sha256=uQwtOfH0tzZSlOP7uSY28SUK4_yk-dWwmmJRPXVAgD0,10480
 vispy/visuals/text/text.py,sha256=nyenaB3kj0YI6EpO9PCMH9RHMa4l9G1OoygZbOwksaE,25253
@@ -514,8 +514,8 @@ vispy/visuals/transforms/nonlinear.py,sha256=3-3Y2V9nD30ZVzJAc013Cbj7BrP2hgNnb6k
 vispy/visuals/transforms/transform_system.py,sha256=ynOGbDhvLkujjV3Y389lJsTUr_-KjZ0QvMV7s0KgX9M,13759
 vispy/visuals/transforms/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vispy/visuals/transforms/tests/test_transforms.py,sha256=u8TbJ0ZJJBqGR78SCZTCC9HxyxShIlaaMK1EVFao2e4,6871
-vispy-0.15.1.dist-info/METADATA,sha256=LIS2ucCJABqjJlmnVVf5Zcq04xa9dwTHUI_VsiYOBKw,8978
-vispy-0.15.1.dist-info/WHEEL,sha256=tQPVbWkEA5kW5mks9ExhiE7QbghQmHHgJqgfeYqA4io,153
-vispy-0.15.1.dist-info/top_level.txt,sha256=mciStn1SI48jYwEhJXlrMJ3HaJ90XOr5ZGJ8YdFI674,6
-vispy-0.15.1.dist-info/RECORD,,
-vispy-0.15.1.dist-info/licenses/LICENSE.txt,sha256=hLBPzUmDb8t3_W75Epf9lzxiqgPLHIyBEYSomgeTc8I,1774
+vispy-0.15.2.dist-info/METADATA,sha256=6PfToxMK1J3Wmrthbth2z3TwlUNwSQzj8mnNm_ea0ZI,8978
+vispy-0.15.2.dist-info/WHEEL,sha256=AKBHhzURqqUE5Bb9LDUoYqPR1ASY5DC5S1zOdvq8Px4,153
+vispy-0.15.2.dist-info/top_level.txt,sha256=mciStn1SI48jYwEhJXlrMJ3HaJ90XOr5ZGJ8YdFI674,6
+vispy-0.15.2.dist-info/RECORD,,
+vispy-0.15.2.dist-info/licenses/LICENSE.txt,sha256=hLBPzUmDb8t3_W75Epf9lzxiqgPLHIyBEYSomgeTc8I,1774

{vispy-0.15.1.dist-info → vispy-0.15.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.6.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: false
 Tag: cp311-cp311-manylinux_2_17_aarch64
 Tag: cp311-cp311-manylinux2014_aarch64