chore: pre-commit, ruff, mypy, type stubs

Author: basnijholt

.pre-commit-config.yaml

@@ -0,0 +1,36 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+      - id: check-merge-conflict
+      - id: check-added-large-files
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.0
+    hooks:
+      - id: ruff
+        args: [--fix, --unsafe-fixes]
+      - id: ruff-format
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.14.0
+    hooks:
+      - id: mypy
+        additional_dependencies: [numpy]
+        args: [--strict]
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --check
+        language: system
+        types: [rust]
+        pass_filenames: false
+      - id: cargo-clippy
+        name: cargo clippy
+        entry: cargo clippy -- -D warnings
+        language: system
+        types: [rust]
+        pass_filenames: false

pyproject.toml

@@ -33,3 +33,19 @@ Repository = "https://github.com/python-adaptive/adaptive-triangulation"
 features = ["pyo3/extension-module"]
 python-source = "python"
 module-name = "adaptive_triangulation._rust"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["ALL"]
+ignore = ["D", "COM812", "ISC001"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101", "PLR2004", "ANN"]
+"benchmarks/*" = ["T201", "ANN", "S101"]
+
+[tool.mypy]
+strict = true
+python_version = "3.10"

python/adaptive_triangulation/__init__.py

@@ -22,9 +22,8 @@
 
 from __future__ import annotations
 
-from adaptive_triangulation._rust import (
+from ._rust import (
     Triangulation,
-    __version__ as __version__,
     circumsphere,
     fast_2d_circumcircle,
     fast_2d_point_in_simplex,
@@ -36,8 +35,11 @@
     simplex_volume_in_embedding,
     volume,
 )
+from ._rust import (
+    __version__ as __version__,
+)
 
-__all__ = [
+__all__: list[str] = [
     "Triangulation",
     "__version__",
     "circumsphere",

python/adaptive_triangulation/__init__.pyi

@@ -0,0 +1,51 @@
+from ._rust import (
+    Triangulation as Triangulation,
+)
+from ._rust import (
+    __version__ as __version__,
+)
+from ._rust import (
+    circumsphere as circumsphere,
+)
+from ._rust import (
+    fast_2d_circumcircle as fast_2d_circumcircle,
+)
+from ._rust import (
+    fast_2d_point_in_simplex as fast_2d_point_in_simplex,
+)
+from ._rust import (
+    fast_3d_circumcircle as fast_3d_circumcircle,
+)
+from ._rust import (
+    fast_3d_circumsphere as fast_3d_circumsphere,
+)
+from ._rust import (
+    fast_norm as fast_norm,
+)
+from ._rust import (
+    orientation as orientation,
+)
+from ._rust import (
+    point_in_simplex as point_in_simplex,
+)
+from ._rust import (
+    simplex_volume_in_embedding as simplex_volume_in_embedding,
+)
+from ._rust import (
+    volume as volume,
+)
+
+__all__: list[str] = [
+    "Triangulation",
+    "__version__",
+    "circumsphere",
+    "fast_2d_circumcircle",
+    "fast_2d_point_in_simplex",
+    "fast_3d_circumcircle",
+    "fast_3d_circumsphere",
+    "fast_norm",
+    "orientation",
+    "point_in_simplex",
+    "simplex_volume_in_embedding",
+    "volume",
+]

python/adaptive_triangulation/_rust.pyi

@@ -0,0 +1,106 @@
+from collections.abc import Iterable, Iterator, Sequence
+from typing import TypeAlias
+
+import numpy as np
+import numpy.typing as npt
+
+PointLike: TypeAlias = Sequence[float] | npt.ArrayLike
+PointsLike: TypeAlias = Sequence[Sequence[float]] | npt.ArrayLike
+SimplexLike: TypeAlias = Sequence[int]
+Simplex: TypeAlias = tuple[int, ...]
+SimplexSet: TypeAlias = set[Simplex]
+TransformLike: TypeAlias = Sequence[Sequence[float]] | npt.ArrayLike
+
+__version__: str
+
+
+class Triangulation:
+    def __init__(self, coords: PointsLike) -> None: ...
+
+    @property
+    def vertices(self) -> list[tuple[float, ...]]: ...
+
+    @property
+    def simplices(self) -> SimplexSet: ...
+
+    @property
+    def vertex_to_simplices(self) -> list[SimplexSet]: ...
+
+    @property
+    def hull(self) -> set[int]: ...
+
+    @property
+    def dim(self) -> int: ...
+
+    @property
+    def default_transform(self) -> npt.NDArray[np.float64]: ...
+
+    def add_simplex(self, simplex: SimplexLike) -> None: ...
+    def delete_simplex(self, simplex: SimplexLike) -> None: ...
+    def add_point(
+        self,
+        point: PointLike,
+        simplex: SimplexLike | None = None,
+        transform: TransformLike | None = None,
+    ) -> tuple[SimplexSet, SimplexSet]: ...
+    def get_vertices(self, indices: Sequence[int]) -> list[tuple[float, ...]]: ...
+    def locate_point(self, point: PointLike) -> tuple[int, ...]: ...
+    def get_reduced_simplex(
+        self,
+        point: PointLike,
+        simplex: SimplexLike,
+        eps: float = 1e-8,
+    ) -> list[int]: ...
+    def circumscribed_circle(
+        self,
+        simplex: SimplexLike,
+        transform: TransformLike | None = None,
+    ) -> tuple[tuple[float, ...], float]: ...
+    def point_in_circumcircle(
+        self,
+        pt_index: int,
+        simplex: SimplexLike,
+        transform: TransformLike | None = None,
+    ) -> bool: ...
+    def point_in_cicumcircle(
+        self,
+        pt_index: int,
+        simplex: SimplexLike,
+        transform: TransformLike | None = None,
+    ) -> bool: ...
+    def volume(self, simplex: SimplexLike) -> float: ...
+    def volumes(self) -> list[float]: ...
+    def faces(
+        self,
+        dim: int | None = None,
+        simplices: Iterable[SimplexLike] | None = None,
+        vertices: Iterable[int] | None = None,
+    ) -> Iterator[Simplex]: ...
+    def containing(self, face: Sequence[int]) -> SimplexSet: ...
+    def reference_invariant(self) -> bool: ...
+    def point_in_simplex(
+        self,
+        point: PointLike,
+        simplex: SimplexLike,
+        eps: float = 1e-8,
+    ) -> bool: ...
+    def bowyer_watson(
+        self,
+        pt_index: int,
+        containing_simplex: SimplexLike | None = None,
+        transform: TransformLike | None = None,
+    ) -> tuple[SimplexSet, SimplexSet]: ...
+    def vertex_invariant(self, vertex: int) -> bool: ...
+    def convex_invariant(self, vertex: int) -> bool: ...
+
+
+def circumsphere(points: PointsLike) -> tuple[tuple[float, ...], float]: ...
+def fast_2d_circumcircle(points: PointsLike) -> tuple[tuple[float, ...], float]: ...
+def fast_2d_point_in_simplex(point: PointLike, simplex: PointsLike, eps: float = 1e-8) -> bool: ...
+def fast_3d_circumcircle(points: PointsLike) -> tuple[tuple[float, ...], float]: ...
+def fast_3d_circumsphere(points: PointsLike) -> tuple[tuple[float, ...], float]: ...
+def fast_norm(point: PointLike) -> float: ...
+def orientation(face: PointsLike, origin: PointLike) -> int: ...
+def point_in_simplex(point: PointLike, simplex: PointsLike, eps: float = 1e-8) -> bool: ...
+def simplex_volume_in_embedding(vertices: PointsLike) -> float: ...
+def volume(simplex: PointsLike) -> float: ...

python/adaptive_triangulation/py.typed

@@ -0,0 +1 @@
+