halfedge 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

halfedge/__init__.py

@@ -1,6 +1,7 @@
 """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,
@@ -13,11 +14,13 @@ from halfedge.type_attrib import (
 
 __all__ = [
     "Attrib",
+    "BlindHalfEdges",
     "ContagionAttrib",
     "Edge",
     "Face",
     "HalfEdges",
     "IncompatibleAttrib",
+    "MeshElementBase",
     "NumericAttrib",
     "Vector2Attrib",
     "Vector3Attrib",

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/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_constructors import BlindHalfEdges
     from halfedge.half_edge_elements import MeshElementBase
 
 _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]:

{halfedge-0.2.0.dist-info → halfedge-0.3.0.dist-info}/METADATA

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

halfedge-0.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+halfedge/__init__.py,sha256=SIezwH5Ox5DQDw5Rr5lmg1W0Y8JW2Q90gQa_PHpKVoY,623
+halfedge/half_edge_constructors.py,sha256=ToGcOYW2b848ynlY59xRNd7ibZuu3OqQpauPCl-N1YE,8654
+halfedge/half_edge_elements.py,sha256=6PkPjGxe_0FYSWXi5MY8Yp4an7yYMWir8MPZn8QlUOc,18042
+halfedge/half_edge_object.py,sha256=Cc1t_hy2tF52O9iD5tvZN6_w4H7Wt9hwDGFLdBqUxr4,28451
+halfedge/half_edge_querries.py,sha256=q5xVOFdpw7t6fhs-Z8yF5j3RlG4DOrOgoLbBsAfkm4A,5179
+halfedge/py.typed,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
+halfedge/type_attrib.py,sha256=bo0Tw-9dhvi0XwehaYY9WowEZuRKlg07Vx0vRuJtDPw,19702
+halfedge/validations.py,sha256=FhUv_J7XcaAduyudYGmi7ZL1tEqwJoCxKZwJU2zQolg,4512
+halfedge-0.3.0.dist-info/METADATA,sha256=gfvX38VnIi-mGzjVwD5sJUphMigznpZF0uny0gnRRyE,7411
+halfedge-0.3.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+halfedge-0.3.0.dist-info/top_level.txt,sha256=iqphKHiIR4DfFMs14-gkFOWTXVkRWfGmDZmCYHhuoFM,9
+halfedge-0.3.0.dist-info/RECORD,,

halfedge-0.2.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-halfedge/__init__.py,sha256=XuyK1eJ6mn_0Y7GYZ9yZKGjUf2lBDr31u8l_pW9q49k,502
-halfedge/half_edge_constructors.py,sha256=AVxbZRuqEgjaWut3R7FfJBLid-9eDPscUQNoFh_gwrQ,7850
-halfedge/half_edge_elements.py,sha256=6PkPjGxe_0FYSWXi5MY8Yp4an7yYMWir8MPZn8QlUOc,18042
-halfedge/half_edge_object.py,sha256=Cc1t_hy2tF52O9iD5tvZN6_w4H7Wt9hwDGFLdBqUxr4,28451
-halfedge/half_edge_querries.py,sha256=q5xVOFdpw7t6fhs-Z8yF5j3RlG4DOrOgoLbBsAfkm4A,5179
-halfedge/py.typed,sha256=MsSFjiLMLJZ7QhUPpVBWKiyDnCzryquRyr329NoCACI,2
-halfedge/type_attrib.py,sha256=61HLkMlvPYbjT6ijaKms-3z9c-844sS8j3QBKYwA720,15980
-halfedge/validations.py,sha256=FhUv_J7XcaAduyudYGmi7ZL1tEqwJoCxKZwJU2zQolg,4512
-halfedge-0.2.0.dist-info/METADATA,sha256=bj7tyx2nCeNx2wNGbDjJwboGiAhSl5Unc6OpzZAq0uk,7411
-halfedge-0.2.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-halfedge-0.2.0.dist-info/top_level.txt,sha256=iqphKHiIR4DfFMs14-gkFOWTXVkRWfGmDZmCYHhuoFM,9
-halfedge-0.2.0.dist-info/RECORD,,