halfedge 0.4.0__tar.gz → 0.5.0__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "halfedge"
-version = "0.4.0"
+version = "0.5.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.4.0"
+version = "0.5.0"
 tag_format = "$version"
 major-version-zero = true
 version_files = ["pyproject.toml:^version"]

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

@@ -6,13 +6,10 @@ from halfedge.half_edge_object import HalfEdges
 from halfedge.type_attrib import (
     Attrib,
     ContagionAttrib,
-    EdgeAttrib,
-    FaceAttrib,
     IncompatibleAttrib,
     NumericAttrib,
     Vector2Attrib,
     Vector3Attrib,
-    VertAttrib,
 )
 
 __all__ = [
@@ -20,9 +17,7 @@ __all__ = [
     "BlindHalfEdges",
     "ContagionAttrib",
     "Edge",
-    "EdgeAttrib",
     "Face",
-    "FaceAttrib",
     "HalfEdges",
     "IncompatibleAttrib",
     "MeshElementBase",
@@ -30,5 +25,4 @@ __all__ = [
     "Vector2Attrib",
     "Vector3Attrib",
     "Vert",
-    "VertAttrib",
 ]

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

@@ -67,7 +67,7 @@ from paragraphs import par
 
 if TYPE_CHECKING:
     from halfedge.half_edge_constructors import BlindHalfEdges
-    from halfedge.half_edge_elements import Edge, Face, MeshElementBase, Vert
+    from halfedge.half_edge_elements import MeshElementBase
 
 _T = TypeVar("_T")
 
@@ -312,228 +312,6 @@ 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.4.0 → halfedge-0.5.0/src/halfedge.egg-info}/PKG-INFO

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