bspy 4.1__py3-none-any.whl → 4.2__py3-none-any.whl

bspy/spline_block.py

@@ -0,0 +1,343 @@
+import numpy as np
+import bspy.spline
+import bspy._spline_domain
+import bspy._spline_evaluation
+import bspy._spline_intersection
+import bspy._spline_fitting
+import bspy._spline_operations
+
+class SplineBlock:
+    """
+    A class to represent and process an array-like collection of splines. 
+    Spline blocks are useful for efficiently manipulating and solving systems of equations with splines.
+
+    Parameters
+    ----------
+    block : an array-like collection of splines (may be a list of lists)
+        Splines in the same row are treated as if they are added together. 
+        Each row need not have the same number of splines, but all splines in a row must have the same 
+        number of dependent variables (same nDep). Corresponding independent variables must have the same domain.
+
+        For example, if F is a spline with nInd = 3 and nDep = 2, G is a spline with nInd = 1 and nDep = 2, 
+        and h is a spline with nInd = 2 and nDep = 1, then [[F, G], [h]] is a valid block (total nDep is 3 
+        and max nInd is 4).
+    """
+
+    def _block_evaluation(self, returnShape, splineFunction, args):
+        value = np.zeros(returnShape, self.coefsDtype)
+        nDep = 0
+        for row in self.block:
+            nInd = 0
+            for spline in row:
+                value[nDep:nDep + spline.nDep] += splineFunction(spline, *[arg[nInd:nInd + spline.nInd] for arg in args])
+                nInd += spline.nInd
+            nDep += spline.nDep
+        return value
+    
+    def _block_operation(self, splineFunction, args):
+        newBlock = []
+        for row in self.block:
+            newRow = []
+            nInd = 0
+            for spline in row:
+                newRow.append(splineFunction(spline, *[arg[nInd:nInd + spline.nInd] for arg in args]))
+                nInd += spline.nInd
+            newBlock.append(newRow)
+        return SplineBlock(newBlock)
+    
+    def __init__(self, block):
+        if isinstance(block, bspy.spline.Spline):
+            self.block = [[block]]
+        elif isinstance(block[0], bspy.spline.Spline):
+            self.block = [block]
+        else:
+            self.block = block
+        self.nInd = 0
+        self.nDep = 0
+        self.knotsDtype = None
+        self.coefsDtype = None
+        self.size = 0
+        self._domain = []
+        for row in self.block:
+            rowInd = 0
+            rowDep = 0
+            for spline in row:
+                if rowDep == 0:
+                    rowDep = spline.nDep
+                    if self.nInd == 0:
+                        self.knotsDtype = spline.knots[0].dtype
+                        self.coefsDtype = spline.coefs.dtype
+                elif rowDep != spline.nDep:
+                    raise ValueError("All splines in the same row must have the same nDep")
+                d = spline.domain()
+                for i in range(rowInd, rowInd + spline.nInd):
+                    ind = i - rowInd
+                    if i < self.nInd:
+                        if self._domain[i][0] != d[ind, 0] or self._domain[i][1] != d[ind, 1]:
+                            raise ValueError("Domains of independent variables must match")
+                    else:
+                        self._domain.append(d[ind])
+                rowInd += spline.nInd
+            self.nInd = max(self.nInd, rowInd)
+            self.nDep += rowDep
+            self.size += len(row)
+        self._domain = np.array(self._domain, self.knotsDtype)
+
+    def __call__(self, uvw):
+        return self.evaluate(uvw)
+
+    def __repr__(self):
+        return f"SplineBlock({self.block})"
+
+    def contours(self):
+        """
+        Find all the contour curves of a block of splines whose `nInd` is one larger than its `nDep`.
+
+        Returns
+        -------
+        curves : `iterable`
+            A collection of `Spline` curves, `u(t)`, each of whose domain is [0, 1], whose range is
+            in the parameter space of the given spline, and which satisfy `self(u(t)) = 0`. 
+
+        See Also
+        --------
+        `zeros` : Find the roots of a block of splines (nInd must match nDep).
+
+        Notes
+        -----
+        Uses `zeros` to find all intersection points and `Spline.contour` to find individual intersection curves. 
+        The algorithm used to to find all intersection curves is from Grandine, Thomas A., and Frederick W. Klein IV. 
+        "A new approach to the surface intersection problem." Computer Aided Geometric Design 14, no. 2 (1997): 111-134.
+        """
+        return bspy._spline_intersection.contours(self)
+
+    def contract(self, uvw):
+        """
+        Contract a spline block by assigning a fixed value to one or more of its independent variables.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable to contract.
+            A value of `None` for an independent variable indicates that variable should remain unchanged.
+
+        Returns
+        -------
+        block : `SplineBlock`
+            The contracted spline block.
+        """
+        return self._block_operation(bspy._spline_operations.contract, (uvw,))
+
+    def derivative(self, with_respect_to, uvw):
+        """
+        Compute the derivative of the spline block at given parameter values.
+
+        Parameters
+        ----------
+        with_respect_to : `iterable`
+            An iterable of length `nInd` that specifies the integer order of derivative for each independent variable.
+            A zero-order derivative just evaluates the spline normally.
+        
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+
+        Returns
+        -------
+        value : `numpy.array`
+            The value of the derivative of the spline block at the given parameter values (array of size nDep).
+        """
+        return self._block_evaluation(self.nDep, bspy._spline_evaluation.derivative, (with_respect_to, uvw))
+
+    def domain(self):
+        """
+        Return the domain of a spline block.
+
+        Returns
+        -------
+        bounds : `numpy.array`
+            nInd x 2 array of the lower and upper bounds on each of the independent variables.
+        """
+        return self._domain
+    
+    def evaluate(self, uvw):
+        """
+        Compute the value of the spline block at given parameter values.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+
+        Returns
+        -------
+        value : `numpy.array`
+            The value of the spline block at the given parameter values (array of size nDep).
+        """
+        return self._block_evaluation(self.nDep, bspy._spline_evaluation.evaluate, (uvw,))
+    
+    def jacobian(self, uvw):
+        """
+        Compute the value of the spline block's Jacobian at given parameter values.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+
+        Returns
+        -------
+        value : `numpy.array`
+            The value of the spline block's Jacobian at the given parameter values. The shape of the return value is (nDep, nInd).
+        """
+        jacobian = np.zeros((self.nDep, self.nInd), self.coefsDtype)
+        nDep = 0
+        for row in self.block:
+            nInd = 0
+            for spline in row:
+                jacobian[nDep:nDep + spline.nDep, nInd:nInd + spline.nInd] += spline.jacobian(uvw[nInd:nInd + spline.nInd])
+                nInd += spline.nInd
+            nDep += spline.nDep
+        return jacobian
+
+    def normal(self, uvw, normalize=True, indices=None):
+        """
+        Compute the normal of the spline block at given parameter values. The number of independent variables must be
+        one different than the number of dependent variables.
+
+        Parameters
+        ----------
+        uvw : `iterable`
+            An iterable of length `nInd` that specifies the values of each independent variable (the parameter values).
+        
+        normalize : `boolean`, optional
+            If True the returned normal will have unit length (the default). Otherwise, the normal's length will
+            be the area of the tangent space (for two independent variables, its the length of the cross product of tangent vectors).
+        
+        indices : `iterable`, optional
+            An iterable of normal indices to calculate. For example, `indices=(0, 3)` will return a vector of length 2
+            with the first and fourth values of the normal. If `None`, all normal values are returned (the default).
+
+        Returns
+        -------
+        normal : `numpy.array`
+            The normal vector of the spline block at the given parameter values.
+
+        See Also
+        --------
+        `normal_spline` : Compute a spline that evaluates to the normal of the given spline block (not normalized).
+
+        Notes
+        -----
+        Attentive readers will notice that the number of independent variables could be one more than the number of 
+        dependent variables (instead of one less, as is typical). In that case, the normal represents the null space of 
+        the matrix formed by the tangents of the spline. If the null space is greater than one dimension, the normal will be zero.
+        """
+        return bspy._spline_evaluation.normal(self, uvw, normalize, indices)
+
+    def normal_spline(self, indices=None):
+        """
+        Compute a spline that evaluates to the normal of the given spline block. The length of the normal
+        is the area of the tangent space (for two independent variables, its the length of the cross product of tangent vectors).
+        The number of independent variables must be one different than the number of dependent variables.
+        Find all the contour curves of a block of splines whose `nInd` is one larger than its `nDep`.
+
+        Parameters
+        ----------
+        indices : `iterable`, optional
+            An iterable of normal indices to calculate. For example, `indices=(0, 3)` will make the returned spline compute a vector of length 2
+            with the first and fourth values of the normal. If `None`, all normal values are returned (the default).
+
+        Returns
+        -------
+        spline : `Spline`
+            The spline that evaluates to the normal of the given spline block.
+
+        See Also
+        --------
+        `normal` : Compute the normal of the spline block at given parameter values.
+
+        Notes
+        -----
+        Attentive readers will notice that the number of independent variables could be one more than the number of 
+        dependent variables (instead of one less, as is typical). In that case, the normal represents the null space of 
+        the matrix formed by the tangents of the spline block. If the null space is greater than one dimension, the normal will be zero.
+        """
+        return bspy._spline_operations.normal_spline(self, indices)
+    
+    def range_bounds(self):
+        """
+        Return the range of a spline block as lower and upper bounds on each of the
+        dependent variables.
+        """
+        return self._block_evaluation((self.nDep, 2), bspy._spline_evaluation.range_bounds, [])
+    
+    def reparametrize(self, newDomain):
+        """
+        Reparametrize a spline block to match new domain bounds. The number of knots and coefficients remain unchanged.
+
+        Parameters
+        ----------
+        newDomain : array-like
+            nInd x 2 array of the new lower and upper bounds on each of the independent variables (same form as 
+            returned from `domain`). If a bound pair is `None` then the original bound (and knots) are left unchanged. 
+            For example, `[[0.0, 1.0], None]` will reparametrize the first independent variable and leave the second unchanged)
+
+        Returns
+        -------
+        block : `SplineBlock`
+            Reparametrized spline block.
+
+        See Also
+        --------
+        `domain` : Return the domain of a spline block.
+        """
+        return self._block_operation(bspy._spline_domain.reparametrize, (newDomain,))
+
+    def trim(self, newDomain):
+        """
+        Trim the domain of a spline block.
+
+        Parameters
+        ----------
+        newDomain : array-like
+            nInd x 2 array of the new lower and upper bounds on each of the independent variables (same form as 
+            returned from `domain`). If a bound is None or nan then the original bound (and knots) are left unchanged.
+
+        Returns
+        -------
+        block : `SplineBlock`
+            Trimmed spline block.
+        """
+        return self._block_operation(bspy._spline_domain.trim, (newDomain,))
+    
+    def zeros(self, epsilon=None, initialScale=None):
+        """
+        Find the roots of a block of splines (nInd must match nDep).
+
+        Parameters
+        ----------
+        epsilon : `float`, optional
+            Tolerance for root precision. The root will be within epsilon of the actual root. 
+            The default is the machine epsilon.
+
+        initialScale : array-like, optional
+            The initial scale of each dependent variable (as opposed to the current scale of 
+            the spline block, which may have been normalized). The default is an array of ones (size nDep).
+
+        Returns
+        -------
+        roots : `iterable`
+            An iterable containing the roots of the block of splines. If the block is 
+            zero over an interval, that root will appear as a tuple of the interval. 
+            For curves (nInd == 1), the roots are ordered.
+        
+        See Also
+        --------
+        `contours` : Find all the contour curves of a spline block whose `nInd` is one larger than its `nDep`.
+
+        Notes
+        -----
+        Implements a variation of the projected-polyhedron technique from Sherbrooke, Evan C., and Nicholas M. Patrikalakis. 
+        "Computation of the solutions of nonlinear polynomial systems." Computer Aided Geometric Design 10, no. 5 (1993): 379-405.
+        """
+        return bspy._spline_intersection.zeros_using_projected_polyhedron(self, epsilon, initialScale)

bspy/viewer.py

@@ -152,12 +152,14 @@ class Viewer(tk.Tk):
             if draw:
                 self.treeview.selection_add(iid)
             for i, boundary in enumerate(solid.boundaries):
-                self.list(boundary, f"{name} boundary {i+1}", fillColor, lineColor, options, False, iid)
+                self.list(boundary, f"Boundary {i}", fillColor, lineColor, options, False, iid)
         elif isinstance(spline, Boundary):
             boundary = spline
             if isinstance(boundary.manifold, Hyperplane):
                 uvMin = boundary.domain.bounds[:,0]
                 uvMax = boundary.domain.bounds[:,1]
+                if (uvMax - uvMin).min() < 1.0e-8:
+                    return
                 xyzMinMin = boundary.manifold.evaluate(uvMin)
                 xyzMinMax = boundary.manifold.evaluate((uvMin[0], uvMax[1]))
                 xyzMaxMin = boundary.manifold.evaluate((uvMax[0], uvMin[1]))
@@ -210,7 +212,7 @@ class Viewer(tk.Tk):
                 if isinstance(spline, Spline):
                     self.list(spline)
                 else:
-                    self.list_solid(spline)
+                    self.list(spline)
     
     def erase_all(self):
         """Stop drawing all splines. Splines remain in the treeview."""
@@ -223,8 +225,7 @@ class Viewer(tk.Tk):
         """Remove splines from the treeview."""
         for item in self.treeview.selection():
             spline = self.splineList.pop(item)
-            self.splineDrawList.remove(spline)
-        self.treeview.delete(*self.treeview.selection())
+            self.treeview.delete(item)
         self.update()
 
     def empty(self):
@@ -426,7 +427,7 @@ class Viewer(tk.Tk):
         fillColor : `numpy.array`
             Array of four floats (r, g, b, a) in the range [0, 1].
         """
-        return spline.metadata["fillColor"]
+        return np.array(spline.metadata["fillColor"], np.float32)
 
     @staticmethod
     def set_fill_color(spline, r, g=None, b=None, a=None):
@@ -467,7 +468,7 @@ class Viewer(tk.Tk):
         lineColor : `numpy.array`
             Array of four floats (r, g, b, a) in the range [0, 1].
         """
-        return spline.metadata["lineColor"]
+        return np.array(spline.metadata["lineColor"], np.float32)
 
     @staticmethod
     def set_line_color(spline, r, g=None, b=None, a=None):

{bspy-4.1.dist-info → bspy-4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bspy
-Version: 4.1
+Version: 4.2
 Summary: Library for manipulating and rendering non-uniform B-splines
 Home-page: http://github.com/ericbrec/BSpy
 Author: Eric Brechner
@@ -34,14 +34,20 @@ Library for manipulating and rendering B-spline curves, surfaces, and multidimen
 
 The [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) abstract base class for [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) and [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html).
 
-The [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html) class has a method to fit multidimensional data for 
-scalar and vector functions of single and multiple variables. It also has methods to create points, lines, circular arcs, spheres, cones, cylinders, tori, ruled surfaces, surfaces of revolution, and four-sided patches. 
+The [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html) class has a method to fit multidimensional data for scalar and vector functions of single and multiple variables. It also can fit splines to functions, to solutions for ordinary differential equations (ODEs), and to geodesics. 
+Spline has methods to create points, lines, circular arcs, spheres, cones, cylinders, tori, ruled surfaces, surfaces of revolution, and four-sided patches. 
 Other methods add, subtract, and multiply splines, as well as confine spline curves to a given range. 
-There are methods to evaluate spline values, derivatives, integrals, normals, curvature, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, graphs, and convolutions. In addition, there are methods to manipulate the domain of splines, including trim, join, reparametrize, transpose, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. There are methods to manipulate the range of splines, including dot product, cross product, translate, rotate, scale, and transform. Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines.
+There are methods to evaluate spline values, derivatives, normals, integrals, continuity, curvature, and the Jacobian, as well as methods that return spline representations of derivatives, normals, integrals, graphs, and convolutions. 
+In addition, there are methods to manipulate the domain of splines, including trim, join, split, reparametrize, transpose, reverse, add and remove knots, elevate and extrapolate, and fold and unfold. 
+There are methods to manipulate the range of splines, including dot product, cross product, translate, rotate, scale, and transform. 
+Finally, there are methods to compute the zeros and contours of a spline and to intersect two splines. 
+Splines can be saved and loaded in json format.
 
 The [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) class has methods to create individual hyperplanes in any dimension, along with axis-aligned hyperplanes and hypercubes.
 
-The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids.
+The [Solid](https://ericbrec.github.io/BSpy/bspy/solid.html) class has methods to construct n-dimensional solids from trimmed [Manifold](https://ericbrec.github.io/BSpy/bspy/manifold.html) boundaries. Each solid consists of a list of boundaries and a Boolean value that indicates if the solid contains infinity. Each [Boundary](https://ericbrec.github.io/BSpy/bspy/solid.html) consists of a manifold (currently a [Hyperplane](https://ericbrec.github.io/BSpy/bspy/hyperplane.html) or [Spline](https://ericbrec.github.io/BSpy/bspy/spline.html)) and a domain solid that trims the manifold. Solids have methods to form the intersection, union, difference, and complement of solids. There are methods to compute point containment, winding numbers, surface integrals, and volume integrals. There are also methods to translate, transform, and slice solids. Solids can be saved and loaded in json format.
+
+The [SplineBlock](https://ericbrec.github.io/BSpy/bspy/spline_block.html) class has methods to represent and process an array-like collection of splines, including ones to compute the contours and zeros of a spline block, as well as a variety of methods to evaluate a spline block and its derivatives. Spline blocks are useful for efficiently manipulating and solving systems of equations with splines.
 
 The [SplineOpenGLFrame](https://ericbrec.github.io/BSpy/bspy/splineOpenGLFrame.html) class is an 
 [OpenGLFrame](https://pypi.org/project/pyopengltk/) with custom shaders to render spline curves and surfaces. Spline surfaces with more 

bspy-4.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+bspy/__init__.py,sha256=ruWkrHgrjGFeB2uATnCNY-J9hpgK5R6vsXrtshBIFDk,1476
+bspy/_spline_domain.py,sha256=xbXOlRxFSwbM55dNiy6RpSOJsgHc1xD3hgACBxYiifk,33647
+bspy/_spline_evaluation.py,sha256=MQmF6hhxHXBEOWCSTGZOTmecP5uOn7VrI9Aj8NUCSb8,9622
+bspy/_spline_fitting.py,sha256=EbM_FI-QW5PjZKbpAF4r4dP8DZOLn8QX3dYvG9zzuFo,50753
+bspy/_spline_intersection.py,sha256=cFciLdc1wTFZuKixfWoOlN8PJhQHWt_nN6N9Wt4EMhw,65438
+bspy/_spline_operations.py,sha256=KNkWSg27jFjoewsaNqMfNLrMAD4MUQJvCkXOfQbEHmI,43088
+bspy/hyperplane.py,sha256=wngJw_9x358gf_S1O3sPqodnUx7HHdJunAp4ceOq7Fw,24605
+bspy/manifold.py,sha256=Ecrm7LjcfttOJ617mKMXdJSWqVxt2eToNvpq5skLliA,14255
+bspy/solid.py,sha256=E8iAcIFV5r_SrzcY_5UB0hKitE-bcrI0-dPzXcvD6iw,36763
+bspy/spline.py,sha256=Bt1WDF69ZYO--rz9Myclb26f0fDnr62q1NWYTxcwFvw,100398
+bspy/splineOpenGLFrame.py,sha256=ezPUyDr9QKF0KU7H6XjHL-HhN23ffC8KbxGhGgGJhQ0,95843
+bspy/spline_block.py,sha256=gfoK_-QVqQCrv9acDCkQf-deHZntjOw1VgyPWAxDWcU,14656
+bspy/viewer.py,sha256=S0yij3LwHIll0ZA-bZevpkNFYSzs41a5xb8EgpHTW_M,33760
+bspy-4.2.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
+bspy-4.2.dist-info/METADATA,sha256=a7T__b4_Kyf9wKg7ba8_s_51FdKB-XgaQg0zLfLWGI8,6792
+bspy-4.2.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+bspy-4.2.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
+bspy-4.2.dist-info/RECORD,,

{bspy-4.1.dist-info → bspy-4.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

bspy-4.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-bspy/__init__.py,sha256=q8XOJK3FsbHybfy2CSPufY5Z5SQJNxK_tH-d9zXR5vY,1308
-bspy/_spline_domain.py,sha256=kklvRrSeEEUUQ48yXvCCDzHMRPd4_BHICxAsOhyxhjk,30178
-bspy/_spline_evaluation.py,sha256=3cWD3sL4odnZ4w1DBQFmUnPg2PuPpSfaGfNcBl8ZrW0,7079
-bspy/_spline_fitting.py,sha256=hFhPyL39d87IGZiAs8teFhYZHxPN1EvzQYxHcDTeBLw,45318
-bspy/_spline_intersection.py,sha256=EV19Qt-kccr5K17aB1EETJXENdz-_UJlYTKWjK-ueJU,58324
-bspy/_spline_operations.py,sha256=y98zl-r31xsZzD6X0VYbuEPUabg3UNC_ERCbkXZRZXU,42530
-bspy/hyperplane.py,sha256=gRConjCEdMAjP8UXA7kaYU--NQHr1tYiVHtmZzLNnqY,24639
-bspy/manifold.py,sha256=29KkZXvv759-aywGd7Ek4Egm-DCBNDTEfusW_Az1kC4,14244
-bspy/solid.py,sha256=qbHofcdNbMTaoCCfKfxloYiEqZDsxfOIJD3MwZguEJ8,36444
-bspy/spline.py,sha256=747e_kChnGnN2Y93EcP9XymDrf2T4NFFweFB_YghEvw,94776
-bspy/splineOpenGLFrame.py,sha256=ezPUyDr9QKF0KU7H6XjHL-HhN23ffC8KbxGhGgGJhQ0,95843
-bspy/viewer.py,sha256=HdtjAj5CZnv4VKcfS8MhT-ciPEPRVNUTp-02TW1NQSU,33717
-bspy-4.1.dist-info/LICENSE,sha256=nLfJULN68Jw6GfCJp4xeMksGuRdyWNdgEsZGjw2twig,1091
-bspy-4.1.dist-info/METADATA,sha256=Fe5wy39gSJOVk7Z3Ruz1Utm3oYZQlPyyJJMYGu6YvP4,6152
-bspy-4.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-bspy-4.1.dist-info/top_level.txt,sha256=fotZnJn6aCwgUbBEV3hslIko7Nw-eqtHLq2eyJLlFsY,5
-bspy-4.1.dist-info/RECORD,,