witwin 0.0.2__tar.gz → 0.3.0__tar.gz

{witwin-0.0.2 → witwin-0.3.0}/.github/workflows/publish-witwin.yml

@@ -83,14 +83,13 @@ jobs:
           PY
 
   build_cuda_wheels:
-    name: Build CUDA wheel / ${{ matrix.os }} / py${{ matrix.python_version }}
+    name: Build stable CUDA wheel / ${{ matrix.os }}
     needs: validate_release
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu-22.04, windows-2022]
-        python_version: ["3.10", "3.11", "3.12"]
 
     steps:
       - name: Check out repository
@@ -99,7 +98,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: ${{ matrix.python_version }}
+          python-version: "3.10"
 
       - name: Free disk space (Linux)
         if: runner.os == 'Linux'
@@ -113,11 +112,11 @@ jobs:
           echo "Disk after cleanup:"; df -h /
 
       - name: Install CUDA Toolkit
-        uses: Jimver/cuda-toolkit@v0.2.29
+        uses: Jimver/cuda-toolkit@v0.2.35
         with:
-          cuda: "12.5.0"
+          cuda: "12.8.1"
           method: local
-          log-file-suffix: "${{ runner.os }}-py${{ matrix.python_version }}"
+          log-file-suffix: "${{ runner.os }}-stable-abi"
 
       - name: Set up MSVC
         if: runner.os == 'Windows'
@@ -149,19 +148,28 @@ jobs:
       - name: Install CUDA extension build dependencies
         run: |
           python -m pip install --upgrade pip setuptools wheel ninja numpy
-          python -m pip install torch==2.6.0 --index-url https://download.pytorch.org/whl/cu124
+          python -m pip install torch==2.10.0 --index-url https://download.pytorch.org/whl/cu128
           python -m pip install build
 
-      - name: Build packaged mesh SDF CUDA extension
+      - name: Build packaged stable mesh SDF CUDA extension
         shell: bash
         env:
           MAX_JOBS: "2"
-          TORCH_CUDA_ARCH_LIST: "7.0;8.0;8.6;8.9;9.0+PTX"
-          WITWIN_CORE_MESH_SDF_CUDA_BUILD_DIR: ${{ runner.temp }}/witwin_core_mesh_sdf_cuda
+          WITWIN_CUDA_GENCODE_ARCHES: "7.0;7.5;8.0;8.6;8.9;9.0;10.0;10.1;12.0+PTX"
           PACKAGE_DIR: ${{ needs.validate_release.outputs.package_dir }}
+          WITWIN_CORE_MESH_SDF_CUDA_BUILD_DIR: ${{ runner.temp }}/witwin_core_mesh_sdf_cuda/stable_abi_v1
         run: |
           python "$PACKAGE_DIR"/scripts/build_mesh_sdf_cuda_prebuilt.py --verbose
 
+      - name: Verify compiled CUDA architectures
+        shell: bash
+        env:
+          PACKAGE_DIR: ${{ needs.validate_release.outputs.package_dir }}
+        run: |
+          python "$PACKAGE_DIR"/scripts/verify_cuda_binary_arches.py \
+            --stem witwin_core_mesh_sdf_cuda \
+            "$PACKAGE_DIR"/witwin/core/geometry/cuda/prebuilt
+
       - name: Build platform wheel
         shell: bash
         env:
@@ -169,21 +177,25 @@ jobs:
         run: |
           python -m build --wheel "$PACKAGE_DIR"
 
-      - name: Normalize Linux wheel platform tag
+      - name: Repair Linux wheel platform tag
         if: runner.os == 'Linux'
         shell: bash
         env:
           PACKAGE_DIR: ${{ needs.validate_release.outputs.package_dir }}
         run: |
-          # PyPI rejects the raw linux_x86_64 tag; the extension is built on the
-          # ubuntu-22.04 runner (glibc 2.35), so retag to the matching manylinux
-          # tag. torch/CUDA runtime libraries are runtime dependencies and stay
-          # unbundled, so no auditwheel repair is required.
-          shopt -s nullglob
+          python -m pip install auditwheel patchelf
+          mkdir -p "$PACKAGE_DIR"/wheelhouse
           for whl in "$PACKAGE_DIR"/dist/*-linux_x86_64.whl; do
-            echo "Retagging $whl"
-            python -m wheel tags --platform-tag manylinux_2_35_x86_64 --remove "$whl"
+            python -m auditwheel repair "$whl" \
+              --plat manylinux_2_35_x86_64 \
+              --wheel-dir "$PACKAGE_DIR"/wheelhouse \
+              --exclude libc10.so --exclude libc10_cuda.so \
+              --exclude libtorch.so --exclude libtorch_cpu.so \
+              --exclude libtorch_cuda.so --exclude libtorch_python.so \
+              --exclude libcudart.so.12 --exclude libcuda.so.1
           done
+          rm -f "$PACKAGE_DIR"/dist/*-linux_x86_64.whl
+          mv "$PACKAGE_DIR"/wheelhouse/*.whl "$PACKAGE_DIR"/dist/
           ls -l "$PACKAGE_DIR"/dist
 
       - name: Smoke install prebuilt wheel
@@ -197,9 +209,18 @@ jobs:
           python -m pip install --no-deps "$PACKAGE_DIR"/dist/*.whl
           python - <<'PY'
           import importlib.util
+          import os
           import site
+          import zipfile
           from pathlib import Path
 
+          wheel = next((Path(os.environ["PACKAGE_DIR"]) / "dist").glob("*.whl"))
+          names = zipfile.ZipFile(wheel).namelist()
+          native = [name for name in names if "witwin_core_mesh_sdf_cuda" in name and name.endswith((".so", ".pyd"))]
+          assert len(native) == 1, native
+          assert "/prebuilt/" in f"/{native[0]}"
+          assert "torch_" not in native[0]
+
           candidates = []
           for root in site.getsitepackages() + [site.getusersitepackages()]:
               candidates.append(Path(root) / "witwin" / "core" / "geometry" / "cuda" / "build.py")
@@ -212,6 +233,7 @@ jobs:
 
           path = module.prebuilt_extension_path()
           assert path.exists(), f"missing packaged prebuilt extension: {path}"
+          assert path.parent.name == "prebuilt"
           extension = module.build_extension()
           print(f"Loaded packaged mesh SDF CUDA extension from {extension.__file__}")
           PY
@@ -219,10 +241,83 @@ jobs:
       - name: Upload wheel artifact
         uses: actions/upload-artifact@v4
         with:
-          name: wheel-${{ matrix.os }}-py${{ matrix.python_version }}
+          name: wheel-${{ matrix.os }}
           path: ${{ needs.validate_release.outputs.package_dir }}/dist/*.whl
           if-no-files-found: error
 
+  test_torch_compatibility:
+    name: Stable ABI / ${{ matrix.os }} / py${{ matrix.compatibility.python_version }} / torch${{ matrix.compatibility.torch_version }}
+    needs:
+      - validate_release
+      - build_cuda_wheels
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, windows-2022]
+        compatibility:
+          - {python_version: "3.10", torch_version: "2.10.0", cuda_index: "cu128"}
+          - {python_version: "3.11", torch_version: "2.10.0", cuda_index: "cu128"}
+          - {python_version: "3.12", torch_version: "2.10.0", cuda_index: "cu128"}
+          - {python_version: "3.13", torch_version: "2.10.0", cuda_index: "cu128"}
+          - {python_version: "3.14", torch_version: "2.10.0", cuda_index: "cu128"}
+          - {python_version: "3.14", torch_version: "2.11.0", cuda_index: "cu128"}
+          - {python_version: "3.14", torch_version: "2.12.0", cuda_index: "cu126"}
+
+    steps:
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.compatibility.python_version }}
+
+      - name: Download stable wheel
+        uses: actions/download-artifact@v4
+        with:
+          name: wheel-${{ matrix.os }}
+          path: dist
+
+      - name: Install compatibility environment
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install --no-cache-dir "torch==${{ matrix.compatibility.torch_version }}" \
+            --index-url "https://download.pytorch.org/whl/${{ matrix.compatibility.cuda_index }}"
+          python -m pip install --no-deps dist/*.whl
+
+      - name: Load the same stable binary
+        shell: bash
+        env:
+          EXPECTED_TORCH: ${{ matrix.compatibility.torch_version }}
+          WITWIN_CORE_MESH_SDF_CUDA_PREBUILT: "1"
+          WITWIN_CORE_MESH_SDF_CUDA_BUILD_DIR: ${{ runner.temp }}/must-not-jit-build
+        run: |
+          python - <<'PY'
+          import importlib.util
+          import os
+          import site
+          from pathlib import Path
+
+          import torch
+
+          assert torch.__version__.split("+", 1)[0] == os.environ["EXPECTED_TORCH"]
+          candidates = [
+              Path(root) / "witwin" / "core" / "geometry" / "cuda" / "build.py"
+              for root in site.getsitepackages() + [site.getusersitepackages()]
+          ]
+          build_path = next((path for path in candidates if path.exists()), None)
+          assert build_path is not None, candidates
+          spec = importlib.util.spec_from_file_location("witwin_core_mesh_sdf_cuda_build", build_path)
+          module = importlib.util.module_from_spec(spec)
+          spec.loader.exec_module(module)
+
+          native_path = module.prebuilt_extension_path()
+          assert native_path.exists(), native_path
+          extension = module.build_extension()
+          assert Path(extension.__file__).resolve() == native_path.resolve()
+          assert extension.query_mesh_unsigned_distance is not None
+          print(f"Loaded {native_path.name} with torch {torch.__version__} on Python {os.sys.version.split()[0]}")
+          PY
+
   build_sdist:
     name: Build source distribution
     needs: validate_release
@@ -257,6 +352,7 @@ jobs:
     if: github.event_name == 'release'
     needs:
       - build_cuda_wheels
+      - test_torch_compatibility
       - build_sdist
     runs-on: ubuntu-latest
     permissions:

{witwin-0.0.2 → witwin-0.3.0}/.gitignore

@@ -171,9 +171,6 @@ venv.bak/
 
 # mkdocs documentation
 /site
-.slangtorch_cache/
-.fdtd_runtime_*.slang
-.adjoint_kernels_runtime_*.slang
 *.png
 *.npy
 *.npz

witwin-0.3.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: witwin
+Version: 0.3.0
+Summary: Witwin shared geometry, material, and structure contracts
+License-Expression: MIT
+Requires-Python: <3.15,>=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: torch>=2.10
+Provides-Extra: all
+Requires-Dist: witwin-channel-native<0.2,>=0.1; extra == 'all'
+Requires-Dist: witwin-genesis<0.2,>=0.1; extra == 'all'
+Requires-Dist: witwin-maxwell<0.3,>=0.2; extra == 'all'
+Requires-Dist: witwin-radar<0.4,>=0.3; extra == 'all'
+Provides-Extra: channel
+Requires-Dist: witwin-channel-native<0.2,>=0.1; extra == 'channel'
+Provides-Extra: genesis
+Requires-Dist: witwin-genesis<0.2,>=0.1; extra == 'genesis'
+Provides-Extra: maxwell
+Requires-Dist: witwin-maxwell<0.3,>=0.2; extra == 'maxwell'
+Provides-Extra: radar
+Requires-Dist: witwin-radar<0.4,>=0.3; extra == 'radar'
+Description-Content-Type: text/markdown
+
+# WiTwin Core
+
+WiTwin Core is the shared data and geometry package of the WiTwin stack. It defines the geometry and material contracts consumed by solver packages without imposing a common solver-specific scene lifecycle.
+
+## Get Started
+
+CPython 3.10-3.14, PyTorch 2.10 or newer, and an NVIDIA GPU are supported for the main WiTwin simulation workflows.
+
+```bash
+pip install witwin
+```
+
+## Prebuilt CUDA Support
+
+Release wheels are built for Linux x86_64 and Windows x86_64 with CUDA 12.8. Each platform wheel carries one PyTorch Stable ABI native library built against PyTorch 2.10 and reused across supported Python and PyTorch versions; CI currently verifies PyTorch 2.10-2.12. The fat binaries contain native code for compute capabilities 7.0, 7.5, 8.0, 8.6, 8.9, 9.0, 10.0, 10.1, and 12.0, plus compute 12.0 PTX for forward-compatible Blackwell execution. This includes native coverage for RTX 2080-class Turing GPUs and current data-center and RTX/RTX PRO Blackwell families.
+
+Linux wheels target `manylinux_2_35_x86_64`. The installed NVIDIA driver must support the CUDA 12.x runtime supplied by PyTorch; the CUDA toolkit is only needed for source/JIT builds.
+
+For full CUDA 12.8 and Blackwell support, use at least driver 570.26 on Linux or 570.65 on Windows. Pre-Blackwell systems can use NVIDIA's CUDA 12.x minor-version compatibility floor (525.60.13 on Linux or 528.33 on Windows), subject to NVIDIA's compatibility-mode feature limits.
+
+## What It Provides
+
+- Runtime-checkable `GeometrySpec` and `MaterialSpec` contracts
+- Shared analytic geometry primitives and differentiable mesh/SDF utilities
+- Reusable `Material` and `Structure` values for solver-owned scenes
+
+Each solver owns its public `Scene` implementation. Radar-specific SMPL geometry lives in `witwin.radar.geometry`; Maxwell-specific `PolySlab` geometry lives in `witwin.maxwell.geometry`.
+
+## Related Solvers
+
+- [WiTwin Maxwell](https://github.com/witwin-ai/witwin-maxwell)
+- [WiTwin Radar](https://github.com/witwin-ai/witwin-radar)
+
+## Developer
+
+<a href="http://xingyuchen.me/">
+  <img src="https://github.com/Asixa.png" alt="Xingyu Chen" width="48" height="48" style="border-radius:50%;">
+</a>
+
+[Xingyu Chen](http://xingyuchen.me/)

witwin-0.3.0/README.md

@@ -0,0 +1,40 @@
+# WiTwin Core
+
+WiTwin Core is the shared data and geometry package of the WiTwin stack. It defines the geometry and material contracts consumed by solver packages without imposing a common solver-specific scene lifecycle.
+
+## Get Started
+
+CPython 3.10-3.14, PyTorch 2.10 or newer, and an NVIDIA GPU are supported for the main WiTwin simulation workflows.
+
+```bash
+pip install witwin
+```
+
+## Prebuilt CUDA Support
+
+Release wheels are built for Linux x86_64 and Windows x86_64 with CUDA 12.8. Each platform wheel carries one PyTorch Stable ABI native library built against PyTorch 2.10 and reused across supported Python and PyTorch versions; CI currently verifies PyTorch 2.10-2.12. The fat binaries contain native code for compute capabilities 7.0, 7.5, 8.0, 8.6, 8.9, 9.0, 10.0, 10.1, and 12.0, plus compute 12.0 PTX for forward-compatible Blackwell execution. This includes native coverage for RTX 2080-class Turing GPUs and current data-center and RTX/RTX PRO Blackwell families.
+
+Linux wheels target `manylinux_2_35_x86_64`. The installed NVIDIA driver must support the CUDA 12.x runtime supplied by PyTorch; the CUDA toolkit is only needed for source/JIT builds.
+
+For full CUDA 12.8 and Blackwell support, use at least driver 570.26 on Linux or 570.65 on Windows. Pre-Blackwell systems can use NVIDIA's CUDA 12.x minor-version compatibility floor (525.60.13 on Linux or 528.33 on Windows), subject to NVIDIA's compatibility-mode feature limits.
+
+## What It Provides
+
+- Runtime-checkable `GeometrySpec` and `MaterialSpec` contracts
+- Shared analytic geometry primitives and differentiable mesh/SDF utilities
+- Reusable `Material` and `Structure` values for solver-owned scenes
+
+Each solver owns its public `Scene` implementation. Radar-specific SMPL geometry lives in `witwin.radar.geometry`; Maxwell-specific `PolySlab` geometry lives in `witwin.maxwell.geometry`.
+
+## Related Solvers
+
+- [WiTwin Maxwell](https://github.com/witwin-ai/witwin-maxwell)
+- [WiTwin Radar](https://github.com/witwin-ai/witwin-radar)
+
+## Developer
+
+<a href="http://xingyuchen.me/">
+  <img src="https://github.com/Asixa.png" alt="Xingyu Chen" width="48" height="48" style="border-radius:50%;">
+</a>
+
+[Xingyu Chen](http://xingyuchen.me/)

{witwin-0.0.2 → witwin-0.3.0}/hatch_build.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sysconfig
 from pathlib import Path
 
 from hatchling.builders.hooks.plugin.interface import BuildHookInterface
@@ -13,5 +14,6 @@ class CustomBuildHook(BuildHookInterface):
         prebuilt_dir = Path(self.root) / "witwin" / "core" / "geometry" / "cuda" / "prebuilt"
         has_prebuilt_extension = any(prebuilt_dir.glob("witwin_core_mesh_sdf_cuda.*"))
         if has_prebuilt_extension:
-            build_data["infer_tag"] = True
+            platform_tag = sysconfig.get_platform().replace("-", "_").replace(".", "_")
+            build_data["tag"] = f"py3-none-{platform_tag}"
             build_data["pure_python"] = False

witwin-0.3.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "witwin"
+version = "0.3.0"
+description = "Witwin shared geometry, material, and structure contracts"
+readme = "README.md"
+requires-python = ">=3.10,<3.15"
+license = "MIT"
+
+dependencies = [
+    "numpy>=1.24",
+    "torch>=2.10",
+]
+
+[project.optional-dependencies]
+maxwell = ["witwin-maxwell>=0.2,<0.3"]
+radar   = ["witwin-radar>=0.3,<0.4"]
+channel = ["witwin-channel-native>=0.1,<0.2"]
+genesis = ["witwin-genesis>=0.1,<0.2"]
+all     = [
+    "witwin-maxwell>=0.2,<0.3",
+    "witwin-radar>=0.3,<0.4",
+    "witwin-channel-native>=0.1,<0.2",
+    "witwin-genesis>=0.1,<0.2",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["witwin"]
+artifacts = [
+    "witwin/core/geometry/cuda/**/*.cpp",
+    "witwin/core/geometry/cuda/**/*.cu",
+    "witwin/core/geometry/cuda/**/*.cuh",
+    "witwin/core/geometry/cuda/**/*.h",
+    "witwin/core/geometry/cuda/prebuilt/**/*.pyd",
+    "witwin/core/geometry/cuda/prebuilt/**/*.so",
+]
+
+[tool.hatch.build.hooks.custom]
+path = "hatch_build.py"

{witwin-0.0.2 → witwin-0.3.0}/scripts/build_mesh_sdf_cuda_prebuilt.py

@@ -39,24 +39,24 @@ def main() -> None:
     parser.add_argument("--verbose", action="store_true")
     args = parser.parse_args()
 
+    cuda_build = _load_cuda_build_module()
     build_dir = Path(
         os.environ.get(
             "WITWIN_CORE_MESH_SDF_CUDA_BUILD_DIR",
-            Path(tempfile.gettempdir()) / "witwin_core_mesh_sdf_cuda_wheel",
+            Path(tempfile.gettempdir()) / "witwin_core_mesh_sdf_cuda_wheel" / "stable_abi_v1",
         )
     )
     os.environ["WITWIN_CORE_MESH_SDF_CUDA_BUILD_DIR"] = str(build_dir)
     os.environ["WITWIN_CORE_MESH_SDF_CUDA_SKIP_PREBUILT"] = "1"
     _ensure_current_device_arch()
 
-    cuda_build = _load_cuda_build_module()
     module = cuda_build.build_extension(verbose=args.verbose)
     module_file = Path(module.__file__).resolve()
 
     target_dir = cuda_build.prebuilt_root()
     target_dir.mkdir(parents=True, exist_ok=True)
     for suffix in (".pyd", ".so"):
-        existing = target_dir / f"witwin_core_mesh_sdf_cuda{suffix}"
+        existing = target_dir / f"{cuda_build.EXTENSION_NAME}{suffix}"
         if existing.exists():
             existing.unlink()
     target = cuda_build.prebuilt_extension_path()

witwin-0.3.0/scripts/verify_cuda_binary_arches.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import argparse
+import subprocess
+import tempfile
+import zipfile
+from pathlib import Path
+
+
+EXPECTED_SASS = ("70", "75", "80", "86", "89", "90", "100", "101", "120")
+EXPECTED_PTX_TARGET = "sm_120"
+
+
+def _matches(path: Path, stems: tuple[str, ...]) -> bool:
+    return path.suffix in {".pyd", ".so"} and any(path.name.startswith(stem) for stem in stems)
+
+
+def _collect_binaries(inputs: list[Path], stems: tuple[str, ...], extract_root: Path) -> list[Path]:
+    binaries: list[Path] = []
+    for input_path in inputs:
+        if input_path.suffix == ".whl":
+            with zipfile.ZipFile(input_path) as wheel:
+                for name in wheel.namelist():
+                    member = Path(name)
+                    if not _matches(member, stems):
+                        continue
+                    wheel.extract(name, extract_root)
+                    binaries.append(extract_root / member)
+            continue
+        if input_path.is_dir():
+            binaries.extend(path for path in input_path.rglob("*") if _matches(path, stems))
+            continue
+        if _matches(input_path, stems):
+            binaries.append(input_path)
+    return sorted(set(path.resolve() for path in binaries))
+
+
+def _cuobjdump(flag: str, binary: Path) -> str:
+    result = subprocess.run(
+        ["cuobjdump", flag, str(binary)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return f"{result.stdout}\n{result.stderr}"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Verify CUDA SASS and PTX targets in release binaries.")
+    parser.add_argument("inputs", nargs="+", type=Path)
+    parser.add_argument("--stem", action="append", required=True)
+    args = parser.parse_args()
+
+    with tempfile.TemporaryDirectory(prefix="witwin_cuda_arch_verify_") as temp_dir:
+        binaries = _collect_binaries(args.inputs, tuple(args.stem), Path(temp_dir))
+        if not binaries:
+            raise SystemExit(f"No native binaries matching {args.stem!r} were found.")
+
+        for binary in binaries:
+            elf_listing = _cuobjdump("--list-elf", binary)
+            missing_sass = [arch for arch in EXPECTED_SASS if f"sm_{arch}" not in elf_listing]
+            if missing_sass:
+                raise SystemExit(f"{binary} is missing SASS targets: {', '.join(missing_sass)}")
+
+            ptx_dump = _cuobjdump("--dump-ptx", binary)
+            if f".target {EXPECTED_PTX_TARGET}" not in ptx_dump:
+                raise SystemExit(f"{binary} is missing compute 12.0 PTX.")
+
+            print(f"Verified CUDA architectures in {binary}")
+
+
+if __name__ == "__main__":
+    main()

witwin-0.3.0/tests/test_contracts.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import pytest
+import torch
+
+from witwin.core import (
+    FrequencyMaterialSample,
+    GeometrySpec,
+    MaterialCapabilities,
+    MaterialSpec,
+    StaticMaterialSample,
+    Structure,
+)
+
+
+class DuckGeometry:
+    kind = "duck"
+
+    def to_mesh(self, segments: int = 16):
+        del segments
+        return torch.zeros((3, 3)), torch.tensor([[0, 1, 2]])
+
+
+class DuckMaterial:
+    name = "duck"
+
+    def capabilities(self):
+        return MaterialCapabilities()
+
+    def evaluate_static(self):
+        return StaticMaterialSample(eps_r=2.0)
+
+    def evaluate_at_frequency(self, frequency: float):
+        del frequency
+        return FrequencyMaterialSample(eps_r=2.0)
+
+
+def test_structure_accepts_protocol_conforming_values():
+    geometry = DuckGeometry()
+    material = DuckMaterial()
+
+    assert isinstance(geometry, GeometrySpec)
+    assert isinstance(material, MaterialSpec)
+    assert Structure(geometry=geometry, material=material).geometry is geometry
+
+
+@pytest.mark.parametrize(
+    ("geometry", "material", "message"),
+    [
+        (object(), DuckMaterial(), "GeometrySpec"),
+        (DuckGeometry(), object(), "MaterialSpec"),
+    ],
+)
+def test_structure_rejects_values_outside_shared_contracts(geometry, material, message):
+    with pytest.raises(TypeError, match=message):
+        Structure(geometry=geometry, material=material)

witwin-0.3.0/tests/test_dependency_contract.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+
+
+def test_runtime_and_optional_dependencies_do_not_include_slangtorch():
+    pyproject = tomllib.loads(Path("pyproject.toml").read_text(encoding="utf-8"))
+    groups = [pyproject["project"]["dependencies"]]
+    groups.extend(pyproject["project"].get("optional-dependencies", {}).values())
+    assert all(
+        not dependency.lower().startswith("slangtorch")
+        for group in groups
+        for dependency in group
+    )

{witwin-0.0.2 → witwin-0.3.0}/tests/test_geometry_sdf.py

@@ -4,7 +4,6 @@ import pytest
 import torch
 
 from witwin.core import Box, Cone, Cylinder, Ellipsoid, HollowBox, Mesh, Prism, Pyramid, Sphere, Torus
-from witwin.core.geometry import ComplexPolySlab, PolySlab
 from witwin.core.geometry.mesh_sdf import (
     _mesh_sdf_available,
     _triangle_mesh_smooth_signed_distance_torch,
@@ -152,39 +151,6 @@ def _require_cuda_mesh_sdf():
             (0.5, 0.0, 0.0),
             (0.7, 0.0, 0.0),
         ),
-        (
-            PolySlab(
-                vertices=[(-0.5, -0.5), (0.5, -0.5), (0.5, 0.5), (-0.5, 0.5)],
-                bounds=(-0.5, 0.5),
-                axis="z",
-            ),
-            (0.0, 0.0, 0.0),
-            (0.5, 0.0, 0.0),
-            (0.7, 0.0, 0.0),
-        ),
-        (
-            # Non-convex L-shape: the notch quadrant must be outside.
-            PolySlab(
-                vertices=[(-0.5, -0.5), (0.5, -0.5), (0.5, 0.0), (0.0, 0.0), (0.0, 0.5), (-0.5, 0.5)],
-                bounds=(-0.5, 0.5),
-                axis="z",
-            ),
-            (-0.25, -0.25, 0.0),
-            (0.5, -0.25, 0.0),
-            (0.25, 0.25, 0.0),
-        ),
-        (
-            ComplexPolySlab(
-                loops=[
-                    [(-0.5, -0.5), (0.5, -0.5), (0.5, 0.5), (-0.5, 0.5)],
-                    [(-0.2, -0.2), (0.2, -0.2), (0.2, 0.2), (-0.2, 0.2)],
-                ],
-                bounds=(-0.5, 0.5),
-            ),
-            (0.35, 0.0, 0.0),
-            (0.5, 0.0, 0.0),
-            (0.0, 0.0, 0.0),
-        ),
     ],
 )
 def test_primitive_signed_distance_has_expected_sign(geometry, inside_point, surface_point, outside_point):
@@ -214,16 +180,6 @@ def test_primitive_signed_distance_has_expected_sign(geometry, inside_point, sur
         (Cone(radius=0.4, height=1.0, axis="z"), (0.0, 0.0, 0.5), (0.2, 0.0, 0.5), (0.3, 0.0, 0.5)),
         (Pyramid(base_size=1.0, height=1.0, axis="z"), (0.0, 0.0, 0.5), (0.25, 0.0, 0.5), (0.35, 0.0, 0.5)),
         (Prism(radius=0.4, height=1.0, num_sides=5, axis="z"), (0.0, 0.0, 0.0), (0.4, 0.0, 0.0), (0.6, 0.0, 0.0)),
-        (
-            PolySlab(
-                vertices=[(-0.4, -0.4), (0.4, -0.4), (0.4, 0.4), (-0.4, 0.4)],
-                bounds=(-0.5, 0.5),
-                axis="z",
-            ),
-            (0.0, 0.0, 0.0),
-            (0.4, 0.0, 0.0),
-            (0.7, 0.0, 0.0),
-        ),
     ],
 )
 def test_primitive_occupancy_is_monotone_and_bounded(geometry, inside_point, boundary_point, outside_point):
@@ -371,27 +327,6 @@ def test_prism_occupancy_has_gradients_for_position_radius_height_and_rotation()
         assert abs(grad.item()) > 1.0e-6
 
 
-def test_polyslab_occupancy_has_gradients_for_vertices_bounds_and_sidewall_angle():
-    xx, yy, zz = _asymmetric_grid()
-    vertices = torch.nn.Parameter(
-        torch.tensor([[-0.31, -0.24], [0.29, -0.24], [0.29, 0.26], [-0.31, 0.26]], dtype=torch.float32)
-    )
-    bounds = torch.nn.Parameter(torch.tensor([-0.28, 0.17], dtype=torch.float32))
-    sidewall_angle = torch.nn.Parameter(torch.tensor(0.10, dtype=torch.float32))
-
-    geometry = PolySlab(vertices, bounds, axis="z", sidewall_angle=sidewall_angle)
-    loss = geometry.to_mask(xx, yy, zz, beta=0.06).sum()
-    loss.backward()
-
-    for grad in (vertices.grad, bounds.grad):
-        assert grad is not None
-        assert torch.all(torch.isfinite(grad))
-        assert torch.any(grad.abs() > 1.0e-6)
-    assert sidewall_angle.grad is not None
-    assert torch.isfinite(sidewall_angle.grad)
-    assert abs(sidewall_angle.grad.item()) > 1.0e-6
-
-
 def test_mesh_signed_distance_matches_box_sign_for_closed_cube():
     vertices, faces = _cube_mesh(size=1.0)
     mesh = Mesh(vertices, faces, recenter=False, fill_mode="solid")