engeom 0.2.4__cp38-abi3-win_amd64.whl → 0.2.5__cp38-abi3-win_amd64.whl

engeom/geom2.pyi

@@ -1,7 +1,8 @@
 from __future__ import annotations
-import numpy
-from typing import Iterable, Tuple, Type, TypeVar
 
+from typing import Iterable, Tuple, TypeVar, Iterator, Any
+
+import numpy
 from engeom.engeom import Resample
 
 Transformable2 = TypeVar("Transformable2", Vector2, Point2, Iso2, SurfacePoint2)
@@ -9,6 +10,9 @@ PointOrVec2 = TypeVar("PointOrVec2", Point2, Vector2)
 
 
 class Vector2(Iterable[float]):
+    def __iter__(self) -> Iterator[float]:
+        pass
+
     def __init__(self, x: float, y: float):
         """
 
@@ -40,6 +44,9 @@ class Vector2(Iterable[float]):
     def __mul__(self, x: float) -> Vector2:
         ...
 
+    def __truediv__(self, x: float) -> Vector2:
+        ...
+
     def as_numpy(self) -> numpy.ndarray[float]:
         """
         Create a numpy array of shape (2,) from the vector.
@@ -78,6 +85,9 @@ class Vector2(Iterable[float]):
 
 
 class Point2(Iterable[float]):
+    def __iter__(self) -> Iterator[float]:
+        pass
+
     def __init__(self, x: float, y: float):
         """
 
@@ -108,6 +118,18 @@ class Point2(Iterable[float]):
     def __add__(self, other: Vector2) -> Vector2:
         ...
 
+    def __mul__(self, other) -> Point2:
+        ...
+
+    def __truediv__(self, other) -> Point2:
+        ...
+
+    def __rmul__(self, other) -> Point2:
+        ...
+
+    def __neg__(self) -> Point2:
+        ...
+
     def as_numpy(self) -> numpy.ndarray[float]:
         """
         Create a numpy array of shape (2,) from the point.
@@ -200,6 +222,49 @@ class SurfacePoint2:
         """
         ...
 
+    def rot_normal(self, angle: float) -> SurfacePoint2:
+        """
+        Rotate the normal vector of the surface point by a given angle in radians and return a new surface point. The
+        position of the surface point is not affected. The angle is positive for counter-clockwise rotation and negative
+        for clockwise rotation.
+
+        :param angle: the angle to rotate the normal vector by.
+        :return:
+        """
+
+    def __mul__(self, other: float) -> SurfacePoint2:
+        """
+        Multiply the position of the surface point by a scalar value. The normal vector is not affected unless the
+        scalar is negative, in which case the normal vector is inverted.
+        :param other:
+        :return:
+        """
+        ...
+
+    def __rmul__(self, other: float) -> SurfacePoint2:
+        """
+        Multiply the position of the surface point by a scalar value. The normal vector is not affected unless the
+        scalar is negative, in which case the normal vector is inverted.
+        :param other:
+        :return:
+        """
+        ...
+
+    def __truediv__(self, other: float) -> SurfacePoint2:
+        """
+        Divide the position of the surface point by a scalar value. The normal vector is not affected unless the
+        scalar is negative, in which case the normal vector is inverted.
+        :param other:
+        :return:
+        """
+        ...
+
+    def __neg__(self) -> SurfacePoint2:
+        """
+        Invert both the position AND the normal vector of the surface point.
+        """
+        ...
+
 
 class Iso2:
     def __init__(self, tx: float, ty: float, r: float):
@@ -233,7 +298,7 @@ class Iso2:
         """
         ...
 
-    def transform_points(self, points: numpy.ndarray[float]) -> numpy.ndarray[float]:
+    def transform_points(self, points: numpy.ndarray[Any, numpy.dtype]) -> numpy.ndarray[float]:
         """
         Transform an array of points using the isometry.
         :param points: a numpy array of shape (N, 2)
@@ -241,7 +306,7 @@ class Iso2:
         """
         ...
 
-    def transform_vectors(self, vectors: numpy.ndarray[float]) -> numpy.ndarray[float]:
+    def transform_vectors(self, vectors: numpy.ndarray[Any, numpy.dtype]) -> numpy.ndarray[float]:
         """
         Transform an array of vectors using the isometry. The translation part of the isometry is ignored.
         :param vectors:
@@ -254,13 +319,75 @@ class SvdBasis2:
 
     def __init__(
             self,
-            points: numpy.ndarray[float],
-            weights: numpy.ndarray[float] | None = None
+            points: numpy.ndarray,
+            weights: numpy.ndarray | None = None
     ):
         """
+        Create a basis from a set of points. The basis will be calculated using a singular value decomposition of the
+        points.
+
+        :param points: a numpy array of shape (n, 2) containing the points to calculate the basis from.
+        :param weights: a numpy array of shape (n,) containing the weights of the points. If None, all points will be
+        weighted equally.
+        """
+        ...
+
+    def rank(self, tol: float) -> int:
+        """
+        Retrieve the rank of the decomposition by counting the number of singular values that are
+        greater than the provided tolerance.  A rank of 0 indicates that all singular values are
+        less than the tolerance, and thus the point set is essentially a single point. A rank of 1
+        indicates that the point set is essentially a line. A rank of 2 indicates that the point
+        set exists roughly in a plane.
+
+        The singular values do not directly have a clear physical meaning. They are square roots of
+        the variance multiplied by the number of points used to compute the basis.  Thus, they can
+        be interpreted in relation to each other, and when they are very small.
 
-        :param points:
-        :param weights:
+        This method should be used either when you know roughly what a cutoff tolerance for the
+        problem you're working on should be, or when you know the cutoff value should be very
+        small.  Otherwise, consider examining the standard deviations of the basis vectors
+        instead, as they will be easier to interpret (`basis_stdevs()`).
+        :param tol: the tolerance to use when determining the rank.
+        :return: the rank of the decomposition.
+        """
+        ...
+
+    def largest(self) -> Vector2:
+        """
+        Get the largest singular vector of the basis.
+        :return: the largest singular vector.
+        """
+        ...
+
+    def smallest(self) -> Vector2:
+        """
+        Get the smallest singular vector of the basis.
+        :return: the smallest singular vector.
+        """
+        ...
+
+    def basis_variances(self) -> numpy.ndarray[float]:
+        """
+        Get the variance of the points along the singular vectors.
+        :return: a numpy array of the variance of the points along the singular vectors.
+        """
+        ...
+
+    def basis_stdevs(self) -> numpy.ndarray[float]:
+        """
+        Get the standard deviation of the points along the singular vectors.
+        :return: a numpy array of the standard deviation of the points along the singular vectors.
+        """
+        ...
+
+    def to_iso2(self) -> Iso2:
+        """
+        Produce an isometry which will transform from the world space to the basis space.
+
+        For example, if the basis is created from a set of points that lie roughly on an arbitrary line, multiplying
+        original points by this isometry will move the points such that all points are aligned with the x-axis.
+        :return: the isometry that transforms from the world space to the basis space.
         """
         ...
 
@@ -533,7 +660,6 @@ class Circle2:
         """
         ...
 
-
     @property
     def center(self) -> Point2:
         """
@@ -658,14 +784,16 @@ class Arc2:
         """
         ...
 
+
 class Aabb2:
-    def __init__(self, x_min: float, x_max: float, y_min: float, y_max: float):
+    def __init__(self, x_min: float, y_min: float, x_max: float, y_max: float):
         """
+        Create an axis-aligned bounding box from the given bounds.
 
-        :param x_min:
-        :param x_max:
-        :param y_min:
-        :param y_max:
+        :param x_min: the minimum x-coordinate of the AABB
+        :param y_min: the minimum y-coordinate of the AABB
+        :param x_max: the maximum x-coordinate of the AABB
+        :param y_max: the maximum y-coordinate of the AABB
         """
         ...
 
@@ -681,6 +809,16 @@ class Aabb2:
         """
         ...
 
+    @staticmethod
+    def from_points(points: numpy.ndarray) -> Aabb2:
+        """
+        Create an AABB that bounds a set of points. If the point array is empty or the wrong shape, an error will be
+        thrown.
+        :param points: a numpy array of shape (N, 2) containing the points to bound
+        :return: a new AABB object
+        """
+        ...
+
     @property
     def min(self) -> Point2:
         """
@@ -731,4 +869,4 @@ class Aabb2:
         :param d: the distance to shrink the AABB by.
         :return: a new AABB object with the shrunk bounds.
         """
-        ...
+        ...

engeom/geom3.pyi

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Tuple, Iterable, List, TypeVar
+from typing import Tuple, Iterable, List, TypeVar, Iterator, Any
 
 import numpy
+from numpy.typing import NDArray
 from engeom import DeviationMode, Resample, SelectOp
 from .metrology import Length3
 
@@ -11,13 +12,13 @@ Transformable3 = TypeVar("Transformable3", Vector3, Point3, Plane3, Iso3, Surfac
 PointOrVector3 = TypeVar("PointOrVector3", Vector3, Point3)
 
 
-class Vector3:
+class Vector3(Iterable[float]):
     def __init__(self, x: float, y: float, z: float):
         """
-
-        :param x:
-        :param y:
-        :param z:
+        Create a vector in 3D space by specifying the x, y, and z components.
+        :param x: the x component of the vector
+        :param y: the y component of the vector
+        :param z: the z component of the vector
         """
         ...
 
@@ -33,7 +34,7 @@ class Vector3:
     def z(self) -> float:
         ...
 
-    def __iter__(self) -> Iterable[float]:
+    def __iter__(self) -> Iterator[float]:
         ...
 
     def __rmul__(self, other: float) -> Vector3:
@@ -51,7 +52,10 @@ class Vector3:
     def __mul__(self, x: float) -> Vector3:
         ...
 
-    def as_numpy(self) -> numpy.ndarray[float]:
+    def __truediv__(self, x: float) -> Vector3:
+        ...
+
+    def as_numpy(self) -> NDArray[float]:
         """
         Create a numpy array of shape (3,) from the vector.
         """
@@ -94,13 +98,14 @@ class Vector3:
         ...
 
 
-class Point3:
+class Point3(Iterable[float]):
     def __init__(self, x: float, y: float, z: float):
         """
+        Create a point in 3D space by specifying the x, y, and z coordinates.
 
-        :param x:
-        :param y:
-        :param z:
+        :param x: the x coordinate of the point
+        :param y: the y coordinate of the point
+        :param z: the z coordinate of the point
         """
         ...
 
@@ -116,7 +121,7 @@ class Point3:
     def z(self) -> float:
         ...
 
-    def __iter__(self) -> Iterable[float]:
+    def __iter__(self) -> Iterator[float]:
         ...
 
     @property
@@ -133,7 +138,19 @@ class Point3:
     def __add__(self, other: Vector3) -> Vector3:
         ...
 
-    def as_numpy(self) -> numpy.ndarray[float]:
+    def __neg__(self) -> Point3:
+        ...
+
+    def __mul__(self, x: float) -> Point3:
+        ...
+
+    def __rmul__(self, x: float) -> Point3:
+        ...
+
+    def __truediv__(self, x: float) -> Point3:
+        ...
+
+    def as_numpy(self) -> NDArray[float]:
         """
         Create a numpy array of shape (2,) from the point.
         """
@@ -143,13 +160,16 @@ class Point3:
 class SurfacePoint3:
     def __init__(self, x: float, y: float, z: float, nx: float, ny: float, nz: float):
         """
+        Create a surface point in 3D space by specifying the x, y, and z coordinates of the point, as well as the x, y,
+        and z components of the normal vector.  The normal components will be normalized before being stored, so they
+        do not need to be scaled to unit length before being passed to this constructor.
 
-        :param x:
-        :param y:
-        :param z:
-        :param nx:
-        :param ny:
-        :param nz:
+        :param x: the x coordinate of the point
+        :param y: the y coordinate of the point
+        :param z: the z coordinate of the point
+        :param nx: the x component of the normal vector (will be normalized after construction)
+        :param ny: the y component of the normal vector (will be normalized after construction)
+        :param nz: the z component of the normal vector (will be normalized after construction)
         """
         ...
 
@@ -223,11 +243,44 @@ class SurfacePoint3:
         """
         ...
 
+    def __mul__(self, other: float) -> SurfacePoint3:
+        """
+        Multiply the position of the surface point by a scalar value. The normal vector is not affected unless the
+        scalar is negative, in which case the normal vector is inverted.
+        :param other:
+        :return:
+        """
+        ...
+
+    def __rmul__(self, other: float) -> SurfacePoint3:
+        """
+        Multiply the position of the surface point by a scalar value. The normal vector is not affected unless the
+        scalar is negative, in which case the normal vector is inverted.
+        :param other:
+        :return:
+        """
+        ...
+
+    def __truediv__(self, other: float) -> SurfacePoint3:
+        """
+        Divide the position of the surface point by a scalar value. The normal vector is not affected unless the
+        scalar is negative, in which case the normal vector is inverted.
+        :param other:
+        :return:
+        """
+        ...
+
+    def __neg__(self) -> SurfacePoint3:
+        """
+        Invert both the position AND the normal vector of the surface point.
+        """
+        ...
+
 
 class Iso3:
     """ An isometry (rigid body transformation) in 3D space. """
 
-    def __init__(self, matrix: numpy.ndarray[float]):
+    def __init__(self, matrix: NDArray[float]):
         """ Create an isometry from a 4x4 matrix. """
         ...
 
@@ -266,7 +319,7 @@ class Iso3:
         """ Return the inverse of the isometry. """
         ...
 
-    def transform_points(self, points: numpy.ndarray[float]) -> numpy.ndarray[float]:
+    def transform_points(self, points: NDArray[float]) -> NDArray[float]:
         """ Transform a set of points by the isometry. This will transform the points by the rotation and translation
         of the isometry.
 
@@ -275,7 +328,7 @@ class Iso3:
         """
         ...
 
-    def transform_vectors(self, vector: numpy.ndarray[float]) -> numpy.ndarray[float]:
+    def transform_vectors(self, vector: NDArray[float]) -> NDArray[float]:
         """ Transform a set of vectors by the isometry. This will only transform the direction of the vectors, not
         their magnitude.
 
@@ -284,7 +337,7 @@ class Iso3:
         """
         ...
 
-    def as_numpy(self) -> numpy.ndarray[float]:
+    def as_numpy(self) -> NDArray[float]:
         """ Return a copy of the 4x4 matrix representation of the isometry. This is a copy operation. """
         ...
 
@@ -310,11 +363,7 @@ class SvdBasis3:
     fitting basis for the points using a singular value decomposition.
     """
 
-    def __init__(
-            self,
-            points: numpy.ndarray[float],
-            weights: numpy.ndarray[float] | None = None
-    ):
+    def __init__(self, points: NDArray[float], weights: NDArray[float] | None = None):
         """
         Create a basis from a set of points. The basis will be calculated using a singular value decomposition of the
         points.
@@ -335,28 +384,28 @@ class SvdBasis3:
         """
         ...
 
-    def largest(self) -> numpy.ndarray[float]:
+    def largest(self) -> Vector3:
         """
         Return the largest normalized basis vector.
-        :return: a numpy array of shape (3,) containing the largest basis vector.
+        :return: a Vector3 object containing the largest basis vector.
         """
         ...
 
-    def smallest(self) -> numpy.ndarray[float]:
+    def smallest(self) -> Vector3:
         """
         Return the smallest normalized basis vector.
-        :return: a numpy array of shape (3,) containing the smallest basis vector.
+        :return: a Vector3 object containing the smallest basis vector.
         """
         ...
 
-    def basis_variances(self) -> numpy.ndarray[float]:
+    def basis_variances(self) -> NDArray[float]:
         """
         Return the variances of the basis vectors.
         :return: a numpy array of shape (3,) containing the variances of the basis vectors.
         """
         ...
 
-    def basis_stdevs(self) -> numpy.ndarray[float]:
+    def basis_stdevs(self) -> NDArray[float]:
         """
         Return the standard deviations of the basis vectors.
         :return: a numpy array of shape (3,) containing the standard deviations of the basis vectors.
@@ -434,8 +483,8 @@ class Mesh:
 
     def __init__(
             self,
-            vertices: numpy.ndarray[float],
-            faces: numpy.ndarray[numpy.uint32],
+            vertices: NDArray[float],
+            faces: NDArray[numpy.uint32],
             merge_duplicates: bool = False,
             delete_degenerate: bool = False
     ):
@@ -507,7 +556,7 @@ class Mesh:
         ...
 
     @property
-    def vertices(self) -> numpy.ndarray[float]:
+    def vertices(self) -> NDArray[float]:
         """
         Will return an immutable view of the vertices of the mesh as a numpy array of shape (n, 3).
         :return: a numpy array of shape (n, 3) containing the vertices of the mesh.
@@ -515,7 +564,7 @@ class Mesh:
         ...
 
     @property
-    def faces(self) -> numpy.ndarray[numpy.uint32]:
+    def faces(self) -> NDArray[numpy.uint32]:
         """
         Will return an immutable view of the triangles of the mesh as a numpy array of shape (m, 3).
         :return: a numpy array of shape (m, 3) containing the triangles of the mesh.
@@ -534,7 +583,7 @@ class Mesh:
         """
         ...
 
-    def deviation(self, points: numpy.ndarray[float], mode: DeviationMode) -> numpy.ndarray[float]:
+    def deviation(self, points: NDArray[float], mode: DeviationMode) -> NDArray[float]:
         """
         Calculate the deviation between a set of points and their respective closest points on the mesh surface. The
         deviation can be calculated in two modes: absolute and normal. In the absolute mode, the deviation is the
@@ -548,7 +597,7 @@ class Mesh:
         """
         ...
 
-    def sample_poisson(self, radius: float) -> numpy.ndarray[float]:
+    def sample_poisson(self, radius: float) -> NDArray[float]:
         """
         Sample the surface of the mesh using a Poisson disk sampling algorithm. This will return a numpy array of points
         and their normals that are approximately evenly distributed across the surface of the mesh. The radius parameter
@@ -632,7 +681,7 @@ class Mesh:
         :return:
         """
 
-    def boundary_first_flatten(self) -> numpy.ndarray[float]:
+    def boundary_first_flatten(self) -> NDArray[float]:
         """
 
         :return:
@@ -751,7 +800,7 @@ class Curve3:
     between them.
     """
 
-    def __init__(self, vertices: numpy.ndarray, tol: float = 1.0e-6):
+    def __init__(self, vertices: NDArray[float], tol: float = 1.0e-6):
         """
         Create a curve from a set of vertices. The vertices should be a numpy array of shape (n, 3).
 
@@ -778,7 +827,7 @@ class Curve3:
         ...
 
     @property
-    def points(self) -> numpy.ndarray[float]:
+    def points(self) -> NDArray[float]:
         """
         Will return an immutable view of the vertices of the mesh as a numpy array of shape (n, 3).
         :return: a numpy array of shape (n, 3) containing the vertices of the mesh.
@@ -900,3 +949,47 @@ class Aabb3:
     def extent(self) -> Vector3:
         """ The extent of the box. """
         ...
+
+    @staticmethod
+    def at_point(x: float, y: float, z: float, w: float, h: float | None = None, l: float | None = None) -> Aabb3:
+        """
+        Create an AABB centered at a point with a given width and height.
+        :param x: the x-coordinate of the center of the AABB.
+        :param y: the y-coordinate of the center of the AABB.
+        :param z: the z-coordinate of the center of the AABB.
+        :param w: the width of the AABB.
+        :param h: the height of the AABB. If not provided, the AABB will be square.
+        :param l: the length of the AABB. If not provided, the AABB will be square.
+        :return: a new AABB object.
+        """
+        ...
+
+    @staticmethod
+    def from_points(points: NDArray[float]) -> Aabb3:
+        """
+        Create an AABB that bounds a set of points. If the point array is empty or the wrong shape, an error will be
+        thrown.
+        :param points: a numpy array of shape (N, 2) containing the points to bound
+        :return: a new AABB object
+        """
+        ...
+
+    def expand(self, d: float) -> Aabb3:
+        """
+        Expand the AABB by a given distance in all directions. The resulting height and
+        width will be increased by 2 * d.
+
+        :param d: the distance to expand the AABB by.
+        :return: a new AABB object with the expanded bounds.
+        """
+        ...
+
+    def shrink(self, d: float) -> Aabb3:
+        """
+        Shrink the AABB by a given distance in all directions. The resulting height and
+        width will be decreased by 2 * d.
+
+        :param d: the distance to shrink the AABB by.
+        :return: a new AABB object with the shrunk bounds.
+        """
+        ...

{engeom-0.2.4.dist-info → engeom-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engeom
-Version: 0.2.4
+Version: 0.2.5
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -8,3 +8,9 @@ Requires-Dist: numpy
 Requires-Dist: pytest ; extra == 'tests'
 Provides-Extra: tests
 Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# Engeom Python Bindings
+
+Full documentation at https://mattj23.github.io/py-engeom/
+

{engeom-0.2.4.dist-info → engeom-0.2.5.dist-info}/RECORD

@@ -1,18 +1,18 @@
-engeom-0.2.4.dist-info/METADATA,sha256=ihtRy0gEfQ1gc10xbpncuk_Uc_-ocxIR2HyZEejVXto,339
-engeom-0.2.4.dist-info/WHEEL,sha256=_g1M2QM3kt1Ssm_sHOg_3TUY7GxNE2Ueyslb9ZDtPwk,94
+engeom-0.2.5.dist-info/METADATA,sha256=N4o4hLHur_HzFZEffX0FYKefzKmcNhCPfOUkUDnDq9U,497
+engeom-0.2.5.dist-info/WHEEL,sha256=_g1M2QM3kt1Ssm_sHOg_3TUY7GxNE2Ueyslb9ZDtPwk,94
 engeom/airfoil/__init__.py,sha256=G6m7JEvHVk3sM2JooJPOg8JNA3VuEp0EIqczSEbC_PY,180
 engeom/airfoil.pyi,sha256=0TVpXkolFUXbBqJp93FenA_XqvU7FD1DnbncAF0ubow,14654
 engeom/align/__init__.py,sha256=SEeMqeqLKqJC73Mg8GwPwd9NwWnl-dcCqJ4rPdh8yyc,196
 engeom/align.pyi,sha256=QCSKrTLkCoaIubcrPU9J-wDZe1lRP0GbPgWZmonXjo0,997
 engeom/engeom.pyi,sha256=Jia11rU8ZnMKdlXgfGeBPlSmsYPEfALM-_ufNwR0ibQ,254
 engeom/geom2/__init__.py,sha256=mRu8Zh6DE-EQyhxScoxszPqDjGVzGWVJEQO6RIAtS4A,174
-engeom/geom2.pyi,sha256=Jh0ES-Gvkl7sFQV7VG6KdwgDbCPhmiETG_YOObYazhU,22741
+engeom/geom2.pyi,sha256=GJk8tRDyBD9HYgLY6YmF3iDrXDJfAdkbvWYiOpLgyGs,28330
 engeom/geom3/__init__.py,sha256=DG5jt2xgS9WRNb58ZkkrcKQQO6bIG-irg-uV_BkHEj4,174
-engeom/geom3.pyi,sha256=UUUg3OHobF_MfSDJZXD0PEZGSak2XQpiGAkne3lY7fI,34163
+engeom/geom3.pyi,sha256=XiM9SLZ7JAT3Ulk6ZR462pPgfBt2hFx6alJZzP3R_Sk,38179
 engeom/matplotlib.py,sha256=A0gdQshzE3G7joNHna4viYnioQtA8LVXfSuZ_X6AHeo,9001
 engeom/metrology/__init__.py,sha256=cpsB0-hJGitzW79Coxwf7r_mpNaeI6yG3myDEVdBJgk,186
 engeom/metrology.pyi,sha256=P_2pkoLUAOB0-RKppj0FN01XGY0jx1lGw9H1eKXrW8s,1144
 engeom/pyvista.py,sha256=WVjaMG1hhd6hkknfxgkgCH8rZRXaM2AweG39T0UQkGc,6044
 engeom/__init__.py,sha256=kYgFq3jq1quDfV013wEYQMlUBz4QNSpP6u8lFiuTHvc,115
-engeom/engeom.pyd,sha256=7G9m_LBBIJkK7bVNkiV0Z6rQ0VA1R-KuVkZcB_w4rPE,2317312
-engeom-0.2.4.dist-info/RECORD,,
+engeom/engeom.pyd,sha256=fCxcjqmiFrg-UITOBXomKiv56yEjmq4JvMUPv1HjQAo,2363904
+engeom-0.2.5.dist-info/RECORD,,