halfedge 0.2.0__tar.gz → 0.4.0__tar.gz

{halfedge-0.2.0 → halfedge-0.4.0}/.github/workflows/pypi-project.yml

@@ -38,27 +38,27 @@ jobs:
       run: |
         pytest
 
-  # If the tests pass, try to bump the version number. If no bump is warranted,
-  # pass silently.
-  bump_version:
-    runs-on: ubuntu-latest
-    name: "Bump version and create changelog with commitizen"
-    continue-on-error: true
-    needs: [tests]
-    if: github.ref == 'refs/heads/dev'
-    steps:
-      - name: Check out
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: "${{ secrets.COMMITIZEN_BUMP }}"
-      - id: cz
-        name: Create bump and changelog
-        uses: commitizen-tools/commitizen-action@master
-        with:
-          github_token: ${{ secrets.COMMITIZEN_BUMP }}
-      - name: Print Version
-        run: echo "Bumped to version ${{ steps.cz.outputs.version }}"
+  # # If the tests pass, try to bump the version number. If no bump is warranted,
+  # # pass silently.
+  # bump_version:
+  #   runs-on: ubuntu-latest
+  #   name: "Bump version and create changelog with commitizen"
+  #   continue-on-error: true
+  #   needs: [tests]
+  #   if: github.ref == 'refs/heads/dev'
+  #   steps:
+  #     - name: Check out
+  #       uses: actions/checkout@v4
+  #       with:
+  #         fetch-depth: 0
+  #         token: "${{ secrets.COMMITIZEN_BUMP }}"
+  #     - id: cz
+  #       name: Create bump and changelog
+  #       uses: commitizen-tools/commitizen-action@master
+  #       with:
+  #         github_token: ${{ secrets.COMMITIZEN_BUMP }}
+  #     - name: Print Version
+  #       run: echo "Bumped to version ${{ steps.cz.outputs.version }}"
 
   # Deploy on test.pypi when branch is dev and commit message starts with 'bump'
   deploy-on-testpypi:

{halfedge-0.2.0 → halfedge-0.4.0}/.pre-commit-config.yaml

@@ -110,6 +110,7 @@ repos:
     - --disable=useless-return # conflicts with mypy
     - --disable=assignment-from-no-return # prevents overloading Attrib methods to only raise an Exception
     - --disable=useless-parent-delegation
+    - --disable=R0801 # Similar lines in multiple files
     - --load-plugins=pylint.extensions.docparams
     - --accept-no-param-doc=n
     - --accept-no-raise-doc=n

{halfedge-0.2.0/src/halfedge.egg-info → halfedge-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: halfedge
-Version: 0.2.0
+Version: 0.4.0
 Summary: A typical half-edge data structure with some padding
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT

{halfedge-0.2.0 → halfedge-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "halfedge"
-version = "0.2.0"
+version = "0.4.0"
 description = "A typical half-edge data structure with some padding"
 authors = [{ name = "Shay Hill", email = "shay_public@hotmail.com" }]
 license = {text = "MIT"}
@@ -25,7 +25,7 @@ build-backend = "setuptools.build_meta"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.2.0"
+version = "0.4.0"
 tag_format = "$version"
 major-version-zero = true
 version_files = ["pyproject.toml:^version"]

{halfedge-0.2.0 → halfedge-0.4.0}/src/halfedge/__init__.py

@@ -1,25 +1,34 @@
 """Allow modules to be imported from top-level."""
 
-from halfedge.half_edge_elements import Edge, Face, Vert
+from halfedge.half_edge_constructors import BlindHalfEdges
+from halfedge.half_edge_elements import Edge, Face, MeshElementBase, Vert
 from halfedge.half_edge_object import HalfEdges
 from halfedge.type_attrib import (
     Attrib,
     ContagionAttrib,
+    EdgeAttrib,
+    FaceAttrib,
     IncompatibleAttrib,
     NumericAttrib,
     Vector2Attrib,
     Vector3Attrib,
+    VertAttrib,
 )
 
 __all__ = [
     "Attrib",
+    "BlindHalfEdges",
     "ContagionAttrib",
     "Edge",
+    "EdgeAttrib",
     "Face",
+    "FaceAttrib",
     "HalfEdges",
     "IncompatibleAttrib",
+    "MeshElementBase",
     "NumericAttrib",
     "Vector2Attrib",
     "Vector3Attrib",
     "Vert",
+    "VertAttrib",
 ]

{halfedge-0.2.0 → halfedge-0.4.0}/src/halfedge/half_edge_constructors.py

@@ -30,7 +30,10 @@ from paragraphs import par
 from halfedge.half_edge_elements import Edge, Face, ManifoldMeshError, Vert
 
 if TYPE_CHECKING:
-    from halfedge.type_attrib import Attrib
+    from halfedge.type_attrib import Attrib, StaticAttrib
+
+
+_T = TypeVar("_T")
 
 _TBlindHalfEdges = TypeVar("_TBlindHalfEdges", bound="BlindHalfEdges")
 
@@ -44,6 +47,27 @@ class BlindHalfEdges:
             self.edges: set[Edge] = set()
         else:
             self.edges = edges
+        self.attrib: dict[str, StaticAttrib[Any]] = {}
+
+    def set_attrib(self, attrib: StaticAttrib[Any]) -> None:
+        """Set an attribute.
+
+        :param attrib: StaticAttrib instance
+        """
+        self.attrib[type(attrib).__name__] = attrib.copy_to_element(self)
+
+    def get_attrib(self, attrib: type[StaticAttrib[_T]]) -> StaticAttrib[_T]:
+        """Get a StaticAttrib.
+
+        :param attrib: StaticAttrib class
+        :returns: StaticAttrib instance
+        :raise AttributeError: if StaticAttrib not found in self.attrib
+        """
+        try:
+            return self.attrib[attrib.__name__]
+        except KeyError as e:
+            msg = f"{attrib.__name__} not found in {self.__class__.__name__}"
+            raise AttributeError(msg) from e
 
     def new_vert(self, *attributes: Attrib[Any], edge: Edge | None = None) -> Vert:
         """Create a new Vert instance.

{halfedge-0.2.0 → halfedge-0.4.0}/src/halfedge/type_attrib.py

@@ -66,11 +66,106 @@ from typing import TYPE_CHECKING, Any, Generic, Literal, Tuple, TypeVar
 from paragraphs import par
 
 if TYPE_CHECKING:
-    from halfedge.half_edge_elements import MeshElementBase
+    from halfedge.half_edge_constructors import BlindHalfEdges
+    from halfedge.half_edge_elements import Edge, Face, MeshElementBase, Vert
 
 _T = TypeVar("_T")
 
 
+class StaticAttrib(Generic[_T]):
+    """Base class for storing a, potentially inferred, attribute value.
+
+    This is the equivalent to the Attrib class, but for meshes, which will never be
+    merged or split.
+    """
+
+    __slots__ = ("_value", "mesh")
+
+    def __new__(
+        cls: type[_TStaticAttrib],
+        value: _T | None = None,
+        mesh: BlindHalfEdges | None = None,
+    ) -> _TStaticAttrib:
+        """Raise an exception if the attribute is not subclassed."""
+        del value
+        del mesh
+        if cls is StaticAttrib:
+            msg = "StaticAttrib is an abstract class and cannot be instantiated."
+            raise TypeError(msg)
+        return object.__new__(cls)
+
+    def __init__(
+        self, value: _T | None = None, mesh: BlindHalfEdges | None = None
+    ) -> None:
+        """Set value and mesh."""
+        self._value = value
+        self.mesh = mesh
+
+    def copy_to_element(
+        self: StaticAttrib[_T], mesh: BlindHalfEdges
+    ) -> StaticAttrib[_T]:
+        """Return a new instance with the same value, assigned to a new mesh.
+
+        :param mesh: BlindHalfEdges instance to which attrib will be assigned.
+        :return: Attrib instance
+        """
+        return type(self)(self._value, mesh)
+
+    @property
+    def value(self) -> _T:
+        """Return value if set, else try to infer a value.
+
+        :return: Value of the attribute
+        :raises AttributeError: If no value is set and _infer_value fails
+        """
+        if self._value is not None:
+            return self._value
+        with suppress(NotImplementedError, ValueError):
+            value = self._infer_value()
+            self._value = value
+            return self._value
+        msg = "no value set and failed to infer from 'self.mesh'"
+        raise AttributeError(msg)
+
+    def _infer_value(self) -> _T:
+        """Get value of self from self._mesh.
+
+        Use the containing mesh to determine a value for self. If no value can be
+        determined, return None.
+
+        The purpose is to allow lazy attributes like edge norm and face area. Use
+        caution, however. These need to be calculated before merging since the method
+        may not support the new shape. For instance, this method might calculate the
+        area of a triangle, but would fail if two triangles were merged into a
+        square. To keep this safe, the _value is calculated *before* any merging. In
+        the "area of a triangle" example,
+
+            * The area calculation is deferred until the first merge.
+            * At the first merge, the area of each merged triangle is calculated. The
+              implication here is that calculation *cannot* be deferred till after a
+              merge.
+            * The merged method sums areas of the merged triangles at the first and
+              subsequent mergers, so further triangle area calculations (which
+              wouldn't work on the merged shapes anyway) are not required.
+
+        If you infer a value, cache it by setting self._value.
+
+        If you do not intend to infer values, raise an exception. This exception
+        should occur *before* an AttributeError is raised for a potentially missing
+        mesh attribute. It should be clear that _infer_value failed because there
+        is no provision for inferring this Attrib.value, *not* because the
+        user failed to set the Attrib property attribute.
+        """
+        msg = par(
+            f"""'{type(self).__name__}' has no provision for inferring a value from
+            'self.mesh'"""
+        )
+        raise AttributeError(msg)
+
+
+_TStaticAttrib = TypeVar("_TStaticAttrib", bound=StaticAttrib[Any])
+
+
 class Attrib(Generic[_T]):
     """Base class for element attributes.
 
@@ -121,7 +216,7 @@ class Attrib(Generic[_T]):
             value = self._infer_value()
             self._value = value
             return self._value
-        msg = f"no value set and failed to infer from {self.element}"
+        msg = "no value set and failed to infer from 'self.element'"
         raise AttributeError(msg)
 
     def copy_to_element(self: Attrib[_T], element: MeshElementBase) -> Attrib[_T]:
@@ -217,6 +312,228 @@ class Attrib(Generic[_T]):
 _TAttrib = TypeVar("_TAttrib", bound=Attrib[Any])
 
 
+class VertAttrib(Generic[_T]):
+    """Base class for Vert attributes."""
+
+    __slots__ = ("_value", "vert")
+
+    def __new__(
+        cls: type[_TVertAttrib], value: _T | None = None, vert: Vert | None = None
+    ) -> _TVertAttrib:
+        """Raise an exception if the attribute is not subclassed."""
+        del value
+        del vert
+        if cls is VertAttrib:
+            msg = "VertAttrib is an abstract class and cannot be instantiated."
+            raise TypeError(msg)
+        return object.__new__(cls)
+
+    def __init__(self, value: _T | None = None, vert: Vert | None = None) -> None:
+        """Set value and vert."""
+        self._value = value
+        self.vert = vert
+
+    @property
+    def value(self) -> _T:
+        """Return value if set, else try to infer a value.
+
+        :return: Value of the attribute
+        :raises AttributeError: If no value is set and _infer_value fails
+        """
+        if self._value is not None:
+            return self._value
+        with suppress(NotImplementedError, ValueError):
+            value = self._infer_value()
+            self._value = value
+            return self._value
+        msg = "no value set and failed to infer from 'self.vert'"
+        raise AttributeError(msg)
+
+    def copy_to_vert(self: VertAttrib[_T], vert: Vert) -> VertAttrib[_T]:
+        """Return a new instance with the same value, assigned to a new vert.
+
+        :param vert: New vert
+        :return: VertAttrib instance
+        """
+        return type(self)(self._value, vert)
+
+    @classmethod
+    def merge(cls, *merge_from: _TVertAttrib | None) -> _TVertAttrib | None:
+        """Get value of self from self._merge_from.
+
+        :param merge_from: VertAttrib instances to merge (all of the same class)
+        :return: VertAttrib instance or None
+        """
+        _ = merge_from
+        return None
+
+    def split(self: _TVertAttrib) -> _TVertAttrib | None:
+        """Define how attribute will be passed when dividing self.vert.
+
+        :return: VertAttrib instance or None
+        """
+        return None
+
+    def _infer_value(self) -> _T:
+        """Get value of self from self._vert."""
+        msg = par(
+            f"""'{type(self).__name__}' has no provision for inferring a value from
+            'self.vert'"""
+        )
+        raise AttributeError(msg)
+
+
+_TVertAttrib = TypeVar("_TVertAttrib", bound=VertAttrib[Any])
+
+
+class EdgeAttrib(Generic[_T]):
+    """Base class for Edge attributes."""
+
+    __slots__ = ("_value", "edge")
+
+    def __new__(
+        cls: type[_TEdgeAttrib], value: _T | None = None, edge: Edge | None = None
+    ) -> _TEdgeAttrib:
+        """Raise an exception if the attribute is not subclassed."""
+        del value
+        del edge
+        if cls is EdgeAttrib:
+            msg = "EdgeAttrib is an abstract class and cannot be instantiated."
+            raise TypeError(msg)
+        return object.__new__(cls)
+
+    def __init__(self, value: _T | None = None, edge: Edge | None = None) -> None:
+        """Set value and edge."""
+        self._value = value
+        self.edge = edge
+
+    @property
+    def value(self) -> _T:
+        """Return value if set, else try to infer a value.
+
+        :return: Value of the attribute
+        :raises AttributeError: If no value is set and _infer_value fails
+        """
+        if self._value is not None:
+            return self._value
+        with suppress(NotImplementedError, ValueError):
+            value = self._infer_value()
+            self._value = value
+            return self._value
+        msg = "no value set and failed to infer from 'self.edge'"
+        raise AttributeError(msg)
+
+    def copy_to_edge(self: EdgeAttrib[_T], edge: Edge) -> EdgeAttrib[_T]:
+        """Return a new instance with the same value, assigned to a new edge.
+
+        :param edge: New edge
+        :return: EdgeAttrib instance
+        """
+        return type(self)(self._value, edge)
+
+    @classmethod
+    def merge(cls, *merge_from: _TEdgeAttrib | None) -> _TEdgeAttrib | None:
+        """Get value of self from self._merge_from.
+
+        :param merge_from: EdgeAttrib instances to merge (all of the same class)
+        :return: EdgeAttrib instance or None
+        """
+        _ = merge_from
+        return None
+
+    def split(self: _TEdgeAttrib) -> _TEdgeAttrib | None:
+        """Define how attribute will be passed when dividing self.edge.
+
+        :return: EdgeAttrib instance or None
+        """
+        return None
+
+    def _infer_value(self) -> _T:
+        """Get value of self from self._edge."""
+        msg = par(
+            f"""'{type(self).__name__}' has no provision for inferring a value from
+            'self.edge'"""
+        )
+        raise AttributeError(msg)
+
+
+_TEdgeAttrib = TypeVar("_TEdgeAttrib", bound=EdgeAttrib[Any])
+
+
+class FaceAttrib(Generic[_T]):
+    """Base class for Face attributes."""
+
+    __slots__ = ("_value", "face")
+
+    def __new__(
+        cls: type[_TFaceAttrib], value: _T | None = None, face: Face | None = None
+    ) -> _TFaceAttrib:
+        """Raise an exception if the attribute is not subclassed."""
+        del value
+        del face
+        if cls is FaceAttrib:
+            msg = "FaceAttrib is an abstract class and cannot be instantiated."
+            raise TypeError(msg)
+        return object.__new__(cls)
+
+    def __init__(self, value: _T | None = None, face: Face | None = None) -> None:
+        """Set value and face."""
+        self._value = value
+        self.face = face
+
+    @property
+    def value(self) -> _T:
+        """Return value if set, else try to infer a value.
+
+        :return: Value of the attribute
+        :raises AttributeError: If no value is set and _infer_value fails
+        """
+        if self._value is not None:
+            return self._value
+        with suppress(NotImplementedError, ValueError):
+            value = self._infer_value()
+            self._value = value
+            return self._value
+        msg = "no value set and failed to infer from 'self.face'"
+        raise AttributeError(msg)
+
+    def copy_to_face(self: FaceAttrib[_T], face: Face) -> FaceAttrib[_T]:
+        """Return a new instance with the same value, assigned to a new face.
+
+        :param face: New face
+        :return: FaceAttrib instance
+        """
+        return type(self)(self._value, face)
+
+    @classmethod
+    def merge(cls, *merge_from: _TFaceAttrib | None) -> _TFaceAttrib | None:
+        """Get value of self from self._merge_from.
+
+        :param merge_from: FaceAttrib instances to merge (all of the same class)
+        :return: FaceAttrib instance or None
+        """
+        _ = merge_from
+        return None
+
+    def split(self: _TFaceAttrib) -> _TFaceAttrib | None:
+        """Define how attribute will be passed when dividing self.face.
+
+        :return: FaceAttrib instance or None
+        """
+        return None
+
+    def _infer_value(self) -> _T:
+        """Get value of self from self._face."""
+        msg = par(
+            f"""'{type(self).__name__}' has no provision for inferring a value from
+            'self.face'"""
+        )
+        raise AttributeError(msg)
+
+
+_TFaceAttrib = TypeVar("_TFaceAttrib", bound=FaceAttrib[Any])
+
+
 class ContagionAttrib(Attrib[Literal[True]]):
     """Spread value when combining with anything.
 

{halfedge-0.2.0 → halfedge-0.4.0/src/halfedge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: halfedge
-Version: 0.2.0
+Version: 0.4.0
 Summary: A typical half-edge data structure with some padding
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT

{halfedge-0.2.0 → halfedge-0.4.0}/tests/test_classes.py

@@ -12,6 +12,7 @@ from typing import Any, Tuple, TypeVar
 
 import pytest
 
+from halfedge.half_edge_constructors import BlindHalfEdges
 from halfedge.half_edge_elements import (
     Edge,
     Face,
@@ -27,6 +28,7 @@ from halfedge.type_attrib import (
     ContagionAttrib,
     IncompatibleAttrib,
     NumericAttrib,
+    StaticAttrib,
     Vector2Attrib,
     Vector3Attrib,
 )
@@ -50,6 +52,10 @@ class MyAttrib(Attrib[int]):
     """An attribute with an integer value."""
 
 
+class MyStaticAttrib(StaticAttrib[int]):
+    """A static attribute with an integer value."""
+
+
 class TestCannotInstantiateAbstractClasses:
     def test_cannot_instantiate_abstract_class(self) -> None:
         """Raise TypeError when instantiating an abstract class."""
@@ -87,6 +93,31 @@ class TestCannotInstantiateAbstractClasses:
             _ = Vector3Attrib()
         assert "cannot be instantiated" in err.value.args[0]
 
+    def test_cannot_instantiate_static_attrib(self) -> None:
+        """Raise TypeError when instantiating an abstract class."""
+        with pytest.raises(TypeError) as err:
+            _: StaticAttrib[Any] = StaticAttrib()
+        assert "cannot be instantiated" in err.value.args[0]
+
+
+class TestStaticAttrib:
+    def test_attribute_error_if_no_value_set(self) -> None:
+        """Raise AttributeError if no value set."""
+        attrib = MyStaticAttrib()
+        with pytest.raises(AttributeError):
+            _ = attrib.value
+
+
+class TestBlindHalfEdgesAttribSettersAndGetters:
+    def test_set_attrib(self) -> None:
+        """Set an attrib by passing a MeshElementBase instance"""
+        mesh = BlindHalfEdges()
+        attrib = MyStaticAttrib(7)
+        mesh.set_attrib(attrib)
+        stored_attrib = mesh.get_attrib(MyStaticAttrib)
+        assert stored_attrib.value == 7
+        assert stored_attrib.mesh is mesh
+
 
 class TestAttribBaseClass:
     def test_attribute_error_if_no_value_set(self) -> None:

{halfedge-0.2.0 → halfedge-0.4.0}/tests/test_constructors.py

@@ -5,8 +5,6 @@ created: 170204 14:22:23
 
 # pyright: reportPrivateUsage=false
 
-import itertools
-import random
 from typing import Any, Dict, Tuple
 
 import pytest
@@ -22,11 +20,6 @@ from halfedge.half_edge_querries import StaticHalfEdges
 from halfedge.type_attrib import IncompatibleAttrib, NumericAttrib
 from tests.conftest import get_canonical_mesh
 
-alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-identifiers = (
-    "".join(random.choice(alphabet) for _ in range(10)) for _ in itertools.count()
-)
-
 
 class Coordinate(IncompatibleAttrib[Tuple[float, ...]]):
     pass