cadgmsh 0.1.0__tar.gz

cadgmsh-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 David Straub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cadgmsh-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: cadgmsh
+Version: 0.1.0
+Summary: Mesh CadQuery/build123d geometry with gmsh
+Author-email: David Straub <straub@protonmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 David Straub
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Repository, https://github.com/DavidMStraub/cadgmsh
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: gmsh
+Requires-Dist: meshio
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: build123d; extra == "test"
+Requires-Dist: cadquery; extra == "test"
+Provides-Extra: dev
+Requires-Dist: cadgmsh[test]; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file

cadgmsh-0.1.0/README.md

@@ -0,0 +1,68 @@
+# cadgmsh
+
+Mesh [CadQuery](https://github.com/CadQuery/cadquery) / [build123d](https://github.com/gumyr/build123d) geometry with [gmsh](https://gmsh.info). No temp files, no exposed `initialize`/`finalize`.
+
+```python
+import cadgmsh
+
+mesh = cadgmsh.mesh(shape, lc=0.3)
+
+mesh = cadgmsh.mesh(
+    [box, sphere],
+    physical={
+        "steel": box,
+        "rubber": sphere,
+        "fixed": box.faces().sort_by(Axis.Z)[0],
+    },
+    imprint=True,
+    lc=0.3,
+)
+```
+
+Returns a [`meshio.Mesh`](https://github.com/nschloe/meshio). Works with [CadQuery](https://github.com/CadQuery/cadquery) and [build123d](https://github.com/gumyr/build123d) shapes interchangeably.
+
+## Installation
+
+```bash
+pip install cadgmsh
+```
+
+Requires [CadQuery](https://github.com/CadQuery/cadquery) or [build123d](https://github.com/gumyr/build123d) in your environment — neither is a hard dependency of cadgmsh itself.
+
+## API
+
+```python
+cadgmsh.mesh(
+    shapes,                        # single shape or list of shapes
+    *,
+    physical=None,                 # dict[str, shape | list[shape]]
+    dim=3,                         # max mesh dimension (1 / 2 / 3)
+    order=1,                       # element order (1 = linear, 2 = quadratic, …)
+    algorithm=None,                # gmsh algorithm number; None = default
+    lc=None,                       # characteristic length (max element size)
+    lc_min=None,                   # min characteristic length
+    imprint=False,                 # boolean-fragment for conforming multi-body meshes
+    verbose=False,                 # show gmsh output
+) -> meshio.Mesh
+```
+
+**`physical`** maps string labels to shapes (solids, faces, edges, or vertices). Labels become named cell sets in the returned mesh, usable for boundary conditions and material assignment.
+
+**`imprint`** runs `BooleanFragments` on all input shapes so that shared interfaces are meshed conformally. Required for multi-domain simulations. Note: interface faces tagged in `physical` will have their OCC pointer invalidated by the fragment operation — tag volumes instead.
+
+## Custom shapes
+
+cadgmsh accepts any shape that exposes `.wrapped._address()` (OCP pybind11 pointer):
+
+```python
+from cadgmsh import OccShape
+
+class MyShape:
+    @property
+    def wrapped(self) -> object:  # must have ._address()
+        return self._occ_shape
+```
+
+## License
+
+MIT

cadgmsh-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cadgmsh"
+version = "0.1.0"
+description = "Mesh CadQuery/build123d geometry with gmsh"
+authors = [{name = "David Straub", email = "straub@protonmail.com"}]
+license = {file = "LICENSE"}
+requires-python = ">=3.10"
+dependencies = [
+    "gmsh",
+    "meshio",
+    "numpy",
+]
+
+[project.urls]
+Repository = "https://github.com/DavidMStraub/cadgmsh"
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-cov", "build123d", "cadquery"]
+dev  = ["cadgmsh[test]", "pyright", "ruff"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.pyright]
+include = ["src"]
+pythonVersion = "3.10"
+typeCheckingMode = "standard"
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["B011"]   # allow assert False in tests

cadgmsh-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cadgmsh-0.1.0/src/cadgmsh/__init__.py

@@ -0,0 +1,4 @@
+from cadgmsh._mesh import mesh
+from cadgmsh._types import OccShape, Shape
+
+__all__ = ["OccShape", "Shape", "mesh"]

cadgmsh-0.1.0/src/cadgmsh/_extract.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import gmsh
+import meshio
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+
+def _to_meshio() -> meshio.Mesh:
+    """
+    Extract the current gmsh model into a :class:`meshio.Mesh`.
+
+    Reads nodes, elements, and any named physical groups from the active gmsh
+    session and returns them as a meshio-compatible object.
+    Must be called while a gmsh session is active (between ``initialize`` /
+    ``finalize``) and after ``gmsh.model.mesh.generate``.
+    """
+    idx, raw_pts, _ = gmsh.model.mesh.getNodes()
+    pts: NDArray[np.float64] = np.asarray(raw_pts).reshape(-1, 3)
+    node_idx: NDArray[np.int64] = np.asarray(idx, dtype=np.int64) - 1
+    srt = np.argsort(node_idx)
+    if not np.all(node_idx[srt] == np.arange(len(node_idx))):
+        raise ValueError("gmsh returned non-consecutive node indices")
+    pts = pts[srt]
+
+    elem_types, elem_tags, node_tags = gmsh.model.mesh.getElements()
+
+    cells: list[tuple[str, ArrayLike] | meshio.CellBlock] = []
+    for etype, etags, ntags in zip(elem_types, elem_tags, node_tags, strict=True):
+        n: int = gmsh.model.mesh.getElementProperties(etype)[3]
+        conn: NDArray[np.int64] = np.asarray(ntags, dtype=np.int64).reshape(-1, n) - 1
+        conn = conn[np.argsort(np.asarray(etags, dtype=np.int64))]
+        cells.append(meshio.CellBlock(meshio.gmsh.gmsh_to_meshio_type[etype], conn))
+
+    cell_sets: dict[str, list[ArrayLike]] = {}
+    for dim, tag in gmsh.model.getPhysicalGroups():
+        name = gmsh.model.getPhysicalName(dim, tag)
+        groups: list[list[NDArray[np.int64]]] = [[] for _ in range(len(cells))]
+        for etag in gmsh.model.getEntitiesForPhysicalGroup(dim, tag):
+            etypes_e, etags_e, _ = gmsh.model.mesh.getElements(dim, etag)
+            if not etypes_e:
+                continue
+            mtype = meshio.gmsh.gmsh_to_meshio_type[etypes_e[0]]
+            for k, cb in enumerate(cells):
+                if isinstance(cb, meshio.CellBlock) and cb.type == mtype:
+                    groups[k].append(np.asarray(etags_e[0], dtype=np.int64) - 1)
+        cell_sets[name] = [
+            np.concatenate(ids) if ids else np.empty(0, dtype=np.int64)
+            for ids in groups
+        ]
+
+    return meshio.Mesh(pts, cells, cell_sets=cell_sets)

cadgmsh-0.1.0/src/cadgmsh/_mesh.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import gmsh
+import meshio
+
+from cadgmsh._extract import _to_meshio
+from cadgmsh._occ import _pointer
+from cadgmsh._resolve import _resolve_tags
+from cadgmsh._types import Shape
+
+
+def mesh(
+    shapes: Shape | list[Shape],
+    *,
+    lc: float | None = None,
+    lc_min: float | None = None,
+    imprint: bool = False,
+    dim: int = 3,
+    order: int = 1,
+    algorithm: int | None = None,
+    physical: dict[str, Shape | list[Shape]] | None = None,
+    verbose: bool = False,
+) -> meshio.Mesh:
+    """
+    Mesh one or more CAD shapes and return a :class:`meshio.Mesh`.
+
+    Parameters
+    ----------
+    shapes:
+        A single cadquery/build123d shape or a list of them.
+    lc:
+        Characteristic length (maximum element size).
+    lc_min:
+        Minimum characteristic length.
+    imprint:
+        If ``True``, boolean-fragment all input shapes so shared faces are
+        conformally meshed. Required for conforming multi-domain assemblies.
+
+        .. warning::
+            OCC Boolean operations on coincident or touching faces can produce
+            a hard segfault inside the OCC kernel that cannot be caught as a
+            Python exception. Verify that input shapes have no coincident
+            boundary faces before enabling this option.
+    dim:
+        Maximum mesh dimension (1, 2, or 3).
+    order:
+        Element order (1 = linear, 2 = quadratic, …).
+    algorithm:
+        gmsh meshing algorithm number (see gmsh docs). ``None`` = gmsh default.
+    physical:
+        Dict mapping string labels to shapes (or lists of shapes).
+        Each value may be a solid, face, edge, or vertex from cadquery or
+        build123d. Labels become named cell sets in the returned mesh.
+    verbose:
+        Show gmsh terminal output.
+    """
+    shapes_list: list[Shape] = shapes if isinstance(shapes, list) else [shapes]
+
+    gmsh.initialize()
+    try:
+        gmsh.option.setNumber("General.Terminal", 1 if verbose else 0)
+        gmsh.model.add("model")
+
+        if lc is not None:
+            gmsh.option.setNumber("Mesh.CharacteristicLengthMax", lc)
+        if lc_min is not None:
+            gmsh.option.setNumber("Mesh.CharacteristicLengthMin", lc_min)
+
+        all_dim_tags: list[list[tuple[int, int]]] = []
+        for s in shapes_list:
+            dt = gmsh.model.occ.importShapesNativePointer(
+                _pointer(s), highestDimOnly=False
+            )
+            all_dim_tags.append(list(dt))
+
+        if imprint and len(shapes_list) > 1:
+            flat: list[tuple[int, int]] = [
+                dt for group in all_dim_tags for dt in group
+            ]
+            gmsh.model.occ.fragment(flat, [], removeObject=True, removeTool=True)
+
+        gmsh.model.occ.synchronize()
+
+        if physical:
+            for label, value in physical.items():
+                entries: list[Shape] = value if isinstance(value, list) else [value]
+                tags_by_dim: dict[int, list[int]] = {}
+                for entry in entries:
+                    for d, t in _resolve_tags(entry):
+                        tags_by_dim.setdefault(d, []).append(t)
+                for d, tags in tags_by_dim.items():
+                    pg = gmsh.model.addPhysicalGroup(d, tags)
+                    gmsh.model.setPhysicalName(d, pg, label)
+
+        if algorithm is not None:
+            gmsh.option.setNumber("Mesh.Algorithm", algorithm)
+
+        gmsh.model.mesh.generate(dim)
+
+        if order != 1:
+            gmsh.model.mesh.setOrder(order)
+
+        return _to_meshio()
+
+    finally:
+        gmsh.finalize()

cadgmsh-0.1.0/src/cadgmsh/_occ.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any
+
+from cadgmsh._types import Shape
+
+
+def _unwrap(shape: Shape) -> Any:
+    """Return the raw OCP ``TopoDS_*`` object, or pass through if already unwrapped."""
+    return shape.wrapped if hasattr(shape, "wrapped") else shape
+
+
+def _pointer(shape: Shape) -> int:
+    """
+    Return the integer memory address of a ``TopoDS_Shape``.
+
+    Compatible with ``gmsh.model.occ.importShapesNativePointer``.
+    Supports OCP (pybind11) via ``._address()`` and PythonOCC (SWIG) via ``.this``.
+    """
+    occ: Any = _unwrap(shape)
+    if hasattr(occ, "_address"):
+        return int(occ._address())
+    if hasattr(occ, "this"):
+        return int(occ.this)
+    raise TypeError(f"Cannot extract OCC pointer from {type(shape)}")

cadgmsh-0.1.0/src/cadgmsh/_resolve.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import gmsh
+
+from cadgmsh._occ import _pointer
+from cadgmsh._types import Shape
+
+
+def _resolve_tags(shape: Shape) -> list[tuple[int, int]]:
+    """
+    Return the gmsh ``(dim, tag)`` pairs for *shape* by re-importing its OCC pointer.
+
+    gmsh tracks topology by TShape pointer identity, so importing a sub-shape that
+    is already part of the model returns existing tags rather than creating new ones.
+    Must be called after ``gmsh.model.occ.synchronize()``.
+    """
+    return list(
+        gmsh.model.occ.importShapesNativePointer(_pointer(shape), highestDimOnly=True)
+    )

cadgmsh-0.1.0/src/cadgmsh/_types.py

@@ -0,0 +1,31 @@
+"""Centralized type definitions for cadgmsh."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from build123d import Shape as _B3DShape
+    from cadquery.occ_impl.shapes import (
+        Shape as _CQShape,  # type: ignore[import-untyped]
+    )
+
+
+@runtime_checkable
+class OccShape(Protocol):
+    """
+    Structural protocol for OCC-backed shapes accepted by cadgmsh.
+
+    Satisfied by cadquery and build123d shapes.
+    Implement ``.wrapped`` pointing to an OCC ``TopoDS_Shape`` to integrate
+    custom shape types without depending on either library.
+    """
+
+    @property
+    def wrapped(self) -> object: ...
+
+
+if TYPE_CHECKING:
+    Shape = _B3DShape | _CQShape | OccShape
+else:
+    Shape = OccShape

cadgmsh-0.1.0/src/cadgmsh.egg-info/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: cadgmsh
+Version: 0.1.0
+Summary: Mesh CadQuery/build123d geometry with gmsh
+Author-email: David Straub <straub@protonmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 David Straub
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Repository, https://github.com/DavidMStraub/cadgmsh
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: gmsh
+Requires-Dist: meshio
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: build123d; extra == "test"
+Requires-Dist: cadquery; extra == "test"
+Provides-Extra: dev
+Requires-Dist: cadgmsh[test]; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file

cadgmsh-0.1.0/src/cadgmsh.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/cadgmsh/__init__.py
+src/cadgmsh/_extract.py
+src/cadgmsh/_mesh.py
+src/cadgmsh/_occ.py
+src/cadgmsh/_resolve.py
+src/cadgmsh/_types.py
+src/cadgmsh.egg-info/PKG-INFO
+src/cadgmsh.egg-info/SOURCES.txt
+src/cadgmsh.egg-info/dependency_links.txt
+src/cadgmsh.egg-info/requires.txt
+src/cadgmsh.egg-info/top_level.txt
+tests/test_extract.py
+tests/test_mesh.py
+tests/test_occ.py

cadgmsh-0.1.0/src/cadgmsh.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cadgmsh-0.1.0/src/cadgmsh.egg-info/requires.txt

@@ -0,0 +1,14 @@
+gmsh
+meshio
+numpy
+
+[dev]
+cadgmsh[test]
+pyright
+ruff
+
+[test]
+pytest
+pytest-cov
+build123d
+cadquery

cadgmsh-0.1.0/src/cadgmsh.egg-info/top_level.txt

@@ -0,0 +1 @@
+cadgmsh

cadgmsh-0.1.0/tests/test_extract.py

@@ -0,0 +1,78 @@
+import gmsh
+import numpy as np
+import pytest
+
+from cadgmsh._extract import _to_meshio
+
+
+@pytest.fixture
+def box_mesh():
+    gmsh.initialize()
+    gmsh.option.setNumber("General.Terminal", 0)
+    gmsh.model.add("test")
+    gmsh.model.occ.addBox(0, 0, 0, 1, 1, 1)
+    gmsh.model.occ.synchronize()
+    gmsh.option.setNumber("Mesh.CharacteristicLengthMax", 0.5)
+    gmsh.model.mesh.generate(3)
+    yield
+    gmsh.finalize()
+
+
+@pytest.fixture
+def box_mesh_with_physical():
+    gmsh.initialize()
+    gmsh.option.setNumber("General.Terminal", 0)
+    gmsh.model.add("test")
+    vol_tag = gmsh.model.occ.addBox(0, 0, 0, 1, 1, 1)
+    gmsh.model.occ.synchronize()
+    pg_vol = gmsh.model.addPhysicalGroup(3, [vol_tag])
+    gmsh.model.setPhysicalName(3, pg_vol, "volume")
+    face_tags = [t for _, t in gmsh.model.getEntities(2)[:2]]
+    pg_face = gmsh.model.addPhysicalGroup(2, face_tags)
+    gmsh.model.setPhysicalName(2, pg_face, "surface")
+    gmsh.option.setNumber("Mesh.CharacteristicLengthMax", 0.5)
+    gmsh.model.mesh.generate(3)
+    yield
+    gmsh.finalize()
+
+
+def test_points_shape(box_mesh):
+    m = _to_meshio()
+    assert m.points.ndim == 2
+    assert m.points.shape[1] == 3
+
+
+def test_points_nonempty(box_mesh):
+    m = _to_meshio()
+    assert len(m.points) > 0
+
+
+def test_cells_nonempty(box_mesh):
+    m = _to_meshio()
+    assert len(m.cells) > 0
+    assert sum(len(cb.data) for cb in m.cells) > 0
+
+
+def test_no_physical_groups(box_mesh):
+    m = _to_meshio()
+    assert m.cell_sets == {}
+
+
+def test_physical_group_names(box_mesh_with_physical):
+    m = _to_meshio()
+    assert "volume" in m.cell_sets
+    assert "surface" in m.cell_sets
+
+
+def test_physical_group_nonempty(box_mesh_with_physical):
+    m = _to_meshio()
+    volume_arrays = [a for a in m.cell_sets["volume"] if a is not None]
+    assert len(volume_arrays) > 0
+    assert sum(len(a) for a in volume_arrays) > 0
+
+
+def test_node_indices_are_consecutive(box_mesh):
+    idx, _, _ = gmsh.model.mesh.getNodes()
+    idx -= 1
+    srt = np.argsort(idx)
+    assert np.all(idx[srt] == np.arange(len(idx)))

cadgmsh-0.1.0/tests/test_mesh.py

@@ -0,0 +1,81 @@
+import meshio
+import pytest
+
+bd = pytest.importorskip("build123d")
+
+
+def box():
+    return bd.Box(1, 1, 1)
+
+
+def sphere():
+    return bd.Sphere(0.4)
+
+
+def test_returns_meshio_mesh():
+    import cadgmsh
+    result = cadgmsh.mesh(box(), lc=0.5)
+    assert isinstance(result, meshio.Mesh)
+
+
+def test_points_and_cells():
+    import cadgmsh
+    result = cadgmsh.mesh(box(), lc=0.5)
+    assert result.points.shape[1] == 3
+    assert len(result.points) > 0
+    assert len(result.cells) > 0
+
+
+def test_list_input():
+    import cadgmsh
+    result = cadgmsh.mesh([box()], lc=0.5)
+    assert isinstance(result, meshio.Mesh)
+
+
+def test_physical_volume():
+    import cadgmsh
+    b = box()
+    result = cadgmsh.mesh(b, physical={"steel": b}, lc=0.5)
+    assert "steel" in result.cell_sets
+    volume_arrays = [a for a in result.cell_sets["steel"] if a is not None]
+    assert len(volume_arrays) > 0
+
+
+def test_physical_face():
+    import cadgmsh
+    b = box()
+    bottom = b.faces().sort_by(bd.Axis.Z)[0]
+    result = cadgmsh.mesh(b, physical={"bottom": bottom}, lc=0.5)
+    assert "bottom" in result.cell_sets
+
+
+def test_dim2():
+    import cadgmsh
+    result = cadgmsh.mesh(box(), dim=2, lc=0.5)
+    cell_types = {cb.type for cb in result.cells}
+    assert not any("tetra" in t for t in cell_types)
+
+
+def test_order2():
+    import cadgmsh
+    result = cadgmsh.mesh(box(), order=2, lc=0.5)
+    cell_types = {cb.type for cb in result.cells}
+    assert "tetra10" in cell_types
+
+
+def test_imprint_two_separated_boxes():
+    import cadgmsh
+    # imprint=True with non-touching shapes: exercises the code path without
+    # triggering OCC Boolean failures on coincident faces
+    b1 = bd.Box(1, 1, 1)
+    b2 = bd.Location((2, 0, 0)) * bd.Box(1, 1, 1)
+    result = cadgmsh.mesh([b1, b2], imprint=True, lc=0.5)
+    assert isinstance(result, meshio.Mesh)
+    assert len(result.points) > 0
+
+
+def test_lc_affects_mesh_density():
+    import cadgmsh
+    coarse = cadgmsh.mesh(box(), lc=0.5)
+    fine = cadgmsh.mesh(box(), lc=0.12)
+    assert len(fine.points) > len(coarse.points)

cadgmsh-0.1.0/tests/test_occ.py

@@ -0,0 +1,61 @@
+import pytest
+
+from cadgmsh._occ import _pointer, _unwrap
+
+
+class _WithAddress:
+    def _address(self):
+        return 42
+
+
+class _WithThis:
+    this = 99
+
+
+def test_unwrap_passthrough():
+    obj = object()
+    assert _unwrap(obj) is obj
+
+
+def test_unwrap_unwraps():
+    inner = object()
+
+    class Wrapped:
+        wrapped = inner
+
+    assert _unwrap(Wrapped()) is inner
+
+
+def test_pointer_address():
+    assert _pointer(_WithAddress()) == 42
+
+
+def test_pointer_this():
+    assert _pointer(_WithThis()) == 99
+
+
+def test_pointer_wrapped_address():
+    class Shape:
+        wrapped = _WithAddress()
+
+    assert _pointer(Shape()) == 42
+
+
+def test_pointer_wrapped_this():
+    class Shape:
+        wrapped = _WithThis()
+
+    assert _pointer(Shape()) == 99
+
+
+def test_pointer_raises_on_unknown():
+    with pytest.raises(TypeError):
+        _pointer(object())
+
+
+def test_pointer_raises_on_wrapped_unknown():
+    class Shape:
+        wrapped = object()
+
+    with pytest.raises(TypeError):
+        _pointer(Shape())