halfedge 0.7.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

halfedge/__init__.py

@@ -1,4 +1,8 @@
-"""Allow modules to be imported from top-level."""
+"""Import functions into the package namespace.
+
+:author: Shay Hill
+:created: 2026-01-25
+"""
 
 from halfedge.half_edge_constructors import BlindHalfEdges
 from halfedge.half_edge_elements import Edge, Face, MeshElementBase, Vert

halfedge/half_edge_constructors.py

@@ -23,20 +23,20 @@ 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, Self, 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
 
 
 _T = TypeVar("_T")
 
-_TBlindHalfEdges = TypeVar("_TBlindHalfEdges", bound="BlindHalfEdges")
-
 
 class BlindHalfEdges:
     """Half-edge structure with no lookups."""
@@ -189,11 +189,11 @@ class BlindHalfEdges:
 
     @classmethod
     def from_vlfi(
-        cls: type[_TBlindHalfEdges],
+        cls,
         vl: Sequence[Vert],
         fi: Iterable[tuple[int, ...]],
         hi: Iterable[tuple[int, ...]] | None = None,
-    ) -> _TBlindHalfEdges:
+    ) -> Self:
         """Create a set of half edges from a vertex list and face index.
 
         :param vl: (vertex list) a seq of vertices

halfedge/half_edge_elements.py

@@ -38,14 +38,15 @@ from __future__ import annotations
 
 from contextlib import suppress
 from itertools import count
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from typing import TYPE_CHECKING, Any, Self, TypeVar
 
 from halfedge.type_attrib import Attrib, ContagionAttrib
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from halfedge.half_edge_constructors import BlindHalfEdges
 
-_TMeshElem = TypeVar("_TMeshElem", bound="MeshElementBase")
 
 _T = TypeVar("_T")
 
@@ -141,7 +142,7 @@ class MeshElementBase:
         except AttributeError:
             return None
 
-    def merge_from(self: _TMeshElem, *elements: _TMeshElem) -> _TMeshElem:
+    def merge_from(self, *elements: Self) -> Self:
         """Fill in missing references from other elements.
 
         :param elements: elements to merge from
@@ -165,7 +166,7 @@ class MeshElementBase:
                 self.set_attrib(merged_attrib)
         return self
 
-    def split_from(self: _TMeshElem, element: _TMeshElem) -> _TMeshElem:
+    def split_from(self, element: Self) -> Self:
         """Pass attributes when dividing or altering elements.
 
         :param element: element to split from
@@ -182,7 +183,7 @@ class MeshElementBase:
                 self.set_attrib(splitted)
         return self
 
-    def __lt__(self: _TMeshElem, other: _TMeshElem) -> bool:
+    def __lt__(self, other: Self) -> bool:
         """Sort by sn.
 
         You'll want to be able to sort Verts at least to make a vlvi (vertex list,

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/py.typed

@@ -1 +1,5 @@
-#
+""" This file is used to indicate to mypy that the package is typed.
+
+Do not delete this comment, because empty files choke
+some cloud drives on sync.
+"""

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, Self, TypeVar
 
 from paragraphs import par
 
@@ -79,13 +79,13 @@ class StaticAttrib(Generic[_T]):
     merged or split.
     """
 
-    __slots__ = ("_value", "_mesh")
+    __slots__ = ("_mesh", "_value")
 
     def __new__(
-        cls: type[_TStaticAttrib],
+        cls,
         value: _T | None = None,
         mesh: BlindHalfEdges | None = None,
-    ) -> _TStaticAttrib:
+    ) -> Self:
         """Raise an exception if the attribute is not subclassed."""
         del value
         del mesh
@@ -157,16 +157,16 @@ class StaticAttrib(Generic[_T]):
               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.
+              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.
+        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
@@ -175,31 +175,26 @@ class StaticAttrib(Generic[_T]):
         raise AttributeError(msg)
 
 
-_TStaticAttrib = TypeVar("_TStaticAttrib", bound=StaticAttrib[Any])
-
-
 class Attrib(Generic[_T]):
     """Base class for element attributes.
 
     MeshElementBase has methods set_attrib and get_attrib that will store Attrib
     instances in the MeshElemenBase.attrib dict. The Attrib class defines how these
-    attributes behave when mesh elements are merged and optionally allows a value
-    (e.g., edge length) to be inferred from the Attrib.element property when and if
-    needed, allowing us to cache (and potentially never access) slow attributes.
-
-    Do not overload `__init__` or `value`. For the most part, treat as an ABC with
-    abstract methods `merge`, `split`, and `_infer_value`--although the base methods
-    are marginally useful and instructive, so you will not need to overload both in
-    every case.
+    attributes behave when mesh elements are merged and optionally allows a value (e.g.,
+    edge length) to be inferred from the Attrib.element property when and if needed,
+    allowing us to cache (and potentially never access) slow attributes.
+
+    Do not overload `__init__` or `value`. Subclasses can override `merge`, `split`,
+    and `_infer_value` to customize behavior while inheriting all other functionality.
     """
 
-    __slots__ = ("_value", "_element")
+    __slots__ = ("_element", "_value")
 
     def __new__(
-        cls: type[_TAttrib],
+        cls,
         value: _T | None = None,
         element: MeshElementBase | None = None,
-    ) -> _TAttrib:
+    ) -> Self:
         """Raise an exception if the attribute is not subclassed."""
         del value
         del element
@@ -268,14 +263,15 @@ class Attrib(Generic[_T]):
         Attrib attributes are assumed None if not defined and are never defined
         if their value is None.
 
-        This base method will not merge attributes, which is desirable in some cases.
+        Override this method in subclasses to customize merge behavior. Default
+        implementation returns None (no merge), which is desirable in some cases.
         For example, a triangle circumcenter that will be meaningless when the
         triangle is merged.
         """
         _ = merge_from
         return None
 
-    def split(self: _TAttrib) -> _TAttrib | None:
+    def split(self) -> Self | None:
         """Define how attribute will be passed when dividing self.element.
 
         :return: Attrib instance or None
@@ -293,7 +289,9 @@ class Attrib(Generic[_T]):
         attribute is lazy (e.g., edge norm), you might want to unset _value for each
         piece of a split edge.
 
-        This base method will not pass an attribute when dividing or altering.
+        Override this method in subclasses to customize split behavior. Default
+        implementation returns None (no split), meaning the attribute will not be
+        passed when dividing or altering elements.
         """
         return None
 
@@ -320,11 +318,12 @@ class Attrib(Generic[_T]):
 
         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
-        element 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.
+        Override this method in subclasses to customize value inference. If you do
+        not intend to infer values, raise an exception. This exception should occur
+        *before* an AttributeError is raised for a potentially missing element
+        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
@@ -348,10 +347,10 @@ class ContagionAttrib(Attrib[Literal[True]]):
     """
 
     def __new__(
-        cls: type[_TAttrib],
+        cls,
         value: Literal[True] | None = None,
         element: MeshElementBase | None = None,
-    ) -> _TAttrib:
+    ) -> Self:
         """Raise an exception if the attribute is not subclassed."""
         del value
         del element
@@ -381,7 +380,7 @@ class ContagionAttrib(Attrib[Literal[True]]):
             return attribs[0]
         return None
 
-    def split(self: _TAttrib) -> _TAttrib | None:
+    def split(self) -> Self | None:
         """Copy attribute to splits.
 
         :return: self
@@ -400,10 +399,10 @@ class IncompatibleAttrib(Attrib[_T]):
     """
 
     def __new__(
-        cls: type[_TAttrib],
+        cls,
         value: _T | None = None,
         element: MeshElementBase | None = None,
-    ) -> _TAttrib:
+    ) -> Self:
         """Raise an exception if the attribute is not subclassed."""
         del value
         del element
@@ -431,7 +430,7 @@ class IncompatibleAttrib(Attrib[_T]):
                 return None
         return merge_from[0]
 
-    def split(self: _TAttrib) -> _TAttrib | None:
+    def split(self) -> Self | None:
         """Pass the value on.
 
         :return: self
@@ -443,10 +442,10 @@ class NumericAttrib(Attrib[_T]):
     """Average merge_from values."""
 
     def __new__(
-        cls: type[_TAttrib],
+        cls,
         value: _T | None = None,
         element: MeshElementBase | None = None,
-    ) -> _TAttrib:
+    ) -> Self:
         """Raise an exception if the attribute is not subclassed."""
         del value
         del element
@@ -469,14 +468,14 @@ 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__(
-        cls: type[_TAttrib],
+        cls,
         value: tuple[float, float] | None = None,
         element: MeshElementBase | None = None,
-    ) -> _TAttrib:
+    ) -> Self:
         """Raise an exception if the attribute is not subclassed."""
         del value
         del element
@@ -496,19 +495,19 @@ class Vector2Attrib(Attrib[Tuple[float, float]]):
         if not have_values:
             return None
         values = [x.value for x in have_values]
-        sum_x, sum_y = (sum(xs) for xs in zip(*values))
+        sum_x, sum_y = (sum(xs) for xs in zip(*values, strict=True))
         num = len(values)
         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__(
-        cls: type[_TAttrib],
+        cls,
         value: tuple[float, float, float] | None = None,
         element: MeshElementBase | None = None,
-    ) -> _TAttrib:
+    ) -> Self:
         """Raise an exception if the attribute is not subclassed."""
         del value
         del element
@@ -528,6 +527,6 @@ class Vector3Attrib(Attrib[Tuple[float, float, float]]):
         if not have_values:
             return None
         values = [x.value for x in have_values]
-        sum_x, sum_y, sum_z = (sum(xs) for xs in zip(*values))
+        sum_x, sum_y, sum_z = (sum(xs) for xs in zip(*values, strict=True))
         num = len(values)
         return type(have_values[0])((sum_x / num, sum_y / num, sum_z / num))

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, TypeVar
 
 from halfedge.half_edge_elements import Edge, Face, ManifoldMeshError
 
 if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+
     from halfedge.half_edge_querries import StaticHalfEdges
 
 _T = TypeVar("_T")

{halfedge-0.7.0.dist-info → halfedge-0.11.0.dist-info}/METADATA

@@ -1,19 +1,13 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: halfedge
-Version: 0.7.0
+Version: 0.11.0
 Summary: A typical half-edge data structure with some padding
+Author: Shay Hill
 Author-email: Shay Hill <shay_public@hotmail.com>
-License: MIT
-Requires-Python: >=3.8
+License-Expression: MIT
+Requires-Dist: paragraphs>=1.0.1
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: paragraphs
-Provides-Extra: dev
-Requires-Dist: commitizen ; extra == 'dev'
-Requires-Dist: coverage ; extra == 'dev'
-Requires-Dist: pre-commit ; extra == 'dev'
-Requires-Dist: pylint ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: tox ; extra == 'dev'
 
 # A typical halfedges data structure with some padding
 
@@ -35,11 +29,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 +58,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.11.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+halfedge/__init__.py,sha256=1-q2fVFdMh3NWMh9ujuuyAnxNgPW8jIs_XpJ2oU8eFc,703
+halfedge/half_edge_constructors.py,sha256=mozSdN3fBh1EbjKnhR1g9tqePj2LwM6GL1OrUaBocos,8584
+halfedge/half_edge_elements.py,sha256=z5rjlZCVJJOpWUf8oVNvZXgr1x4xhz5033lmsm4UBLk,18466
+halfedge/half_edge_object.py,sha256=A70CVmV44zDi46gbtGHj8dw4Ltshqs56MRn5-78eM20,28771
+halfedge/half_edge_querries.py,sha256=q5xVOFdpw7t6fhs-Z8yF5j3RlG4DOrOgoLbBsAfkm4A,5179
+halfedge/py.typed,sha256=cnjZxaS4F-N8wLWhQK9YvZ-PaN5T1TK94E9VhPT_LGg,155
+halfedge/type_attrib.py,sha256=GOrO6kiCwLM7XgnonS9jB9Z_6cd6BCm3GsJQ-ASuYIQ,20368
+halfedge/validations.py,sha256=G3YmJnxX5Q_C3Jhbd7740oTngvsOIllfSwLa81jY3d0,4544
+halfedge-0.11.0.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+halfedge-0.11.0.dist-info/METADATA,sha256=7m3b02UpPq_DYX9V1mZzr3GqerKB-EAla4WlPxB51FM,6779
+halfedge-0.11.0.dist-info/RECORD,,

{halfedge-0.7.0.dist-info → halfedge-0.11.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: uv 0.9.26
 Root-Is-Purelib: true
 Tag: py3-none-any
-

halfedge-0.7.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-halfedge/__init__.py,sha256=O5tfw3JIBJH83JlpwdYoTNHFsmcg959rAJd6RU51E4s,661
-halfedge/half_edge_constructors.py,sha256=ToGcOYW2b848ynlY59xRNd7ibZuu3OqQpauPCl-N1YE,8654
-halfedge/half_edge_elements.py,sha256=oX4ti6f6L1gcYsoP-KGNwdF4-cRpTJeBoMGMTJuIN14,18554
-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=1W06nlyTSc0Q6f6PnQec_VNNRLVSgdNStoBlJmMgJNQ,20420
-halfedge/validations.py,sha256=FhUv_J7XcaAduyudYGmi7ZL1tEqwJoCxKZwJU2zQolg,4512
-halfedge-0.7.0.dist-info/METADATA,sha256=UYimfFRmGpY38Ipy9QgOqWwrW28El8aKnTybjhjKQVc,7411
-halfedge-0.7.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-halfedge-0.7.0.dist-info/top_level.txt,sha256=iqphKHiIR4DfFMs14-gkFOWTXVkRWfGmDZmCYHhuoFM,9
-halfedge-0.7.0.dist-info/RECORD,,

halfedge-0.7.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-halfedge