halfedge 0.6.0__tar.gz → 0.8.1__tar.gz

{halfedge-0.6.0 → halfedge-0.8.1}/.github/workflows/pypi-project.yml

@@ -17,7 +17,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
         os: [ubuntu-latest, macos-latest, windows-latest]
     # if: startsWith(github.event.head_commit.message, 'bump:') == false
     steps:

{halfedge-0.6.0 → halfedge-0.8.1}/.pre-commit-config.yaml

@@ -4,7 +4,7 @@ ci:
 repos:
 
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.6.0
+  rev: v6.0.0
   hooks:
     - id: check-added-large-files
     - id: check-ast
@@ -29,9 +29,6 @@ repos:
     - id: mixed-line-ending
     - id: requirements-txt-fixer
     - id: trailing-whitespace
-    - id: fix-encoding-pragma
-      args:
-      - --remove
     - id: name-tests-test
       args:
       - --pytest-test-first
@@ -42,12 +39,12 @@ repos:
         # files: .pre-commit-config.yaml
 
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v1.11.1
+  rev: v1.17.1
   hooks:
   - id: mypy
     name: mypy
     language: python
-    language_version: python 3.12
+    language_version: python 3.9
     types: [python]
     require_serial: true
     verbose: true
@@ -58,23 +55,23 @@ repos:
     # files: ^(src/|tests/)
 
 - repo: https://github.com/PyCQA/isort
-  rev: 5.13.2
+  rev: 6.0.1
   hooks:
   - id: isort
     args: ["--profile", "black", "--filter-files", "--combine-as", "honor--noqa"]
 
 - repo: https://github.com/psf/black
-  rev: 24.8.0
+  rev: 25.1.0
   hooks:
   - id: black
-    language_version: python3.8
+    language_version: python3.9
     args: ["--skip-magic-trailing-comma"]
 
 - repo: https://github.com/asottile/pyupgrade
-  rev: v3.17.0
+  rev: v3.20.0
   hooks:
   - args:
-    - --py38-plus
+    - --py39-plus
     id: pyupgrade
 
 - repo: https://github.com/Lucas-C/pre-commit-hooks
@@ -83,7 +80,7 @@ repos:
   - id: remove-tabs
 
 - repo: https://github.com/commitizen-tools/commitizen
-  rev: v3.28.0
+  rev: v4.8.3
   hooks:
   - id: commitizen
 
@@ -129,18 +126,18 @@ repos:
   # PLR2004 magic value used in comparison
   # D403 First word of the first line should be properly capitalized
   # PLR0913 too namy arguments
-  rev: 'v0.5.7'
+  rev: 'v0.12.10'
   hooks:
     - id: ruff
       exclude: "tests"
       args:
-      - --target-version=py38
+      - --target-version=py39
       - --select=ALL
       - --ignore=COM812,D203,D213,ISC003,PYI019,A002,PLR2004,D403,PLR0913
       # - --fix
 
 # reads pyproject.toml for additional config
 - repo: https://github.com/RobertCraigie/pyright-python
-  rev: v1.1.375
+  rev: v1.1.404
   hooks:
     - id: pyright

{halfedge-0.6.0/src/halfedge.egg-info → halfedge-0.8.1}/PKG-INFO

@@ -1,10 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: halfedge
-Version: 0.6.0
+Version: 0.8.1
 Summary: A typical half-edge data structure with some padding
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: paragraphs
 Provides-Extra: dev
@@ -35,11 +35,11 @@ mesh.remove_edge(edge)
 
 ## Particulars
 
-The idea (for 18 years and counting) has been to create an interface that is neither too complex, too verbose, nor too magical. I've been all over the place as to where that line should be. This is my current thinking.
+The idea (for 19 years and counting) has been to create an interface that is neither too complex, too verbose, nor too magical. I've been all over the place as to where that line should be. This is my current thinking.
 
 ### Reflection
 
-If you set `edge_a.orig = vert_a`, then the `Edge.vert` setter will *automagically* set `vert_a.edge = edge_a`. This is true for any setter that might otherwise break the mesh. Sometimes, this reflection will happen when it isn't strictly necessary. Imagine you have `face_a` with three edges: `edge_a`, `edge_b` and `edge_c`. `face_a` has a pointer to `edge_a`, but it could point to any of the three edges and still be correct per the requirements of the halfedge data structure. If you directly set `edge_b.face = face_a`, everything would still be correct (`face_a.edge` would still be `edge_a` and that would still be correct), but the `Edge.edge` setter will nevertheless set `face_a.edge = edge_b`.
+If you set `edge_a.orig = vert_a`, then the `Edge.vert` setter will *automagically* set `vert_a.edge = edge_a`. This is true for any setter that might otherwise break the mesh. Sometimes, this reflection will happen when it isn't strictly necessary. Imagine you have `face_a` with three edges: `edge_a`, `edge_b` and `edge_c`. `face_a` has a pointer to `edge_a`, but it could point to any of the three edges and still be correct per the requirements of the halfedge data structure. If you directly set `edge_b.face = face_a`, everything would still be correct (`face_a.edge` would still be `edge_a` and that would still be correct), but the `Edge.edge` setter will nevertheless "reflectively" set `face_a.edge = edge_b`.
 
 ### id
 
@@ -64,50 +64,66 @@ Face(
 
 The `is_hole` `__init__` kwarg is shorthand for
 
-    class IsHole(ContagionAttribute):
-        pass
+```python
+class IsHole(ContagionAttribute):
+    pass
+
+face = Face()
+face.add_attrib(IsHole())
+```
 
-    vert = Vert()
-    vert.add_attrib(IsHole())
 
 The `face_instance.is_hole` property getter is shorthand for
 
-    vert.get_attrib(IsHole())
+```python
+vert.get_attrib(IsHole())
+```
 
 More on `Attrib` classes below and in `type_attrib.py`.
 
 ### Element Attributes
 
-By halfedge convention, each Vert instance holds a pointer to one Edge instance, each Face instance holds a pointer to one Edge instance, and each Edge instance holds four pointers (orig, pair, face, next). These describe the geometry of a mesh, but there may be other attributes you would like to assign to these instances. For example, each Face instance might have a color or each Vert instance an (x, y) coordinate. There is no objectively correct way define these attributes or to combine them when two elements are merged. If you assign position vertices to your verts, will they be xy tuples or numpy arrays? Do a red and a blue face behave like paint and combine to make a purple face? Or do they behave like DNA to make a red *or* blue face depending on which is dominant?
+By halfedge convention
 
-These cannot be stored as simple attributes (e.g., `face.color`), because it wouldn't be clear what to do when two faces were combined--by, for instance, deleting a shared edge. Somewhere, you have to define a rule for how different colored faces merge or how coordinate locations combine when merging verts. So, properties like color must be defined here as `Attrib` instances. To create an attribute, inherit from `Attrib` or one of its children defined in `type_attrib.py`. Define `merge`, `split`, and `_infer_value` methods to determine how (for instance, face color) will behave when merged or cached.
+- each Vert instance holds a pointer to one Edge instance;
+- each Face instance holds a pointer to one Edge instance; and
+- each Edge instance holds four pointers (orig, pair, face, next).
 
-You cannot assign these with `instance.attribute`. Instead assign with `vert.add_attrib(attrib_instance)`. This will add the Attrib to a `attrib` dict in Vert instance dict. Retrieve the value with `vert_instance.get_attrib(attrib_class)`. Everything will be keyed to the class name, so you will need a new ElemAttribBase descendant for each attribute type.
+These describe the geometry of a mesh, but there may be other attributes you would like to assign to these instances. For example, each Face instance might have a color. There is no objectively correct way to define a face color, nor to merge colors when two faces are merged, nor to split a color when faces are split. Do a red and a blue face behave like paint and combine to make a purple face? Or do they behave like DNA to make a red *or* blue face depending on which is dominant? This library will not guess.
 
-    class Coordinate(IncompatibleAttribute[Tuple[float, float]]):
-        pass
+For each such attribute, you will need to define `merge` and `split` methods to explicate how the attribute 1) combines when elements are merged; and 2) behaves when an element is split. Do this by creating a new descendent of `Attrib` or one of `Attrib`'s children defined in `type_attrib.py`. See the docstring in that file for more information.
 
-    vert = Vert()
-    vert.add_attrib(Coordinate((1, 2)))
-    assert vert.get_attrib(Coordinate).value == (1, 2)
+```python
+# `Vector2Attrib` is a child of `Attrib` defined in `type_attrib.py`.
+# It defines suitable (YMMV) `merge` (average) and `split` (fail) methods for
+# an (x, y) coordinate.
+class Coordinate(Vector2Attrib):
+    pass
+
+vert = Vert()
+vert.add_attrib(Coordinate((1, 2)))
+assert vert.get_attrib(Coordinate).value == (1, 2)
+```
 
-These element attributes can also be passed at `__init__`
+You cannot assign or access these attributes with `vert.attribute`. Instead assign with `vert.add_attrib(attrib_instance)`. Retrieve the value with `vert.get_attrib(attrib_class)`. Everything will be keyed to the class name, so you will need a new ElemAttribBase descendant for each attribute type.
 
-    vert = Vert(Coordinate(1, 2))
-    assert vert.get_attrib(Coordinate).value == (1, 2)
+These element attributes can also be passed at `__init__`
 
-The Attrib classes and merge and split methods that will be called when two elements are merged (e.g., merge two faces when removing the edge between them) or split (e.g., split an edge into two edges).
+```python
+vert = Vert(Coordinate(1, 2))
+assert vert.get_attrib(Coordinate).value == (1, 2)
+```
 
 ### You Should Know
 
 A canonical half-edge data structure stores:
 
-* a set of verts (redundant)
-* for each vert, a pointer to an edge
-* a set of edges
-* for each edge, pointers to vert, pair, face, next
-* a set of faces (redundant)
-* for each face, a pointer to an edge
+- a set of verts (redundant)
+- for each vert, a pointer to an edge
+- a set of edges
+- for each edge, pointers to vert, pair, face, next
+- a set of faces (redundant)
+- for each face, a pointer to an edge
 
 This implementation only stores a set of edges. Sets of verts and faces are generated by iterating through references in edge instances. This makes for slower code, but does not violate DRY and makes for dramatically cleaner code.
 

{halfedge-0.6.0 → halfedge-0.8.1}/README.md

@@ -18,11 +18,11 @@ mesh.remove_edge(edge)
 
 ## Particulars
 
-The idea (for 18 years and counting) has been to create an interface that is neither too complex, too verbose, nor too magical. I've been all over the place as to where that line should be. This is my current thinking.
+The idea (for 19 years and counting) has been to create an interface that is neither too complex, too verbose, nor too magical. I've been all over the place as to where that line should be. This is my current thinking.
 
 ### Reflection
 
-If you set `edge_a.orig = vert_a`, then the `Edge.vert` setter will *automagically* set `vert_a.edge = edge_a`. This is true for any setter that might otherwise break the mesh. Sometimes, this reflection will happen when it isn't strictly necessary. Imagine you have `face_a` with three edges: `edge_a`, `edge_b` and `edge_c`. `face_a` has a pointer to `edge_a`, but it could point to any of the three edges and still be correct per the requirements of the halfedge data structure. If you directly set `edge_b.face = face_a`, everything would still be correct (`face_a.edge` would still be `edge_a` and that would still be correct), but the `Edge.edge` setter will nevertheless set `face_a.edge = edge_b`.
+If you set `edge_a.orig = vert_a`, then the `Edge.vert` setter will *automagically* set `vert_a.edge = edge_a`. This is true for any setter that might otherwise break the mesh. Sometimes, this reflection will happen when it isn't strictly necessary. Imagine you have `face_a` with three edges: `edge_a`, `edge_b` and `edge_c`. `face_a` has a pointer to `edge_a`, but it could point to any of the three edges and still be correct per the requirements of the halfedge data structure. If you directly set `edge_b.face = face_a`, everything would still be correct (`face_a.edge` would still be `edge_a` and that would still be correct), but the `Edge.edge` setter will nevertheless "reflectively" set `face_a.edge = edge_b`.
 
 ### id
 
@@ -47,50 +47,66 @@ Face(
 
 The `is_hole` `__init__` kwarg is shorthand for
 
-    class IsHole(ContagionAttribute):
-        pass
+```python
+class IsHole(ContagionAttribute):
+    pass
+
+face = Face()
+face.add_attrib(IsHole())
+```
 
-    vert = Vert()
-    vert.add_attrib(IsHole())
 
 The `face_instance.is_hole` property getter is shorthand for
 
-    vert.get_attrib(IsHole())
+```python
+vert.get_attrib(IsHole())
+```
 
 More on `Attrib` classes below and in `type_attrib.py`.
 
 ### Element Attributes
 
-By halfedge convention, each Vert instance holds a pointer to one Edge instance, each Face instance holds a pointer to one Edge instance, and each Edge instance holds four pointers (orig, pair, face, next). These describe the geometry of a mesh, but there may be other attributes you would like to assign to these instances. For example, each Face instance might have a color or each Vert instance an (x, y) coordinate. There is no objectively correct way define these attributes or to combine them when two elements are merged. If you assign position vertices to your verts, will they be xy tuples or numpy arrays? Do a red and a blue face behave like paint and combine to make a purple face? Or do they behave like DNA to make a red *or* blue face depending on which is dominant?
+By halfedge convention
 
-These cannot be stored as simple attributes (e.g., `face.color`), because it wouldn't be clear what to do when two faces were combined--by, for instance, deleting a shared edge. Somewhere, you have to define a rule for how different colored faces merge or how coordinate locations combine when merging verts. So, properties like color must be defined here as `Attrib` instances. To create an attribute, inherit from `Attrib` or one of its children defined in `type_attrib.py`. Define `merge`, `split`, and `_infer_value` methods to determine how (for instance, face color) will behave when merged or cached.
+- each Vert instance holds a pointer to one Edge instance;
+- each Face instance holds a pointer to one Edge instance; and
+- each Edge instance holds four pointers (orig, pair, face, next).
 
-You cannot assign these with `instance.attribute`. Instead assign with `vert.add_attrib(attrib_instance)`. This will add the Attrib to a `attrib` dict in Vert instance dict. Retrieve the value with `vert_instance.get_attrib(attrib_class)`. Everything will be keyed to the class name, so you will need a new ElemAttribBase descendant for each attribute type.
+These describe the geometry of a mesh, but there may be other attributes you would like to assign to these instances. For example, each Face instance might have a color. There is no objectively correct way to define a face color, nor to merge colors when two faces are merged, nor to split a color when faces are split. Do a red and a blue face behave like paint and combine to make a purple face? Or do they behave like DNA to make a red *or* blue face depending on which is dominant? This library will not guess.
 
-    class Coordinate(IncompatibleAttribute[Tuple[float, float]]):
-        pass
+For each such attribute, you will need to define `merge` and `split` methods to explicate how the attribute 1) combines when elements are merged; and 2) behaves when an element is split. Do this by creating a new descendent of `Attrib` or one of `Attrib`'s children defined in `type_attrib.py`. See the docstring in that file for more information.
 
-    vert = Vert()
-    vert.add_attrib(Coordinate((1, 2)))
-    assert vert.get_attrib(Coordinate).value == (1, 2)
+```python
+# `Vector2Attrib` is a child of `Attrib` defined in `type_attrib.py`.
+# It defines suitable (YMMV) `merge` (average) and `split` (fail) methods for
+# an (x, y) coordinate.
+class Coordinate(Vector2Attrib):
+    pass
+
+vert = Vert()
+vert.add_attrib(Coordinate((1, 2)))
+assert vert.get_attrib(Coordinate).value == (1, 2)
+```
 
-These element attributes can also be passed at `__init__`
+You cannot assign or access these attributes with `vert.attribute`. Instead assign with `vert.add_attrib(attrib_instance)`. Retrieve the value with `vert.get_attrib(attrib_class)`. Everything will be keyed to the class name, so you will need a new ElemAttribBase descendant for each attribute type.
 
-    vert = Vert(Coordinate(1, 2))
-    assert vert.get_attrib(Coordinate).value == (1, 2)
+These element attributes can also be passed at `__init__`
 
-The Attrib classes and merge and split methods that will be called when two elements are merged (e.g., merge two faces when removing the edge between them) or split (e.g., split an edge into two edges).
+```python
+vert = Vert(Coordinate(1, 2))
+assert vert.get_attrib(Coordinate).value == (1, 2)
+```
 
 ### You Should Know
 
 A canonical half-edge data structure stores:
 
-* a set of verts (redundant)
-* for each vert, a pointer to an edge
-* a set of edges
-* for each edge, pointers to vert, pair, face, next
-* a set of faces (redundant)
-* for each face, a pointer to an edge
+- a set of verts (redundant)
+- for each vert, a pointer to an edge
+- a set of edges
+- for each edge, pointers to vert, pair, face, next
+- a set of faces (redundant)
+- for each face, a pointer to an edge
 
 This implementation only stores a set of edges. Sets of verts and faces are generated by iterating through references in edge instances. This makes for slower code, but does not violate DRY and makes for dramatically cleaner code.
 

{halfedge-0.6.0 → halfedge-0.8.1}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "halfedge"
-version = "0.6.0"
+version = "0.8.1"
 description = "A typical half-edge data structure with some padding"
 authors = [{ name = "Shay Hill", email = "shay_public@hotmail.com" }]
 license = {text = "MIT"}
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 dependencies = ["paragraphs"]
 
 [project.optional-dependencies]
@@ -25,7 +25,7 @@ build-backend = "setuptools.build_meta"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.6.0"
+version = "0.8.1"
 tag_format = "$version"
 major-version-zero = true
 version_files = ["pyproject.toml:^version"]
@@ -43,7 +43,7 @@ log_cli = 1
 [tool.tox]
 legacy_tox_ini = """
 [tox]
-envlist = py{38,39,310,311,312}
+envlist = py{39,310,311,312,313}
 
 [testenv]
 deps = pytest
@@ -55,7 +55,7 @@ commands = pytest
 include = ["src"]
 exclude = ["**/__pycache__.py"]
 
-pythonVersion = "3.8"
+pythonVersion = "3.9"
 pythonPlatform = "Any"
 
 typeCheckingMode = "strict"

{halfedge-0.6.0 → halfedge-0.8.1}/src/halfedge/half_edge_constructors.py

@@ -23,13 +23,15 @@ then passing that raw data to mesh_from_vr would create a mesh with 6 faces and
 from __future__ import annotations
 
 from contextlib import suppress
-from typing import TYPE_CHECKING, Any, Iterable, Sequence, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from paragraphs import par
 
 from halfedge.half_edge_elements import Edge, Face, ManifoldMeshError, Vert
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
     from halfedge.type_attrib import Attrib, StaticAttrib
 
 

{halfedge-0.6.0 → halfedge-0.8.1}/src/halfedge/half_edge_elements.py

@@ -84,11 +84,31 @@ class MeshElementBase:
         """
         self.sn = next(self._sn_generator)
         self.attrib: dict[str, Attrib[Any]] = {}
-        self.mesh = mesh
+        self._mesh = mesh
 
         for attribute in attributes:
             self.set_attrib(attribute)
 
+    @property
+    def mesh(self) -> BlindHalfEdges:
+        """Return the mesh instance.
+
+        :return: the mesh instance
+        :raise AttributeError: if mesh not set for self
+        """
+        if self._mesh is not None:
+            return self._mesh
+        msg = "mesh not set for self"
+        raise AttributeError(msg)
+
+    @mesh.setter
+    def mesh(self, mesh: BlindHalfEdges) -> None:
+        """Set the mesh instance.
+
+        :param mesh: the mesh instance
+        """
+        self._mesh = mesh
+
     def set_attrib(self, attrib: Attrib[Any]) -> None:
         """Set an attribute.
 

{halfedge-0.6.0 → halfedge-0.8.1}/src/halfedge/half_edge_object.py

@@ -79,6 +79,13 @@ class HalfEdges(StaticHalfEdges):
         Able to infer from:
             * both verts on same face: that face
             * empty mesh: a new Hole
+
+        This is only called when inserting an edge into an existing face (or empty
+        mesh), so the orig and dest should always be connected to only one face (or
+        nothing, which is handled in this method).
+
+        Once the face is split, the two verts will form an edge that connects to two
+        faces.
         """
         if not self.edges:
             return self.new_hole()

{halfedge-0.6.0 → halfedge-0.8.1}/src/halfedge/type_attrib.py

@@ -61,7 +61,7 @@ When assigned to a Vert instance, these will be stored in the Vert instance's
 from __future__ import annotations
 
 from contextlib import suppress
-from typing import TYPE_CHECKING, Any, Generic, Literal, Tuple, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar
 
 from paragraphs import par
 
@@ -79,7 +79,7 @@ class StaticAttrib(Generic[_T]):
     merged or split.
     """
 
-    __slots__ = ("_value", "_mesh")
+    __slots__ = ("_mesh", "_value")
 
     def __new__(
         cls: type[_TStaticAttrib],
@@ -193,7 +193,7 @@ class Attrib(Generic[_T]):
     every case.
     """
 
-    __slots__ = ("_value", "_element")
+    __slots__ = ("_element", "_value")
 
     def __new__(
         cls: type[_TAttrib],
@@ -469,7 +469,7 @@ class NumericAttrib(Attrib[_T]):
         return type(have_values[0])(sum(values) / len(values))
 
 
-class Vector2Attrib(Attrib[Tuple[float, float]]):
+class Vector2Attrib(Attrib[tuple[float, float]]):
     """Average merge_from values as xy tuples."""
 
     def __new__(
@@ -501,7 +501,7 @@ class Vector2Attrib(Attrib[Tuple[float, float]]):
         return type(have_values[0])((sum_x / num, sum_y / num))
 
 
-class Vector3Attrib(Attrib[Tuple[float, float, float]]):
+class Vector3Attrib(Attrib[tuple[float, float, float]]):
     """Average merge_from values as xyz tuples."""
 
     def __new__(

{halfedge-0.6.0 → halfedge-0.8.1}/src/halfedge/validations.py

@@ -10,11 +10,13 @@ created: 181127
 from __future__ import annotations
 
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Callable, Iterator, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
 
 from halfedge.half_edge_elements import Edge, Face, ManifoldMeshError
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from halfedge.half_edge_querries import StaticHalfEdges
 
 _T = TypeVar("_T")

{halfedge-0.6.0 → halfedge-0.8.1/src/halfedge.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: halfedge
-Version: 0.6.0
+Version: 0.8.1
 Summary: A typical half-edge data structure with some padding
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: paragraphs
 Provides-Extra: dev
@@ -35,11 +35,11 @@ mesh.remove_edge(edge)
 
 ## Particulars
 
-The idea (for 18 years and counting) has been to create an interface that is neither too complex, too verbose, nor too magical. I've been all over the place as to where that line should be. This is my current thinking.
+The idea (for 19 years and counting) has been to create an interface that is neither too complex, too verbose, nor too magical. I've been all over the place as to where that line should be. This is my current thinking.
 
 ### Reflection
 
-If you set `edge_a.orig = vert_a`, then the `Edge.vert` setter will *automagically* set `vert_a.edge = edge_a`. This is true for any setter that might otherwise break the mesh. Sometimes, this reflection will happen when it isn't strictly necessary. Imagine you have `face_a` with three edges: `edge_a`, `edge_b` and `edge_c`. `face_a` has a pointer to `edge_a`, but it could point to any of the three edges and still be correct per the requirements of the halfedge data structure. If you directly set `edge_b.face = face_a`, everything would still be correct (`face_a.edge` would still be `edge_a` and that would still be correct), but the `Edge.edge` setter will nevertheless set `face_a.edge = edge_b`.
+If you set `edge_a.orig = vert_a`, then the `Edge.vert` setter will *automagically* set `vert_a.edge = edge_a`. This is true for any setter that might otherwise break the mesh. Sometimes, this reflection will happen when it isn't strictly necessary. Imagine you have `face_a` with three edges: `edge_a`, `edge_b` and `edge_c`. `face_a` has a pointer to `edge_a`, but it could point to any of the three edges and still be correct per the requirements of the halfedge data structure. If you directly set `edge_b.face = face_a`, everything would still be correct (`face_a.edge` would still be `edge_a` and that would still be correct), but the `Edge.edge` setter will nevertheless "reflectively" set `face_a.edge = edge_b`.
 
 ### id
 
@@ -64,50 +64,66 @@ Face(
 
 The `is_hole` `__init__` kwarg is shorthand for
 
-    class IsHole(ContagionAttribute):
-        pass
+```python
+class IsHole(ContagionAttribute):
+    pass
+
+face = Face()
+face.add_attrib(IsHole())
+```
 
-    vert = Vert()
-    vert.add_attrib(IsHole())
 
 The `face_instance.is_hole` property getter is shorthand for
 
-    vert.get_attrib(IsHole())
+```python
+vert.get_attrib(IsHole())
+```
 
 More on `Attrib` classes below and in `type_attrib.py`.
 
 ### Element Attributes
 
-By halfedge convention, each Vert instance holds a pointer to one Edge instance, each Face instance holds a pointer to one Edge instance, and each Edge instance holds four pointers (orig, pair, face, next). These describe the geometry of a mesh, but there may be other attributes you would like to assign to these instances. For example, each Face instance might have a color or each Vert instance an (x, y) coordinate. There is no objectively correct way define these attributes or to combine them when two elements are merged. If you assign position vertices to your verts, will they be xy tuples or numpy arrays? Do a red and a blue face behave like paint and combine to make a purple face? Or do they behave like DNA to make a red *or* blue face depending on which is dominant?
+By halfedge convention
 
-These cannot be stored as simple attributes (e.g., `face.color`), because it wouldn't be clear what to do when two faces were combined--by, for instance, deleting a shared edge. Somewhere, you have to define a rule for how different colored faces merge or how coordinate locations combine when merging verts. So, properties like color must be defined here as `Attrib` instances. To create an attribute, inherit from `Attrib` or one of its children defined in `type_attrib.py`. Define `merge`, `split`, and `_infer_value` methods to determine how (for instance, face color) will behave when merged or cached.
+- each Vert instance holds a pointer to one Edge instance;
+- each Face instance holds a pointer to one Edge instance; and
+- each Edge instance holds four pointers (orig, pair, face, next).
 
-You cannot assign these with `instance.attribute`. Instead assign with `vert.add_attrib(attrib_instance)`. This will add the Attrib to a `attrib` dict in Vert instance dict. Retrieve the value with `vert_instance.get_attrib(attrib_class)`. Everything will be keyed to the class name, so you will need a new ElemAttribBase descendant for each attribute type.
+These describe the geometry of a mesh, but there may be other attributes you would like to assign to these instances. For example, each Face instance might have a color. There is no objectively correct way to define a face color, nor to merge colors when two faces are merged, nor to split a color when faces are split. Do a red and a blue face behave like paint and combine to make a purple face? Or do they behave like DNA to make a red *or* blue face depending on which is dominant? This library will not guess.
 
-    class Coordinate(IncompatibleAttribute[Tuple[float, float]]):
-        pass
+For each such attribute, you will need to define `merge` and `split` methods to explicate how the attribute 1) combines when elements are merged; and 2) behaves when an element is split. Do this by creating a new descendent of `Attrib` or one of `Attrib`'s children defined in `type_attrib.py`. See the docstring in that file for more information.
 
-    vert = Vert()
-    vert.add_attrib(Coordinate((1, 2)))
-    assert vert.get_attrib(Coordinate).value == (1, 2)
+```python
+# `Vector2Attrib` is a child of `Attrib` defined in `type_attrib.py`.
+# It defines suitable (YMMV) `merge` (average) and `split` (fail) methods for
+# an (x, y) coordinate.
+class Coordinate(Vector2Attrib):
+    pass
+
+vert = Vert()
+vert.add_attrib(Coordinate((1, 2)))
+assert vert.get_attrib(Coordinate).value == (1, 2)
+```
 
-These element attributes can also be passed at `__init__`
+You cannot assign or access these attributes with `vert.attribute`. Instead assign with `vert.add_attrib(attrib_instance)`. Retrieve the value with `vert.get_attrib(attrib_class)`. Everything will be keyed to the class name, so you will need a new ElemAttribBase descendant for each attribute type.
 
-    vert = Vert(Coordinate(1, 2))
-    assert vert.get_attrib(Coordinate).value == (1, 2)
+These element attributes can also be passed at `__init__`
 
-The Attrib classes and merge and split methods that will be called when two elements are merged (e.g., merge two faces when removing the edge between them) or split (e.g., split an edge into two edges).
+```python
+vert = Vert(Coordinate(1, 2))
+assert vert.get_attrib(Coordinate).value == (1, 2)
+```
 
 ### You Should Know
 
 A canonical half-edge data structure stores:
 
-* a set of verts (redundant)
-* for each vert, a pointer to an edge
-* a set of edges
-* for each edge, pointers to vert, pair, face, next
-* a set of faces (redundant)
-* for each face, a pointer to an edge
+- a set of verts (redundant)
+- for each vert, a pointer to an edge
+- a set of edges
+- for each edge, pointers to vert, pair, face, next
+- a set of faces (redundant)
+- for each face, a pointer to an edge
 
 This implementation only stores a set of edges. Sets of verts and faces are generated by iterating through references in edge instances. This makes for slower code, but does not violate DRY and makes for dramatically cleaner code.
 

{halfedge-0.6.0 → halfedge-0.8.1}/tests/conftest.py

@@ -1,10 +1,11 @@
-""" simple HalfEdges instances for testing
+"""simple HalfEdges instances for testing
 
 created: 181121 13:14:06
 """
 
+from collections.abc import Iterable, Sequence
 from itertools import product
-from typing import Any, Dict, Iterable, List, Sequence, Set, Tuple, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 import pytest
 
@@ -14,12 +15,12 @@ from halfedge.half_edge_object import HalfEdges
 from halfedge.type_attrib import IncompatibleAttrib
 
 
-class Coordinate(IncompatibleAttrib[Tuple[int, ...]]):
+class Coordinate(IncompatibleAttrib[tuple[int, ...]]):
     pass
 
 
 @pytest.fixture
-def he_triangle() -> Dict[str, List[Any]]:
+def he_triangle() -> dict[str, list[Any]]:
     """A simple triangle (inside and outside faces) for Mesh Element test"""
     mesh = HalfEdges()
     verts = [half_edge_elements.Vert(Coordinate(x)) for x in ((-1, 0), (1, 0), (0, 1))]
@@ -47,7 +48,7 @@ def he_triangle() -> Dict[str, List[Any]]:
 
 
 @pytest.fixture(scope="module")
-def meshes_vlvi() -> Dict[str, Any]:
+def meshes_vlvi() -> dict[str, Any]:
     """A cube and a 3 x 3 grid"""
     # fmt: off
     cube_vl = [(-1, -1, -1), (1, -1, -1), (1, 1, -1), (-1, 1, -1),
@@ -73,13 +74,13 @@ def meshes_vlvi() -> Dict[str, Any]:
 
 
 @pytest.fixture(scope="function")
-def he_cube(meshes_vlvi: Dict[str, Any]) -> HalfEdges:
+def he_cube(meshes_vlvi: dict[str, Any]) -> HalfEdges:
     vl = [Vert(Coordinate(x)) for x in meshes_vlvi["cube_vl"]]
     return HalfEdges.from_vlfi(vl, meshes_vlvi["cube_vi"])
 
 
 @pytest.fixture(scope="function")
-def he_grid(meshes_vlvi: Dict[str, Any]) -> HalfEdges:
+def he_grid(meshes_vlvi: dict[str, Any]) -> HalfEdges:
     vl = [Vert(Coordinate(x)) for x in meshes_vlvi["grid_vl"]]
     return HalfEdges.from_vlfi(vl, meshes_vlvi["grid_vi"])
 
@@ -97,7 +98,7 @@ def he_mesh(
 @pytest.fixture(scope="function", params=range(9))
 def grid_faces(
     request: pytest.FixtureRequest, he_grid: HalfEdges
-) -> Tuple[HalfEdges, Face]:
+) -> tuple[HalfEdges, Face]:
     """A cube and a 3 x 3 grid as HalfEdges instances"""
     idx = cast(int, request.param)
     return he_grid, sorted(he_grid.faces)[idx]
@@ -106,7 +107,7 @@ def grid_faces(
 @pytest.fixture(scope="function", params=range(6))
 def cube_faces(
     request: pytest.FixtureRequest, he_cube: HalfEdges
-) -> Tuple[HalfEdges, Face]:
+) -> tuple[HalfEdges, Face]:
     """A cube and a 3 x 3 grid as HalfEdges instances"""
     idx = cast(int, request.param)
     return he_cube, sorted(he_cube.faces)[idx]
@@ -115,9 +116,9 @@ def cube_faces(
 @pytest.fixture(params=range(2))
 def mesh_faces(
     request: pytest.FixtureRequest,
-    grid_faces: Tuple[HalfEdges, Face],
-    cube_faces: Tuple[HalfEdges, Face],
-) -> Tuple[HalfEdges, Face]:
+    grid_faces: tuple[HalfEdges, Face],
+    cube_faces: tuple[HalfEdges, Face],
+) -> tuple[HalfEdges, Face]:
     """A cube and a 3 x 3 grid as HalfEdges instances"""
     if request.param == 0:
         return grid_faces
@@ -127,7 +128,7 @@ def mesh_faces(
 @pytest.fixture(scope="function", params=range(48))
 def grid_edges(
     request: pytest.FixtureRequest, he_grid: HalfEdges
-) -> Tuple[HalfEdges, Edge]:
+) -> tuple[HalfEdges, Edge]:
     """A cube and a 3 x 3 grid as HalfEdges instances"""
     idx = cast(int, request.param)
     return he_grid, sorted(he_grid.edges)[idx]
@@ -136,7 +137,7 @@ def grid_edges(
 @pytest.fixture(scope="function", params=range(24))
 def cube_edges(
     request: pytest.FixtureRequest, he_cube: HalfEdges
-) -> Tuple[HalfEdges, Edge]:
+) -> tuple[HalfEdges, Edge]:
     """A cube and a 3 x 3 grid as HalfEdges instances"""
     idx = cast(int, request.param)
     return he_cube, sorted(he_cube.edges)[idx]
@@ -145,9 +146,9 @@ def cube_edges(
 @pytest.fixture(params=range(2))
 def mesh_edges(
     request: pytest.FixtureRequest,
-    grid_edges: Tuple[HalfEdges, Edge],
-    cube_edges: Tuple[HalfEdges, Edge],
-) -> Tuple[HalfEdges, Edge]:
+    grid_edges: tuple[HalfEdges, Edge],
+    cube_edges: tuple[HalfEdges, Edge],
+) -> tuple[HalfEdges, Edge]:
     """A cube and a 3 x 3 grid as HalfEdges instances"""
     if request.param == 0:
         return grid_edges
@@ -191,7 +192,7 @@ def compare_circular_2(
 _TAxis = TypeVar("_TAxis")
 
 
-def get_canonical_index_tuple(vals: Iterable[int]) -> Tuple[int, ...]:
+def get_canonical_index_tuple(vals: Iterable[int]) -> tuple[int, ...]:
     """Return a tuple with the lowest value first.
 
     This is useful for comparing circular sequences. It will only be canonical when
@@ -204,13 +205,13 @@ def get_canonical_index_tuple(vals: Iterable[int]) -> Tuple[int, ...]:
 
 
 def get_canonical_vr(
-    vr: Set[Tuple[Tuple[_TAxis, ...], ...]]
-) -> Set[Tuple[Tuple[_TAxis, ...], ...]]:
+    vr: set[tuple[tuple[_TAxis, ...], ...]],
+) -> set[tuple[tuple[_TAxis, ...], ...]]:
     """Rotate each tuple in a set to start with its min item.
 
     See docstring for canonical_mesh.
     """
-    vr_aligned: Set[Tuple[Tuple[_TAxis, ...], ...]] = set()
+    vr_aligned: set[tuple[tuple[_TAxis, ...], ...]] = set()
     for face_verts in vr:
         min_item_idx = face_verts.index(min(face_verts))
         vr_aligned.add(face_verts[min_item_idx:] + face_verts[:min_item_idx])
@@ -218,8 +219,8 @@ def get_canonical_vr(
 
 
 def get_canonical_mesh(
-    vl: Sequence[Tuple[_TAxis, ...]], vi: Iterable[Tuple[int, ...]]
-) -> Set[Tuple[Tuple[_TAxis, ...], ...]]:
+    vl: Sequence[tuple[_TAxis, ...]], vi: Iterable[tuple[int, ...]]
+) -> set[tuple[tuple[_TAxis, ...], ...]]:
     """Return a canonical mesh representation.
 
     Methods in this library represent meshes as
@@ -264,7 +265,7 @@ def get_canonical_mesh(
     This function produces an unambiguous representation so that such methods can be
     tested.
     """
-    vr: Set[Tuple[Tuple[_TAxis, ...], ...]] = set()
+    vr: set[tuple[tuple[_TAxis, ...], ...]] = set()
     for face_indices in vi:
         vr.add(tuple(vl[x] for x in face_indices))
     return get_canonical_vr(vr)

{halfedge-0.6.0 → halfedge-0.8.1}/tests/test_classes.py

@@ -8,7 +8,7 @@ created: 170204 14:22:23
 from __future__ import annotations
 
 import random
-from typing import Any, Tuple, TypeVar
+from typing import Any, TypeVar
 
 import pytest
 
@@ -333,11 +333,9 @@ def test_edge_lap_fails(he_triangle: dict[str, Any]) -> None:
     assert "infinite" in err.value.args[0]
 
 
-class Coordinate(IncompatibleAttrib[Tuple[int, int, int]]):
+class Coordinate(IncompatibleAttrib[tuple[int, int, int]]):
     """A subclass of IncompatibleAttrib."""
 
-    pass
-
 
 class TestInitVert:
     def setup_method(self) -> None:

{halfedge-0.6.0 → halfedge-0.8.1}/tests/test_constructors.py

@@ -5,7 +5,7 @@ created: 170204 14:22:23
 
 # pyright: reportPrivateUsage=false
 
-from typing import Any, Dict, Tuple
+from typing import Any
 
 import pytest
 
@@ -21,7 +21,7 @@ from halfedge.type_attrib import IncompatibleAttrib, NumericAttrib
 from tests.conftest import get_canonical_mesh
 
 
-class Coordinate(IncompatibleAttrib[Tuple[float, ...]]):
+class Coordinate(IncompatibleAttrib[tuple[float, ...]]):
     pass
 
 
@@ -29,7 +29,7 @@ class TestFromVlfi:
     def test_raise_on_non_inferable_holes(self) -> None:
         """Raises if holes cannot be inferred."""
         vl = [Vert() for _ in range(7)]
-        fi: list[Tuple[int, ...]] = [(0, 2, 3, 1), (3, 5, 6, 4)]
+        fi: list[tuple[int, ...]] = [(0, 2, 3, 1), (3, 5, 6, 4)]
         with pytest.raises(ManifoldMeshError) as err:
             _ = HalfEdges.from_vlfi(vl, fi)
         assert "Ambiguous 'next'" in err.value.args[0]
@@ -54,7 +54,7 @@ class TestMeshElementBase:
         assert flag1_defined.get_attrib(Flag2).value == 4
 
 
-def test_edge_lap_succeeds(he_triangle: Dict[str, Any]) -> None:
+def test_edge_lap_succeeds(he_triangle: dict[str, Any]) -> None:
     """Returns to self when (func(func(func(....func(self))))) == self."""
     for edge in he_triangle["edges"]:
         assert _function_lap(lambda x: x.next, edge) == [
@@ -64,7 +64,7 @@ def test_edge_lap_succeeds(he_triangle: Dict[str, Any]) -> None:
         ]
 
 
-def test_edge_lap_fails(he_triangle: Dict[str, Any]) -> None:
+def test_edge_lap_fails(he_triangle: dict[str, Any]) -> None:
     """Fails when self intersects."""
     edges = he_triangle["edges"]
     with pytest.raises(ManifoldMeshError) as err:
@@ -75,55 +75,55 @@ def test_edge_lap_fails(he_triangle: Dict[str, Any]) -> None:
 class TestElementSubclasses:
     """Test all three _MeshElementBase children."""
 
-    def test_edge_face_edges(self, he_triangle: Dict[str, Any]) -> None:
+    def test_edge_face_edges(self, he_triangle: dict[str, Any]) -> None:
         """Edge next around face."""
         for edge in he_triangle["edges"]:
             assert tuple(edge.face_edges) == (edge, edge.next, edge.next.next)
 
-    def test_face_edges(self, he_triangle: Dict[str, Any]) -> None:
+    def test_face_edges(self, he_triangle: dict[str, Any]) -> None:
         """Finds all edges, starting at face.edge."""
         for face in he_triangle["faces"]:
             assert tuple(face.edges) == tuple(face.edge.face_edges)
 
-    def test_edge_face_verts(self, he_triangle: Dict[str, Any]) -> None:
+    def test_edge_face_verts(self, he_triangle: dict[str, Any]) -> None:
         """Is equivalent to edge.pair.next around orig."""
         for edge in he_triangle["edges"]:
             assert tuple(edge.vert_edges) == (edge, edge.pair.next)
 
-    def test_vert_edges(self, he_triangle: Dict[str, Any]) -> None:
+    def test_vert_edges(self, he_triangle: dict[str, Any]) -> None:
         """Is equivalent to vert_edges for vert.edge."""
         for vert in he_triangle["verts"]:
             assert tuple(vert.edges) == tuple(vert.edge.vert_edges)
 
-    def test_vert_verts(self, he_triangle: Dict[str, Any]) -> None:
+    def test_vert_verts(self, he_triangle: dict[str, Any]) -> None:
         """Is equivalent to vert_edge.dest for vert.edge."""
         for vert in he_triangle["verts"]:
             assert vert.neighbors == [x.dest for x in vert.edge.vert_edges]
 
-    def test_vert_valence(self, he_triangle: Dict[str, Any]) -> None:
+    def test_vert_valence(self, he_triangle: dict[str, Any]) -> None:
         """Valence is two for every corner in a triangle."""
         for vert in he_triangle["verts"]:
             assert vert.valence == 2
 
-    def test_prev_by_face_edges(self, he_triangle: Dict[str, Any]) -> None:
+    def test_prev_by_face_edges(self, he_triangle: dict[str, Any]) -> None:
         """Previous edge will 'next' to self."""
         for edge in he_triangle["edges"]:
             assert edge.prev.next == edge
 
     @staticmethod
-    def test_dest_is_next_orig(he_triangle: Dict[str, Any]) -> None:
+    def test_dest_is_next_orig(he_triangle: dict[str, Any]) -> None:
         """Finds orig of next or pair edge."""
         for edge in he_triangle["edges"]:
             assert edge.dest is edge.next.orig
 
     @staticmethod
-    def test_face_verts(he_triangle: Dict[str, Any]) -> None:
+    def test_face_verts(he_triangle: dict[str, Any]) -> None:
         """Returns orig for every edge in face_verts."""
         for face in he_triangle["faces"]:
             assert tuple(face.verts) == tuple(face.edge.face_verts)
 
 
-def test_half_edges_init(he_triangle: Dict[str, Any]) -> None:
+def test_half_edges_init(he_triangle: dict[str, Any]) -> None:
     """Verts, edges, faces, and holes match hand-calculated coordinates."""
     verts = set(he_triangle["verts"])
     edges = set(he_triangle["edges"])
@@ -142,7 +142,7 @@ class TestHalfEdges:
     """Keep the linter happy."""
 
     def test_vi(
-        self, meshes_vlvi: Dict[str, Any], he_grid: HalfEdges, he_cube: HalfEdges
+        self, meshes_vlvi: dict[str, Any], he_grid: HalfEdges, he_cube: HalfEdges
     ) -> None:
         """Convert unaltered mesh faces back to input vi."""
         for mesh, key in ((he_grid, "grid"), (he_cube, "cube")):
@@ -153,7 +153,7 @@ class TestHalfEdges:
             )
             assert expect == result
 
-    def test_hi(self, meshes_vlvi: Dict[str, Any], he_grid: HalfEdges) -> None:
+    def test_hi(self, meshes_vlvi: dict[str, Any], he_grid: HalfEdges) -> None:
         """Convert unaltered mesh holes back to input holes."""
         input_vl, input_hi = meshes_vlvi["grid_vl"], meshes_vlvi["grid_hi"]
         expect = get_canonical_mesh(input_vl, input_hi)

{halfedge-0.6.0 → halfedge-0.8.1}/tests/test_elements.py

@@ -8,8 +8,6 @@ tested elsewhere.
 :created: 2024-08-09
 """
 
-from typing import Tuple
-
 import pytest
 
 from halfedge.half_edge_elements import Face, Vert
@@ -24,7 +22,7 @@ class TestVert:
     def test_holes(self) -> None:
         """Test that holes are correctly identified."""
         vl = [Vert() for _ in range(3)]
-        fi: list[Tuple[int, ...]] = [(0, 1, 2)]
+        fi: list[tuple[int, ...]] = [(0, 1, 2)]
         mesh = HalfEdges.from_vlfi(vl, fi)
         assert len(mesh.holes) == 1
 
@@ -53,7 +51,7 @@ class TestEdge:
     def test_vert_faces(self, edge_index: int) -> None:
         """Test that vert_faces returns the correct faces."""
         vl = [Vert() for _ in range(3)]
-        fi: list[Tuple[int, ...]] = [(0, 1, 2)]
+        fi: list[tuple[int, ...]] = [(0, 1, 2)]
         mesh = HalfEdges.from_vlfi(vl, fi)
         assert len(mesh.faces) == 1
         (face,) = mesh.faces
@@ -64,7 +62,7 @@ class TestEdge:
     def test_vert_holes(self, edge_index: int) -> None:
         """Test that vert_holes returns the correct holes."""
         vl = [Vert() for _ in range(3)]
-        fi: list[Tuple[int, ...]] = [(0, 1, 2)]
+        fi: list[tuple[int, ...]] = [(0, 1, 2)]
         mesh = HalfEdges.from_vlfi(vl, fi)
         assert len(mesh.holes) == 1
         (hole,) = mesh.holes

{halfedge-0.6.0 → halfedge-0.8.1}/tests/test_operations.py

@@ -1,4 +1,4 @@
-""" test halfedge.operations
+"""test halfedge.operations
 
 created: 181121 13:38:46
 
@@ -10,7 +10,7 @@ import random
 from contextlib import suppress
 from itertools import chain, combinations, permutations
 from operator import attrgetter
-from typing import Any, Tuple
+from typing import Any
 
 import pytest
 
@@ -25,7 +25,7 @@ class NamedAttribute(IncompatibleAttrib[str]):
     """For color, flags. etc. to ensure attributes are passed"""
 
 
-class Coordinate(IncompatibleAttrib[Tuple[float, ...]]):
+class Coordinate(IncompatibleAttrib[tuple[float, ...]]):
     """Hold coordinates when creating a mesh from a list of vertices"""
 
 

{halfedge-0.6.0 → halfedge-0.8.1}/tests/test_validations.py

@@ -3,8 +3,6 @@
 created: 170204 14:22:23
 """
 
-from typing import Tuple
-
 import pytest
 
 from halfedge.half_edge_elements import ManifoldMeshError, Vert
@@ -14,7 +12,7 @@ from halfedge.type_attrib import IncompatibleAttrib
 from halfedge.validations import validate_mesh
 
 
-class Coordinate(IncompatibleAttrib[Tuple[float, ...]]):
+class Coordinate(IncompatibleAttrib[tuple[float, ...]]):
     pass