halfedge 0.2.0__tar.gz

halfedge-0.2.0/.github/workflows/pypi-project.yml

@@ -0,0 +1,110 @@
+# Run tests then upload to Pypi on version bumps.
+# Run tests on each push.
+# Try to bump version
+# If version is bumped, upload to pypi or test.pypi depending on branch name.
+
+name: pypi project
+
+on:
+  push:
+    branches: [dev, main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    # if: startsWith(github.event.head_commit.message, 'bump:') == false
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+        python -m pip install pytest
+        python -m pip install commitizen
+        python -m pip install .
+
+    - name: Test with pytest
+      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 }}"
+
+  # Deploy on test.pypi when branch is dev and commit message starts with 'bump'
+  deploy-on-testpypi:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    needs: [tests]
+    if: github.ref_name == 'dev' && startsWith(github.event.head_commit.message, 'bump:')
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      - name: Build package
+        run: python -m build
+      - name: Publish package
+        uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+        with:
+          repository_url: https://test.pypi.org/legacy/
+          user: __token__
+          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+
+  # Deploy on pypi when branch is main and commit message starts with 'bump'
+  deploy-on-pypi:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    needs: [tests]
+    if: github.ref_name == 'main' && startsWith(github.event.head_commit.message, 'bump:')
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      - name: Build package
+        run: python -m build
+      - name: Publish package
+        uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI_API_TOKEN }}

halfedge-0.2.0/.gitignore

@@ -0,0 +1 @@
+Update-PythonVenv.ps1

halfedge-0.2.0/.pre-commit-config.yaml

@@ -0,0 +1,145 @@
+ci:
+  skip: [pyright]
+
+repos:
+
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v4.6.0
+  hooks:
+    - id: check-added-large-files
+    - id: check-ast
+    - id: check-case-conflict
+    - id: check-docstring-first
+    - id: check-executables-have-shebangs
+    - id: check-json
+    - id: check-merge-conflict
+      args:
+        - --assume-in-merge
+    - id: check-shebang-scripts-are-executable
+    - id: check-symlinks
+    - id: check-toml
+    - id: check-vcs-permalinks
+    - id: check-xml
+    - id: check-yaml
+    - id: debug-statements
+    - id: destroyed-symlinks
+    # - id: detect-aws-credentials
+    - id: detect-private-key
+    - id: end-of-file-fixer
+    - 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
+    - id: no-commit-to-branch
+    - id: pretty-format-json
+      args: ['--autofix']
+    # - id: sort-simple-yaml
+        # files: .pre-commit-config.yaml
+
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: v1.11.1
+  hooks:
+  - id: mypy
+    name: mypy
+    language: python
+    language_version: python 3.12
+    types: [python]
+    require_serial: true
+    verbose: true
+    additional_dependencies: ['types-requests']
+    # exclude: "tests"
+    # args:
+    # - --ignore-missing-imports
+    # files: ^(src/|tests/)
+
+- repo: https://github.com/PyCQA/isort
+  rev: 5.13.2
+  hooks:
+  - id: isort
+    args: ["--profile", "black", "--filter-files", "--combine-as", "honor--noqa"]
+
+- repo: https://github.com/psf/black
+  rev: 24.8.0
+  hooks:
+  - id: black
+    language_version: python3.8
+    args: ["--skip-magic-trailing-comma"]
+
+- repo: https://github.com/asottile/pyupgrade
+  rev: v3.17.0
+  hooks:
+  - args:
+    - --py38-plus
+    id: pyupgrade
+
+- repo: https://github.com/Lucas-C/pre-commit-hooks
+  rev: v1.5.5
+  hooks:
+  - id: remove-tabs
+
+- repo: https://github.com/commitizen-tools/commitizen
+  rev: v3.28.0
+  hooks:
+  - id: commitizen
+
+- repo: local
+  hooks:
+  - id: pylint
+    exclude: "tests"
+    name: pylint
+    entry: ./venv/Scripts/pylint.exe
+    language: system
+    types: [python]
+    args:
+    - --ignore-patterns=venv
+    - --good-names=i,j,_,f
+    # - --disable=protected-access
+    # - --disable=no-member
+    # - --disable=import-error
+    # - --disable=no-name-in-module
+    - --disable=redundant-returns-doc # many false positives
+    - --disable=too-many-arguments
+    - --disable=too-many-instance-attributes
+    - --disable=redefined-builtin # sticking with edge.next
+    - --disable=invalid-name # for _TMeshElem and similar type hints
+    - --disable=useless-return # conflicts with mypy
+    - --disable=assignment-from-no-return # prevents overloading Attrib methods to only raise an Exception
+    - --disable=useless-parent-delegation
+    - --load-plugins=pylint.extensions.docparams
+    - --accept-no-param-doc=n
+    - --accept-no-raise-doc=n
+    - --accept-no-return-doc=n
+    - --accept-no-yields-doc=n
+
+- repo: https://github.com/charliermarsh/ruff-pre-commit
+  # ignores
+  # COM812 Trailing comma missing (does not agree with Black)
+  # D203 1 blank line required before class docstring (incompatible with D211)
+  # D213 multi line summary second line (incompatible with D212):
+  # ISC003 Explicitly concatenated string should be implicitly concatenated
+  #
+  # PYI019 Use typing.Self instead of custom TypeVar (useless py < 3.10)
+  # A002 shadowing built-in 'next'
+  # 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'
+  hooks:
+    - id: ruff
+      exclude: "tests"
+      args:
+      - --target-version=py38
+      - --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
+  hooks:
+    - id: pyright

halfedge-0.2.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.1
+Name: halfedge
+Version: 0.2.0
+Summary: A typical half-edge data structure with some padding
+Author-email: Shay Hill <shay_public@hotmail.com>
+License: MIT
+Requires-Python: >=3.8
+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
+
+## Use
+
+You will most likely want to create meshes with the `from_vlfi` constructor. It's got a few tricks, so be sure to read the docstring.
+
+```python
+from halfedges import HalfEdges, Vert
+
+vertices = [Vert() for _ in range(4)]
+face_indices: list[tuple[int, ...]] = [(0, 1, 2), (0, 2, 3)]
+
+mesh = HalfEdges.from_vlfi(vertices, face_indices)
+
+edge = next(iter(mesh.edges))
+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.
+
+### 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`.
+
+### id
+
+Each Vert, Edge, and Face instance has an `id` attribute. This is a unique, sequential identifier for the instance. Sorted vert, edge, and face lists (`HalfEdges.vl`, `HalfEdges.el`, `HalfEdges.fl`) are sorted by `id`. All Vert, Edge, and Face instances across all HalfEdges instances will share the id counter, so don't expect the id of your verts to start at 0.
+
+### Holes
+
+A triangle mesh in 2D will never be entirely triangular (and also manifold). There will be a boundary around the triangles. This library treats the outside of that boundary as a face (with an `is_hole == True` attribute). This way, every edge has a pair and a face, and the `is_hole` flags can be used to keep these hole faces out of your way.
+
+Holes are useful for more than just 2D mesh boundaries, you can explicitly create holes (`Face` instances with an as `is_hole == True` property) to maintain manifold mesh conditions in many circumstances. The constructor `HalfEdges.from_vlfi()` will try to insert hole faces to maintain manifold conditions.
+
+Four main types: Vert, Edge, Face, and HalfEdges. Vert and Face instances have `*.faces` properties which will return all adjacent faces. These properties will *not* return faces flagged as holes. The holes are there to keep things simple and manifold, but otherwise stay out of your way.
+
+```python
+Face(
+    *attributes: Attrib[Any],
+    mesh: BlindHalfEdges | None = None,
+    edge: Edge | None = None,
+    is_hole: bool = False,
+) -> None:
+```
+
+The `is_hole` `__init__` kwarg is shorthand for
+
+    class IsHole(ContagionAttribute):
+        pass
+
+    vert = Vert()
+    vert.add_attrib(IsHole())
+
+The `face_instance.is_hole` property getter is shorthand for
+
+    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?
+
+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.
+
+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.
+
+    class Coordinate(IncompatibleAttribute[Tuple[float, float]]):
+        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__`
+
+    vert = Vert(Coordinate(1, 2))
+    assert vert.get_attrib(Coordinate).value == (1, 2)
+
+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).
+
+### 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
+
+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.
+
+This means that verts and faces disappear from a mesh when the edges referencing them are removed.
+
+Also means that this won't be useful for more than hundreds (maybe thousands) of edges. Good enough for my purposes.
+
+## Project Structure
+
+The HalfEdges class is defined across three modules:
+
+### half_edge_constructors.py
+
+class BlindHalfEdges defines the from_vlfi constructor and just enough methods to allow it to work. These methods define how pointers and Attrib instances are assigned.
+
+### half_edge_querries.py
+
+class StaticHalfEdges(BlindHalfEdges) defines all the look-up tricks of the halfedge data structure. What faces are adjacent to an edge? What edges radiate from a vert? etc.
+
+### half_edge_object.py
+
+class HalfEdges(StaticHalfEdges) defines all of the methods that change the structure of the mesh: insert_edge, collapse_edge, etc.

halfedge-0.2.0/README.md

@@ -0,0 +1,115 @@
+# A typical halfedges data structure with some padding
+
+## Use
+
+You will most likely want to create meshes with the `from_vlfi` constructor. It's got a few tricks, so be sure to read the docstring.
+
+```python
+from halfedges import HalfEdges, Vert
+
+vertices = [Vert() for _ in range(4)]
+face_indices: list[tuple[int, ...]] = [(0, 1, 2), (0, 2, 3)]
+
+mesh = HalfEdges.from_vlfi(vertices, face_indices)
+
+edge = next(iter(mesh.edges))
+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.
+
+### 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`.
+
+### id
+
+Each Vert, Edge, and Face instance has an `id` attribute. This is a unique, sequential identifier for the instance. Sorted vert, edge, and face lists (`HalfEdges.vl`, `HalfEdges.el`, `HalfEdges.fl`) are sorted by `id`. All Vert, Edge, and Face instances across all HalfEdges instances will share the id counter, so don't expect the id of your verts to start at 0.
+
+### Holes
+
+A triangle mesh in 2D will never be entirely triangular (and also manifold). There will be a boundary around the triangles. This library treats the outside of that boundary as a face (with an `is_hole == True` attribute). This way, every edge has a pair and a face, and the `is_hole` flags can be used to keep these hole faces out of your way.
+
+Holes are useful for more than just 2D mesh boundaries, you can explicitly create holes (`Face` instances with an as `is_hole == True` property) to maintain manifold mesh conditions in many circumstances. The constructor `HalfEdges.from_vlfi()` will try to insert hole faces to maintain manifold conditions.
+
+Four main types: Vert, Edge, Face, and HalfEdges. Vert and Face instances have `*.faces` properties which will return all adjacent faces. These properties will *not* return faces flagged as holes. The holes are there to keep things simple and manifold, but otherwise stay out of your way.
+
+```python
+Face(
+    *attributes: Attrib[Any],
+    mesh: BlindHalfEdges | None = None,
+    edge: Edge | None = None,
+    is_hole: bool = False,
+) -> None:
+```
+
+The `is_hole` `__init__` kwarg is shorthand for
+
+    class IsHole(ContagionAttribute):
+        pass
+
+    vert = Vert()
+    vert.add_attrib(IsHole())
+
+The `face_instance.is_hole` property getter is shorthand for
+
+    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?
+
+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.
+
+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.
+
+    class Coordinate(IncompatibleAttribute[Tuple[float, float]]):
+        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__`
+
+    vert = Vert(Coordinate(1, 2))
+    assert vert.get_attrib(Coordinate).value == (1, 2)
+
+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).
+
+### 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
+
+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.
+
+This means that verts and faces disappear from a mesh when the edges referencing them are removed.
+
+Also means that this won't be useful for more than hundreds (maybe thousands) of edges. Good enough for my purposes.
+
+## Project Structure
+
+The HalfEdges class is defined across three modules:
+
+### half_edge_constructors.py
+
+class BlindHalfEdges defines the from_vlfi constructor and just enough methods to allow it to work. These methods define how pointers and Attrib instances are assigned.
+
+### half_edge_querries.py
+
+class StaticHalfEdges(BlindHalfEdges) defines all the look-up tricks of the halfedge data structure. What faces are adjacent to an edge? What edges radiate from a vert? etc.
+
+### half_edge_object.py
+
+class HalfEdges(StaticHalfEdges) defines all of the methods that change the structure of the mesh: insert_edge, collapse_edge, etc.

halfedge-0.2.0/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = "halfedge"
+version = "0.2.0"
+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"
+dependencies = ["paragraphs"]
+
+[project.optional-dependencies]
+dev = [
+    "commitizen",
+    "coverage",
+    "pre-commit",
+    "pylint",
+    "pytest",
+    "tox"
+]
+
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "0.2.0"
+tag_format = "$version"
+major-version-zero = true
+version_files = ["pyproject.toml:^version"]
+
+
+[tool.isort]
+profile = "black"
+
+
+[tool.pytest.ini_options]
+# addopts = "--doctest-modules"
+pythonpath = ["tests"]
+log_cli = 1
+
+[tool.tox]
+legacy_tox_ini = """
+[tox]
+envlist = py{38,39,310,311,312}
+
+[testenv]
+deps = pytest
+commands = pytest
+"""
+
+
+[tool.pyright]
+include = ["src"]
+exclude = ["**/__pycache__.py"]
+
+pythonVersion = "3.8"
+pythonPlatform = "Any"
+
+typeCheckingMode = "strict"
+reportShadowedImports = true
+reportCallInDefaultInitializer = true
+reportImplicitStringConcatenation = true
+# reportMissingSuperCall = true
+reportPropertyTypeMismatch = true
+reportUninitializedInstanceVariable = true
+reportUnnecessaryTypeIgnoreComment = true
+reportUnusedCallResult = true
+
+venvPath = "."
+venv = "./venv"

halfedge-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

halfedge-0.2.0/src/halfedge/__init__.py

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