pytetwild 0.1.dev1__cp311-cp311-win_amd64.whl → 0.2.0__cp311-cp311-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,16 +2,15 @@
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_5_4():
+def _delvewheel_patch_1_12_0():
     import os
-    libs_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'pytetwild.libs'))
-    if os.path.isdir(libs_dir):
+    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_5_4()
-del _delvewheel_patch_1_5_4
+_delvewheel_patch_1_12_0()
+del _delvewheel_patch_1_12_0
 # end delvewheel patch
 
 from ._version import __version__  # noqa: F401
-from .pytetwild import tetrahedralize, tetrahedralize_pv  # noqa: F401
+from .pytetwild import tetrahedralize, tetrahedralize_pv, tetrahedralize_csg  # noqa: F401

pytetwild/_version.py

@@ -1,4 +1,5 @@
 """Contains the pytetwild version."""
+
 from importlib import metadata
 
 __version__ = metadata.version("pytetwild")

pytetwild/pytetwild.py

@@ -1,13 +1,18 @@
 """Wrapper for fTetWild."""
+
 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.
@@ -15,17 +20,87 @@ def _check_edge_length(edge_length_fac: float) -> None:
     Parameters
     ----------
     edge_length_fac : float, default: 0.05
-        Tetrahedral edge length as a function of bounding box diagional. The
+        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.
@@ -33,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 diagional. The
-        default ideal edge length is bb/20 (bounding box divided by 20).
-    optimize : bool
+        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, 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
     -------
@@ -63,63 +161,109 @@ def tetrahedralize_pv(
 
     """
     try:
-        import pyvista as pv
+        import pyvista.core as pv
     except:
         raise ModuleNotFoundError(
-            "Install PyVista to use this feature with:\n\n" "pip install pytetwild[all]"
+            "Install PyVista to use this feature with:\n\npip install pytetwild[all]"
         )
 
     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)
+    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 diagional. 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
     -------
@@ -132,5 +276,90 @@ 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(
+    csg_file: str,
+    epsilon: float = 1e-3,
+    edge_length_r: float = 0.05,
+    stop_energy: float = 10.0,
+    coarsen: bool = True,
+    num_threads: int = 0,
+    loglevel: int = 3,
+) -> "pv.UnstructuredGrid":
+    """
+    Generate a tetrahedral mesh based on a the CSG tree specified in the csf_file.
+
+    Parameters
+    ----------
+    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.
+    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).
+    stop_energy : float, default: 10.0
+        The mesh optimization stops when the  conformal AMIPS energy reaches 'stop_energy'.
+    coarsen : bool, default: true
+        Coarsen the output as much as possible, while maintaining the mesh quality.
+    num_threads : int, default: 0
+        Set number of threads used (0 means all available cores).
+    loglevel : int, default: 6
+        Set log level (0 = most verbose, 6 = minimal output).
+
+    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.
+    """
+    try:
+        pass
+    except:
+        raise ModuleNotFoundError(
+            "Install PyVista to use this feature with:\n\npip install pytetwild[all]"
+        )
+    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,
+    )
+
+    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\\cp311-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qrk3shix\\cp311-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-qrk3shix\\cp311-win_amd64\\built_wheel\\pytetwild-0.2.0-cp311-cp311-win_amd64.whl', '--add-path', '.']

{pytetwild-0.1.dev1.dist-info → pytetwild-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pytetwild
-Version: 0.1.dev1
+Version: 0.2.0
 Summary: Python wrapper of fTetWild
 Author-Email: Alex Kaszynski <akascap@gmail.com>
 Classifier: Development Status :: 3 - Alpha
@@ -10,22 +10,23 @@ Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: MacOS
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 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
-Requires-Dist: pyvista; extra == "all"
-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"
 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: pre-commit; extra == "dev"
 Description-Content-Type: text/x-rst
-License-File: LICENSE
 
 pytetwild
 #########
@@ -46,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
@@ -62,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
 
@@ -75,18 +81,22 @@ To tetrahedralize a surface mesh from `PyVista <https://docs.pyvista.org>`_:
 
    # Convert the surface mesh to a tetrahedral mesh. For this example let's
    # use a coarse mesh
-   tetrahedral_mesh = pytetwild.tetrahedralize_pv(surface_mesh, edge_length_fac=1))
+   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
 
 You can also work with raw arrays. Here's a simple cube that we turn into tetrahedra.
 
-.. code:: pycon
+.. code:: py
 
    import numpy as np
+   import pytetwild
 
    # Define vertices of the cube
    vertices = np.array([
@@ -115,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 diagional. The
-        default ideal edge length is bb/20 (bounding box divided by 20).
-    optimize : bool
+        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, 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=Pat3rwTsjBjwzDYwwd3do72LlxOQJ57iqtJTCe3diWg,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=8iX8gmlbRvL4GPsrmnUMA_KjoddkRGkRF1KU4P0Uctk,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=oXhHG6ewLm-FNdEna2zwgy-K0KEl4claZ1ztR4VTx0I,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.dev1.dist-info → pytetwild-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.8.2
+Generator: scikit-build-core 0.11.6
 Root-Is-Purelib: false
 Tag: cp311-cp311-win_amd64
 

pytetwild-0.1.dev1.dist-info/DELVEWHEEL

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

pytetwild-0.1.dev1.dist-info/RECORD

@@ -1,14 +0,0 @@
-pytetwild/py.typed,sha256=mDShSrm8qg9qjacQc2F-rI8ATllqP6EdgHuEYxuCXZ0,7
-pytetwild/PyfTetWildWrapper.pyd,sha256=ojH-nbIrsvbCd6rCpHDE2HNSwsTag2x_-HM8c1rdh50,4990976
-pytetwild/pytetwild.py,sha256=PSLlG5czLo2Z2aZtcgxmZAy97E9eAtbo7EdvY0WONIs,4646
-pytetwild/_version.py,sha256=hbg9UkagWDGV6Zg23kEpex_otuUYHUzMCHXYTnFnHmE,118
-pytetwild/__init__.py,sha256=QdK3GINbrnK1cwEauX0cPgzkVCa1VPait8aGT2AJN4Q,486
-pytetwild-0.1.dev1.dist-info/DELVEWHEEL,sha256=Jof_OsfrYCWD5xfBGEx3t8btsaL3IAHoWQjxgLVys5U,423
-pytetwild-0.1.dev1.dist-info/entry_points.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytetwild-0.1.dev1.dist-info/METADATA,sha256=6I1FzXoY9ezDC8EWamtUR2MVxWtBvgjD5frhxz4gw6Y,4587
-pytetwild-0.1.dev1.dist-info/RECORD,,
-pytetwild-0.1.dev1.dist-info/WHEEL,sha256=BqEX1Ir2N732jBkDsbdh_aEJYw2lve5DIKlaeaAffeY,105
-pytetwild-0.1.dev1.dist-info/licenses/LICENSE,sha256=k0P1sbYupRWlxoESvbYq2UzoMW6MXA84LltqR-4mEo4,17096
-pytetwild.libs/concrt140-ddbfd8b75976783430ced289c6b989c3.dll,sha256=BZPGv1uz0YBgBOgTWBBL0elt7C3clmR348_2Zlqh47Q,302080
-pytetwild.libs/mpir-0f58ffaa159ebf7efb9359a55c2d7f23.dll,sha256=qd6vEIL0JPtRZ39EzelGE9rApfJ6duoMgV8jT8UHGns,612352
-pytetwild.libs/msvcp140-3499a3a8427eec4915749ee9a8991ddd.dll,sha256=oDDcLf0uyiipN1ySmJrfTa8WH5iNteFrnhBnjrDf9Mc,573008