pytetwild 0.1.1__cp310-cp310-win_amd64.whl → 0.2.0__cp310-cp310-win_amd64.whl

pytetwild/PyfTetWildWrapper.pyi

@@ -0,0 +1,29 @@
+import numpy as np
+from numpy.typing import NDArray
+
+def tetrahedralize_mesh(
+    vertices: NDArray[np.float64],
+    faces: NDArray[np.uint32],
+    optimize: bool,
+    skip_simplify: bool,
+    edge_length_r: float,
+    edge_length_abs: float,
+    epsilon: float,
+    stop_energy: float,
+    coarsen: bool,
+    num_threads: int,
+    num_opt_iter: int,
+    loglevel: int,
+    quiet: bool,
+    vtk_ordering: bool,
+) -> tuple[NDArray[np.float64], NDArray[np.int32]]: ...
+def tetrahedralize_csg(
+    csg_file: str,
+    epsilon: float,
+    edge_length_r: float,
+    stop_energy: float,
+    coarsen: bool,
+    num_threads: int,
+    log_level: int,
+    vtk_ordering: bool,
+) -> tuple[NDArray[np.float64], NDArray[np.int32], NDArray[np.int32]]: ...

pytetwild/__init__.py

@@ -2,14 +2,14 @@
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_11_2():
+def _delvewheel_patch_1_12_0():
     import os
     if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'pytetwild.libs'))):
         os.add_dll_directory(libs_dir)
 
 
-_delvewheel_patch_1_11_2()
-del _delvewheel_patch_1_11_2
+_delvewheel_patch_1_12_0()
+del _delvewheel_patch_1_12_0
 # end delvewheel patch
 
 from ._version import __version__  # noqa: F401

pytetwild/pytetwild.py

@@ -2,13 +2,17 @@
 
 import warnings
 import numpy as np
-from pytetwild import PyfTetWildWrapper  # type: ignore
-from typing import Tuple, TYPE_CHECKING
-import numpy.typing as npt
+from pytetwild import PyfTetWildWrapper
+from typing import TYPE_CHECKING
+from numpy.typing import NDArray
 
 if TYPE_CHECKING:
     import pyvista as pv
 
+VTK_UNSIGNED_CHAR = 3
+VTK_TETRA = 10
+VTK_QUADRATIC_TETRA = 24
+
 
 def _check_edge_length(edge_length_fac: float) -> None:
     """Check edge length.
@@ -19,14 +23,84 @@ def _check_edge_length(edge_length_fac: float) -> None:
         Tetrahedral edge length as a function of bounding box diagonal. The
         default ideal edge length is bb/20 (bounding box divided by 20).
 
-
     """
     if edge_length_fac > 1.0 or edge_length_fac < 0.0 + 1e-16:
         raise ValueError("Edge length factor must be between 1e-16 and 1.0")
 
 
+def _ugrid_from_regular_cells(
+    points: NDArray[np.float32] | NDArray[np.float64],
+    cells: NDArray[np.int32],
+) -> "pv.UnstructuredGrid":
+    """
+    Create an UnstructuredGrid from points and fixed-size cells.
+
+    Parameters
+    ----------
+    points : np.ndarray[np.float64]
+        Point coordinates.
+    cells : np.ndarray[np.int32]
+        Cell connectivity without padding. Cell type inferred from shape.
+
+    Returns
+    -------
+    pyvista.UnstructuredGrid
+        Unstructured grid.
+
+    """
+    try:
+        import pyvista.core as pv
+    except:
+        raise ModuleNotFoundError(
+            "Install PyVista to use this feature with:\n\npip install pytetwild[all]"
+        )
+
+    from vtkmodules.vtkCommonCore import vtkTypeInt32Array
+    from vtkmodules.util.numpy_support import numpy_to_vtk
+    from vtkmodules.vtkCommonDataModel import vtkCellArray
+
+    if cells.ndim != 2:
+        raise ValueError("cells must be 2D")
+
+    grid = pv.UnstructuredGrid()
+    grid.points = points
+
+    n_cells, n_nodes_per_cell = cells.shape
+    vtk_dtype = vtkTypeInt32Array().GetDataType()
+    offsets = np.arange(0, n_cells * n_nodes_per_cell + 1, n_nodes_per_cell, dtype=np.int32)
+    offsets_vtk = numpy_to_vtk(offsets, deep=False, array_type=vtk_dtype)
+    conn_vtk = numpy_to_vtk(cells.ravel(), deep=False, array_type=vtk_dtype)
+
+    cell_array = vtkCellArray()
+    cell_array.SetData(offsets_vtk, conn_vtk)
+
+    if n_nodes_per_cell == 4:
+        cell_type = VTK_TETRA
+    elif n_nodes_per_cell == 10:
+        cell_type = VTK_QUADRATIC_TETRA
+    else:
+        raise ValueError(f"Unsupported number of nodes per cells {n_nodes_per_cell}")
+
+    celltypes = numpy_to_vtk(
+        np.full(n_cells, cell_type, dtype=np.uint8), deep=False, array_type=VTK_UNSIGNED_CHAR
+    )
+    grid.SetCells(celltypes, cell_array)
+    return grid
+
+
 def tetrahedralize_pv(
-    mesh: "pv.PolyData", edge_length_fac: float = 0.05, optimize: bool = True
+    mesh: "pv.PolyData",
+    edge_length_fac: float = 0.05,
+    edge_length_abs: float | None = None,
+    optimize: bool = True,
+    simplify: bool = True,
+    epsilon: float = 1e-3,
+    stop_energy: float = 10.0,
+    coarsen: bool = False,
+    num_threads: int = 0,
+    num_opt_iter: int = 80,
+    loglevel: int = 3,
+    quiet: bool = True,
 ) -> "pv.UnstructuredGrid":
     """
     Convert a PyVista surface mesh to a PyVista unstructured grid.
@@ -34,13 +108,36 @@ def tetrahedralize_pv(
     Parameters
     ----------
     mesh : pv.PolyData
-        The input surface mesh.
+        The input surface mesh. Should be composed of all triangles.
     edge_length_fac : float, default: 0.05
         Tetrahedral edge length as a function of bounding box diagonal. The
-        default ideal edge length is bb/20 (bounding box divided by 20).
-    optimize : bool
+        default ideal edge length is ``bb/20`` (bounding box divided by
+        20). Ignored when ``edge_length_abs`` is input.
+    edge_length_abs : float, optional
+        Absolute ideal edge length. When input ``edge_length_fac`` is ignored.
+    optimize : bool, default: True
         Improve the minimum scaled Jacobean for each cell. This leads to higher
-        cell quality at the expense of computation time.
+        cell quality at the expense of computation time. Optimization level is
+        dependent on ``stop_energy`` and ``num_opt_iter``.
+    simplify : bool, default: True
+        Simplfiy the input mesh surface before tetrahedralization.
+    epsilon : float, default 1e-3
+        Envelop size, specifying the maximum distance of the output surface
+        from the input surface, relative to the bounding box size.
+    stop_energy : float, default: 10.0
+        The mesh optimization stops when the conformal AMIPS energy reaches
+        ``stop_energy``.
+    coarsen : bool, default: False
+        Coarsen the output as much as possible, while maintaining the mesh
+        quality.
+    num_threads : int, default: 0
+        Set number of threads used. 0 (default) uses all available cores.
+    num_opt_iter : int, default: 80
+        Maximum number of optimization iterations if ``optimize=True``.
+    loglevel : int, default: 6
+        Set log level (0 = most verbose, 6 = minimal output).
+    quiet : bool, default: False
+        Disable all output. Overrides ``loglevel``.
 
     Returns
     -------
@@ -64,7 +161,7 @@ def tetrahedralize_pv(
 
     """
     try:
-        import pyvista as pv
+        import pyvista.core as pv
     except:
         raise ModuleNotFoundError(
             "Install PyVista to use this feature with:\n\npip install pytetwild[all]"
@@ -72,55 +169,101 @@ def tetrahedralize_pv(
 
     if not isinstance(mesh, pv.PolyData):
         raise TypeError(f"`mesh` must be a pyvista.PolyData, got {type(mesh)}")
-
     if not mesh.is_all_triangles:
         warnings.warn(
             "Input mesh is not all triangles. Either call `.triangulate()`"
             " beforehand to suppress this warning or use an all triangle mesh."
         )
         mesh = mesh.triangulate()
-
     _check_edge_length(edge_length_fac)
+
+    if edge_length_abs is None:
+        edge_length_abs = 0.0
+
     vertices = mesh.points.astype(np.float64, copy=False)
-    faces = mesh.faces.reshape((-1, 4))[:, 1:4].astype(np.float32, copy=False)
-
-    (
-        tetrahedral_mesh_vertices,
-        tetrahedral_mesh_tetrahedra,
-    ) = PyfTetWildWrapper.tetrahedralize_mesh(vertices, faces, optimize, edge_length_fac)
-
-    cells = np.hstack(
-        [
-            np.full((tetrahedral_mesh_tetrahedra.shape[0], 1), 4, dtype=np.int32),
-            tetrahedral_mesh_tetrahedra,
-        ]
-    )
-    cell_types = np.full(tetrahedral_mesh_tetrahedra.shape[0], 10, dtype=np.uint8)
+    faces = mesh._connectivity_array.reshape(-1, 3)
+    if faces.dtype == np.int32:
+        # we can cheat here and just treat it as unsigned 32 (assuming no negative indices)
+        faces_unsigned = faces.view(np.uint32)
+    else:
+        faces_unsigned = faces.astype(np.uint32, copy=False)
 
-    return pv.UnstructuredGrid(cells, cell_types, tetrahedral_mesh_vertices).clean()
+    skip_simplify = not simplify
+    vtk_ordering = True
+    tmesh_v, tmesh_c = PyfTetWildWrapper.tetrahedralize_mesh(
+        vertices,
+        faces_unsigned,
+        optimize,
+        skip_simplify,
+        edge_length_fac,
+        edge_length_abs,
+        epsilon,
+        stop_energy,
+        coarsen,
+        num_threads,
+        num_opt_iter,
+        loglevel,
+        quiet,
+        vtk_ordering,
+    )
+    return _ugrid_from_regular_cells(tmesh_v, tmesh_c)
 
 
 def tetrahedralize(
-    vertices: npt.NDArray[np.float64],
-    faces: npt.NDArray[np.int32],
-    optimize: bool = True,
+    vertices: NDArray[np.float32] | NDArray[np.float64],
+    faces: NDArray[np.int32],
     edge_length_fac: float = 0.05,
-) -> Tuple[npt.NDArray[np.float64], npt.NDArray[np.int32]]:
+    edge_length_abs: float | None = None,
+    optimize: bool = True,
+    simplify: bool = True,
+    epsilon: float = 1e-3,
+    stop_energy: float = 10.0,
+    coarsen: bool = False,
+    num_threads: int = 0,
+    num_opt_iter: int = 80,
+    loglevel: int = 3,
+    quiet: bool = True,
+    vtk_ordering: bool = False,
+) -> tuple[NDArray[np.float64], NDArray[np.int32]]:
     """
     Convert mesh vertices and faces to a tetrahedral mesh.
 
     Parameters
     ----------
-    vertices : np.ndarray[double]
+    vertices : np.ndarray[np.float32] | np.ndarray[np.float64]
         The vertices of the mesh.
-    faces : np.ndarray
+    faces : np.ndarray[np.int32]
         The faces of the mesh.
+    edge_length_fac : float, default: 0.05
+        Tetrahedral edge length as a function of bounding box diagonal. The
+        default ideal edge length is bb/20 (bounding box divided by
+        20). Ignored when ``edge_length_abs`` is input.
+    edge_length_abs : float, optional
+        Absolute ideal edge length. When input ``edge_length_fac`` is ignored.
     optimize : bool
         Improve the minimum scaled Jacobean for each cell. This leads to higher
         cell quality at the expense of computation time.
-    edge_length_fac : float, default: 0.05
-        Tetrahedral edge length as a function of bounding box diagonal. The
-        default ideal edge length is bb/20 (bounding box divided by 20).
+    simplify : bool, default: True
+        Simplfiy the input mesh surface before tetrahedralization.
+    epsilon : float, default 1e-3
+        Envelop size, specifying the maximum distance of the output surface
+        from the input surface, relative to the bounding box size.
+    stop_energy : float, default: 10.0
+        The mesh optimization stops when the conformal AMIPS energy reaches
+        ``stop_energy``.
+    coarsen : bool, default: False
+        Coarsen the output as much as possible, while maintaining the mesh
+        quality.
+    num_threads : int, default: 0
+        Set number of threads used. 0 (default) uses all available cores.
+    num_opt_iter : int, default: 80
+        Maximum number of optimization iterations if ``optimize=True``.
+    loglevel : int, default: 6
+        Set log level (0 = most verbose, 6 = minimal output).
+    quiet : bool, default: False
+        Disable all output. Overrides ``loglevel``.
+    vtk_ordering : bool, default: False
+        Reorder the tetrahedral cell indices to match VTK's ordering.
 
     Returns
     -------
@@ -133,8 +276,32 @@ def tetrahedralize(
     if not isinstance(faces, np.ndarray):
         raise TypeError("`faces` must be a numpy array")
     vertices = vertices.astype(np.float64, copy=False)
-    faces = faces.astype(np.int32, copy=False)
-    return PyfTetWildWrapper.tetrahedralize_mesh(vertices, faces, optimize, edge_length_fac)
+    if faces.dtype == np.int32:
+        # we can cheat here and just treat it as unsigned 32 (assuming no negative indices)
+        faces_unsigned = faces.view(np.uint32)
+    else:
+        faces_unsigned = faces.astype(np.uint32, copy=False)
+
+    if edge_length_abs is None:
+        edge_length_abs = 0.0
+
+    skip_simplify = not simplify
+    return PyfTetWildWrapper.tetrahedralize_mesh(
+        vertices,
+        faces_unsigned,
+        optimize,
+        skip_simplify,
+        edge_length_fac,
+        edge_length_abs,
+        epsilon,
+        stop_energy,
+        coarsen,
+        num_threads,
+        num_opt_iter,
+        loglevel,
+        quiet,
+        vtk_ordering,
+    )
 
 
 def tetrahedralize_csg(
@@ -154,8 +321,8 @@ def tetrahedralize_csg(
     csg_file : str
         Path to the input json file.
     epsilon : float, default 1e-3
-        Envelop size, specifying the maximum distance of the output surface from the input surface,
-        relative to the bounding box size.
+        Envelop size, specifying the maximum distance of the output surface
+        from the input surface, relative to the bounding box size.
     edge_length_r : float, default: 0.05
         Tetrahedral edge length as a function of bounding box diagonal. The
         default ideal edge length is bb/20 (bounding box divided by 20).
@@ -171,28 +338,28 @@ def tetrahedralize_csg(
     Returns
     -------
     pv.UnstructuredGrid
-        The converted unstructured grid containing only tetrahedra,
-        with a cell attribute 'marker' indicating which of the input surfaces the cell belongs to.
+        The converted unstructured grid containing only tetrahedra, with a cell
+        attribute 'marker' indicating which of the input surfaces the cell
+        belongs to.
     """
     try:
-        import pyvista as pv
+        pass
     except:
         raise ModuleNotFoundError(
             "Install PyVista to use this feature with:\n\npip install pytetwild[all]"
         )
-    (tetrahedral_mesh_vertices, tetrahedral_mesh_tetrahedra, tetrahedral_marker) = (
-        PyfTetWildWrapper.tetrahedralize_csg(
-            csg_file, epsilon, edge_length_r, stop_energy, coarsen, num_threads, loglevel
-        )
+    vtk_ordering = True
+    tmesh_v, tmesh_c, tmesh_marker = PyfTetWildWrapper.tetrahedralize_csg(
+        csg_file,
+        epsilon,
+        edge_length_r,
+        stop_energy,
+        coarsen,
+        num_threads,
+        loglevel,
+        vtk_ordering,
     )
-    cells = np.hstack(
-        [
-            np.full((tetrahedral_mesh_tetrahedra.shape[0], 1), 4, dtype=np.int32),
-            tetrahedral_mesh_tetrahedra,
-        ]
-    )
-    cell_types = np.full(tetrahedral_mesh_tetrahedra.shape[0], 10, dtype=np.uint8)
 
-    grid = pv.UnstructuredGrid(cells, cell_types, tetrahedral_mesh_vertices).clean()
-    grid["marker"] = tetrahedral_marker
-    return grid
+    ugrid = _ugrid_from_regular_cells(tmesh_v, tmesh_c).clean()
+    ugrid["marker"] = tmesh_marker
+    return ugrid

pytetwild-0.2.0.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.12.0
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qrk3shix\\cp310-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qrk3shix\\cp310-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qrk3shix\\cp310-win_amd64\\built_wheel\\pytetwild-0.2.0-cp310-cp310-win_amd64.whl', '--add-path', '.']

{pytetwild-0.1.1.dist-info → pytetwild-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pytetwild
-Version: 0.1.1
+Version: 0.2.0
 Summary: Python wrapper of fTetWild
 Author-Email: Alex Kaszynski <akascap@gmail.com>
 Classifier: Development Status :: 3 - Alpha
@@ -14,15 +14,18 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: <3.15,>=3.10
 Requires-Dist: numpy
 Provides-Extra: all
 Requires-Dist: pyvista; extra == "all"
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pyvista; extra == "tests"
+Requires-Dist: scipy; extra == "tests"
+Requires-Dist: meshio; extra == "tests"
 Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: pyvista; extra == "dev"
-Requires-Dist: scipy; extra == "dev"
-Requires-Dist: meshio; extra == "dev"
 Description-Content-Type: text/x-rst
 
 pytetwild
@@ -44,13 +47,17 @@ Python wrapper around the efficient C++ library for tetrahedral meshing provided
 Installation
 ************
 
-We have pre-built wheels for Python 3.8 - Python 3.12 for Windows and Linux x64.
+We have pre-built wheels for Python 3.10 - Python 3.14 for Windows, Linux, and macOS.
 
 The recommended way to install ``pytetwild`` is via PyPI:
 
 .. code:: sh
 
-   pip install pytetwild
+   pip install pytetwild[all]
+
+This installs ``pyvista`` by default, which you can use to tetrahedralize
+sufrace meshes from PyVista. Alternatively you can just install with ``pip
+install pytetwild`` for a lighter install.
 
 You can also clone the repository and install it from source, but since there's
 C++ involved, the build is a bit more complicated. See ``CONTRIBUTING.md`` for
@@ -60,7 +67,8 @@ more details.
 Usage
 *****
 
-To tetrahedralize a surface mesh from `PyVista <https://docs.pyvista.org>`_:
+To tetrahedralize a surface mesh from `PyVista <https://docs.pyvista.org>`_,
+you'll need to first install ``pyvista`` as it's not a dependency and then run:
 
 .. code:: py
 
@@ -76,7 +84,10 @@ To tetrahedralize a surface mesh from `PyVista <https://docs.pyvista.org>`_:
    tetrahedral_mesh = pytetwild.tetrahedralize_pv(surface_mesh, edge_length_fac=1)
 
    # Visualize the tetrahedral mesh in an "exploded" view
-   tetrahedral_mesh.explode(1).plot(show_edges=True)
+   tetrahedral_mesh.explode(0.5).plot(
+       show_edges=True, zoom=1.6, ssao=True, anti_aliasing="ssaa"
+   )
+
 
 .. image:: https://github.com/pyvista/pytetwild/raw/main/exploded-sphere.png
 
@@ -85,6 +96,7 @@ You can also work with raw arrays. Here's a simple cube that we turn into tetrah
 .. code:: py
 
    import numpy as np
+   import pytetwild
 
    # Define vertices of the cube
    vertices = np.array([
@@ -113,25 +125,49 @@ You can also work with raw arrays. Here's a simple cube that we turn into tetrah
 
 Usage - Options
 ---------------
-We've surfaced a handful of parameters to each of our interfaces
-``tetrahedralize`` and ``tetrahedralize_pv``. Here are the optional parameters.
+We've surfaced a several parameters to each of our interfaces
+``tetrahedralize`` and ``tetrahedralize_pv``:
 
 .. code::
 
-    Additional Parameters
-    ---------------------
+    Parameters
+    ----------
     edge_length_fac : float, default: 0.05
         Tetrahedral edge length as a function of bounding box diagonal. The
-        default ideal edge length is bb/20 (bounding box divided by 20).
-    optimize : bool
+        default ideal edge length is ``bb/20`` (bounding box divided by
+        20). Ignored when ``edge_length_abs`` is input.
+    edge_length_abs : float, optional
+        Absolute ideal edge length. When input ``edge_length_fac`` is ignored.
+    optimize : bool, default: True
         Improve the minimum scaled Jacobean for each cell. This leads to higher
-        cell quality at the expense of computation time.
+        cell quality at the expense of computation time. Optimization level is
+        dependent on ``stop_energy`` and ``num_opt_iter``.
+    simplify : bool, default: True
+        Simplfiy the input mesh surface before tetrahedralization.
+    epsilon : float, default 1e-3
+        Envelop size, specifying the maximum distance of the output surface
+        from the input surface, relative to the bounding box size.
+    stop_energy : float, default: 10.0
+        The mesh optimization stops when the conformal AMIPS energy reaches
+        ``stop_energy``.
+    coarsen : bool, default: False
+        Coarsen the output as much as possible, while maintaining the mesh
+        quality.
+    num_threads : int, default: 0
+        Set number of threads used. 0 (default) uses all available cores.
+    num_opt_iter : int, default: 80
+        Maximum number of optimization iterations if ``optimize=True``.
+    loglevel : int, default: 6
+        Set log level (0 = most verbose, 6 = minimal output).
+    quiet : bool, default: False
+        Disable all output. Overrides ``loglevel``.
+
 
 
 License and Acknowledgments
 ***************************
 
-This project relies on ``fTetWild`` and credits go to the original authors for
+This project relies on ``fTetWild`` and credit goes to the original authors for
 their efficient C++ library for tetrahedral meshing. That work is licensed
 under the Mozilla Public License v2.0.
 

pytetwild-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pytetwild/py.typed,sha256=mDShSrm8qg9qjacQc2F-rI8ATllqP6EdgHuEYxuCXZ0,7
+pytetwild/PyfTetWildWrapper.pyd,sha256=0ON5fI5JN4Reh2qwH0pElTg4qdV3bECFoprNkYGt08k,5898752
+pytetwild/PyfTetWildWrapper.pyi,sha256=hNiPnsN-o1-EGSzDeP2lkKEx9zTwrVQVYQFHunueDOY,769
+pytetwild/pytetwild.py,sha256=dyz-HMQCFccv1Db1AXubG24iNRkFyFMY-8xvyLm7WwA,12601
+pytetwild/_version.py,sha256=A4_1DWpVQi-Rp5-lH3Itz0MNxg-VoQh0v0s0Wub4PQ4,120
+pytetwild/__init__.py,sha256=Ccsw00SOCxDfe-SfqiHy-D0QZohTB9kD0LMe4GgVHKY,498
+pytetwild-0.2.0.dist-info/DELVEWHEEL,sha256=xvA-7Mn7KlqJuS6aCe-pv-0FLGP-Ex4f-BUHgYbZ_as,421
+pytetwild-0.2.0.dist-info/METADATA,sha256=W2TWaKZlnSapb1l0vwV4nvbPQNiaPd76VdoaEm1hdFI,6131
+pytetwild-0.2.0.dist-info/RECORD,,
+pytetwild-0.2.0.dist-info/WHEEL,sha256=hrGeChGtn46HBGmzasO9QQDSLelRN-tUarBSv4gFcsI,106
+pytetwild-0.2.0.dist-info/licenses/LICENSE,sha256=k0P1sbYupRWlxoESvbYq2UzoMW6MXA84LltqR-4mEo4,17096
+pytetwild.libs/concrt140-63a42d2def1023b22584817146cee33d.dll,sha256=tWTNrcqIbCkALGnMNEoKRuaSbXscOIw0F5gWYZzfmDY,304128
+pytetwild.libs/mpir-68915c4420c2a122a0aba56cd715bd26.dll,sha256=96pOmyi8-b4gAyXakkz7w0arxMoDHxmlAU33OZXMKAY,612352
+pytetwild.libs/msvcp140-8f141b4454fa78db34bc1f28c571b4da.dll,sha256=jxQbRFT6eNs0vB8oxXG02g4AzSxD960OKC8xMDaCaq4,557648

pytetwild-0.1.1.dist-info/DELVEWHEEL

@@ -1,2 +0,0 @@
-Version: 1.11.2
-Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-aufwxr3e\\cp310-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-aufwxr3e\\cp310-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-aufwxr3e\\cp310-win_amd64\\built_wheel\\pytetwild-0.1.1-cp310-cp310-win_amd64.whl', '--add-path', '.']

pytetwild-0.1.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-pytetwild/py.typed,sha256=mDShSrm8qg9qjacQc2F-rI8ATllqP6EdgHuEYxuCXZ0,7
-pytetwild/PyfTetWildWrapper.pyd,sha256=M_XsJqhhQQJN9nhLsIDOBLswfyYR9nhDuVfhubBwQUY,5937152
-pytetwild/pytetwild.py,sha256=JZNJzIsoC9fOLqb4xDJ7oREJarEYkdvCgbIgRCvp52Q,6977
-pytetwild/_version.py,sha256=A4_1DWpVQi-Rp5-lH3Itz0MNxg-VoQh0v0s0Wub4PQ4,120
-pytetwild/__init__.py,sha256=l0Dwm58loQqSSrYqdxUx8lRHxeEBYyxr9gBvmvo-QIA,498
-pytetwild-0.1.1.dist-info/DELVEWHEEL,sha256=gZxgaaz-JQQNpB_Ga7Cs5kJSMv4hamtJCustTiy7LZQ,421
-pytetwild-0.1.1.dist-info/METADATA,sha256=4NA0MlyTgECJengiMK3QHzM89oMFU_IPMCscS8Mg4u0,4508
-pytetwild-0.1.1.dist-info/RECORD,,
-pytetwild-0.1.1.dist-info/WHEEL,sha256=hrGeChGtn46HBGmzasO9QQDSLelRN-tUarBSv4gFcsI,106
-pytetwild-0.1.1.dist-info/licenses/LICENSE,sha256=k0P1sbYupRWlxoESvbYq2UzoMW6MXA84LltqR-4mEo4,17096
-pytetwild.libs/concrt140-63a42d2def1023b22584817146cee33d.dll,sha256=tWTNrcqIbCkALGnMNEoKRuaSbXscOIw0F5gWYZzfmDY,304128
-pytetwild.libs/mpir-68915c4420c2a122a0aba56cd715bd26.dll,sha256=96pOmyi8-b4gAyXakkz7w0arxMoDHxmlAU33OZXMKAY,612352
-pytetwild.libs/msvcp140-8f141b4454fa78db34bc1f28c571b4da.dll,sha256=jxQbRFT6eNs0vB8oxXG02g4AzSxD960OKC8xMDaCaq4,557648