chalc 3.1.3__tar.gz → 4.0.0.dev1__tar.gz

{chalc-3.1.3 → chalc-4.0.0.dev1}/CMakeLists.txt

@@ -9,9 +9,9 @@ if (NOT DEFINED ENV{NO_USE_VCPKG})
         message(STATUS "CI build detected.")
         set(VCPKG_INSTALLATION_ROOT ${CMAKE_CURRENT_LIST_DIR}/vcpkg)
         message(STATUS "Setting VCPKG_INSTALLATION_ROOT to ${CMAKE_CURRENT_LIST_DIR}/vcpkg")
-    elseif (DEFINED ENV{VCPKG_INSTALLATION_ROOT})
-        set(VCPKG_INSTALLATION_ROOT $ENV{VCPKG_INSTALLATION_ROOT})
-        message(STATUS "VCPKG_INSTALLATION_ROOT is $ENV{VCPKG_INSTALLATION_ROOT}")
+    elseif (DEFINED ENV{VCPKG_ROOT})
+        set(VCPKG_INSTALLATION_ROOT $ENV{VCPKG_ROOT})
+        message(STATUS "VCPKG_INSTALLATION_ROOT is ${VCPKG_INSTALLATION_ROOT}")
     else()
         # get the vcpkg commit id from vcpkg.json
         file(READ ${CMAKE_CURRENT_LIST_DIR}/vcpkg.json VCPKG_JSON_STRING)

{chalc-3.1.3 → chalc-4.0.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chalc
-Version: 3.1.3
+Version: 4.0.0.dev1
 Summary: Persistent homology of chromatic Delaunay filtrations
 Keywords: topological data analysis,TDA,chromatic Delaunay,computational geometry,computational topology,persistent homology
 Author-Email: Abhinav Natarajan <natarajan@maths.ox.ac.uk>

chalc-4.0.0.dev1/build_docs.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+python -m pybind11_stubgen chalc.chromatic --numpy-array-use-type-var --output-dir src
+python -m pybind11_stubgen chalc.filtration --numpy-array-use-type-var --output-dir src
+sphinx-build -E -b html docs docs/_build

{chalc-3.1.3 → chalc-4.0.0.dev1}/docs/Makefile

@@ -12,9 +12,15 @@ BUILDDIR      = build
 help:
 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
 
-.PHONY: help Makefile
+stubs:
+	@echo "Generating stubs for chalc.chromatic"
+	@python -m pybind11_stubgen chalc.chromatic --numpy-array-use-type-var --output-dir ../src
+	@echo "Generating stubs for chalc.filtration"
+	@python -m pybind11_stubgen chalc.filtration --numpy-array-use-type-var --output-dir ../src
+
+.PHONY: help Makefile stubs
 
 # Catch-all target: route all unknown targets to Sphinx using the new
 # "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
+%: Makefile stubs
 	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

chalc-4.0.0.dev1/docs/README.md

@@ -0,0 +1,11 @@
+# Chalc Documentation Source Directory
+
+To build the documentation, first make sure that ``chalc`` is installed and available to the Python interpreter. Then run the following commands from the root directory of the repository.
+
+```bash
+pip install -r requirements.txt
+make html
+```
+
+This will build the documentation into the folder ``docs/build`` with root ``index.html``.
+In order to avoid polluting your global Python package tree, it is a good idea to install ``chalc`` and run the ``pip install ..`` command above in a virtual environment.

chalc-4.0.0.dev1/docs/requirements.txt

@@ -0,0 +1,15 @@
+# Dependencies for the documentation build
+pybind11-stubgen ~= 2.5.1 # generate stubs from binary modules
+sphinx ~= 8.0.0 # documentation generator
+sphinx-autoapi ~= 3.3.1 # automatically generate the API documentation
+furo ~= 2024.8.6 # sphinx theme
+nbsphinx ~= 0.9.3 # support for jupyter notebooks
+sphinx_design ~= 0.6.0 # for the grid layout in the installation page
+sphinx_toolbox ~= 3.5.0 # sidebar and github links
+
+# Dependencies to run the example notebook
+numpy ~= 2.0.0
+matplotlib ~= 3.8.4
+IPython ~= 8.15.0
+ipykernel ~= 6.25.2
+ipympl ~= 0.9.3

chalc-4.0.0.dev1/docs/source/API.rst

@@ -0,0 +1,7 @@
+API Reference
+=============
+
+.. toctree::
+   :name: api
+
+   autoapi/chalc/index

chalc-4.0.0.dev1/docs/source/conf.py

@@ -0,0 +1,101 @@
+import os
+from pathlib import Path
+
+from packaging.version import parse
+
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here.
+docs_path = list(Path(__file__).parents)[1]
+project_root_dir = docs_path.parent
+
+copyright = "2023, Abhinav Natarajan"
+author = "Abhinav Natarajan"
+
+# Get the name and release from pyproject.toml
+from tomllib import loads
+
+with open(project_root_dir / "pyproject.toml") as f:
+	proj_props = loads(f.read())["project"]
+
+project = proj_props["name"]
+release = ".".join(map(str, parse(proj_props["version"]).release))
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+maximum_signature_line_length = 160
+toc_object_entries_show_parents = "hide"
+add_module_names = False
+master_doc = "index"
+# templates_path = ['templates']
+exclude_patterns = [
+	"_build",
+	"templates",
+	"exts",
+	"static",
+	# "example.ipynb",
+]
+
+extensions = [
+	"sphinx.ext.autosectionlabel",
+	"sphinx.ext.napoleon",
+	"autoapi.extension",
+	"sphinx.ext.intersphinx",
+	"nbsphinx",
+	"sphinx_design",
+	"sphinx_toolbox.sidebar_links",
+	"sphinx_toolbox.github",
+	"sphinx.ext.githubpages",
+]
+
+# autosectionlabel options
+autosectionlabel_prefix_document = True
+
+# napoleon options
+napolean_include_init_with_doc = True
+napoleon_attr_annotations = True
+
+# autoapi options
+autoapi_dirs = ["../../src"]
+autoapi_options = [
+	"members",
+	"show-module-summary",
+]
+
+# intersphinx options
+intersphinx_mapping = {
+	"python": ("https://docs.python.org/3/", None),
+	"numpy": ("https://numpy.org/doc/stable", None),
+	"matplotlib": ("https://matplotlib.org/stable", None),
+	"h5py": ("https://docs.h5py.org/en/stable/", None),
+}
+
+# nbsphinx options
+nbsphinx_execute = "always"
+os.environ["PYDEVD_DISABLE_FILE_VALIDATION"] = "1"
+
+# toolbox.github options
+github_username = "abhinavnatarajan"
+github_repository = "chalc"
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_static_path = ["../static"]
+html_css_files = ["css/custom.css"]
+
+html_theme = "furo"
+html_theme_options = {
+	"source_repository": "https://github.com/abhinavnatarajan/chalc",
+	"source_branch": "master",
+	"source_directory": "docs/",
+	"top_of_page_button": "edit",
+}

{chalc-3.1.3/docs → chalc-4.0.0.dev1/docs/source}/example.ipynb

@@ -19132,8 +19132,8 @@
     "# using the previously computed filtration\n",
     "dgms_alpha = ch.sixpack.from_filtration(K, dom=[0])\n",
     "# or directly from the point cloud\n",
-    "dgms_delcech = ch.sixpack.compute(points, colours, dom=[0], method=\"chromatic delcech\")\n",
-    "dgms_delrips = ch.sixpack.compute(points, colours, dom=[0], method=\"chromatic delrips\")"
+    "dgms_delcech = ch.sixpack.compute(points, colours, dom=[0], method=\"delcech\")\n",
+    "dgms_delrips = ch.sixpack.compute(points, colours, dom=[0], method=\"delrips\")"
    ]
   },
   {

{chalc-3.1.3/docs → chalc-4.0.0.dev1/docs/source}/index.rst

@@ -20,13 +20,12 @@ Documentation index
    installation
    example
    API
+   license
 
 .. sidebar-links::
    :github:
    :pypi: chalc
 
-   license
-
 Citing this Software
 --------------------
 If you want to use chalc in your work, please use the following citation:

{chalc-3.1.3/docs → chalc-4.0.0.dev1/docs/source}/installation.rst

@@ -43,7 +43,7 @@ Clone the git repository.
    $ git clone https://github.com/abhinavnatarajan/chalc
    $ cd chalc
 
-If you have vcpkg installed on your system, make sure that the environment variable ``VCPKG_INSTALLATION_ROOT`` is set and points to the base directory where vcpkg is installed.
+If you have vcpkg installed on your system, make sure that the environment variable ``VCPKG_ROOT`` is set and points to the base directory where vcpkg is installed.
 
 .. tab-set::
 
@@ -52,14 +52,14 @@ If you have vcpkg installed on your system, make sure that the environment varia
 
       .. code-block:: bash
 
-         $ export VCPKG_INSTALLATION_ROOT=/path/to/vcpkg/dir
+         $ export VCPKG_ROOT=/path/to/vcpkg/dir
 
    .. tab-item:: Powershell
       :sync: powershell
 
       .. code-block:: powershell
 
-         > $Env:VCPKG_INSTALLATION_ROOT = 'C:\path\to\vcpkg\dir'
+         > $Env:VCPKG_ROOT = 'C:\path\to\vcpkg\dir'
 
 If you do not have vcpkg installed, the build process will automatically download vcpkg into a temporary directory and fetch the required dependencies.
 
@@ -88,3 +88,17 @@ Build the package wheel using ``pip wheel`` and install the compiled binary.
 
    $ pip wheel . -w outputdir
    $ pip install outputdir/<name_of_generated_wheel>.whl
+
+Building the Documentation
+--------------------------
+
+To build the documentation, first make sure that ``chalc`` is installed and available to the Python interpreter. Then run the following commands from the root directory of the repository.
+
+.. code-block:: console
+
+   $ cd docs
+   $ pip install -r requirements.txt
+   $ make html
+
+This will build the documentation into the folder ``docs/build`` with root ``index.html``.
+In order to avoid polluting your global Python package tree, it is a good idea to install ``chalc`` and run the ``pip install ..`` command above in a virtual environment.

{chalc-3.1.3 → chalc-4.0.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "chalc"
-version = "3.1.3"
+version = "4.0.0-dev1"
 authors = [{ name = "Abhinav Natarajan", email = "natarajan@maths.ox.ac.uk" }]
 description = "Persistent homology of chromatic Delaunay filtrations"
 readme = { file = "README.md", content-type = "text/markdown" }
@@ -57,7 +57,7 @@ experimental = true
 archs = ["auto64"]
 skip = ["pp*", "*-musllinux_*"]
 test-command = "pytest {package}/tests"
-test-requires = ["pytest==8.2.2"]
+test-requires = ["pytest~=8.2.2"]
 build-verbosity = 2
 
 [tool.cibuildwheel.linux]

chalc-4.0.0.dev1/src/chalc/__init__.py

@@ -0,0 +1,28 @@
+"""
+Chalc is a package to compute the persistent homology of chromatic complexes of points clouds in Euclidean space.
+"""
+
+from __future__ import annotations
+
+import platform
+
+from . import filtration
+
+if platform.system() == "Windows":
+	# need to load up the GMP and MPFR DLLs
+	import os as _os
+	from importlib.metadata import files as _files
+
+	_bindir = (
+		[x for x in _files("chalc") if len(x.parent.parts) > 0 and x.parent.parts[-1] == "bin"][0]
+		.locate()
+		.parent
+	)
+	with _os.add_dll_directory(_bindir):
+		from . import chromatic
+else:
+	from . import chromatic
+
+from . import plotting, sixpack
+
+__all__ = ["chromatic", "filtration", "sixpack", "plotting"]

{chalc-3.1.3 → chalc-4.0.0.dev1}/src/chalc/chromatic.pyi

@@ -1,22 +1,20 @@
 """
 
 Module containing geometry routines to compute chromatic Delaunay filtrations.
-
-Attributes:
-	MaxColoursChromatic (int): Maximum number of colours that can be handled by the methods in this module.
         
 """
 from __future__ import annotations
 import chalc.filtration
 import numpy
-import pybind11_stubgen.typing_ext
 import typing
 __all__ = ['MaxColoursChromatic', 'alpha', 'delaunay', 'delcech', 'delrips']
+M = typing.TypeVar("M", bound=int)
+N = typing.TypeVar("N", bound=int)
 @typing.overload
-def alpha(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.DynamicSize('m', 'n')], colours: typing.Annotated[numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.DynamicSize('m', 1)]) -> tuple[chalc.filtration.FilteredComplex, bool]:
+def alpha(x: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], colours: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.int32]]) -> tuple[chalc.filtration.FilteredComplex, bool]:
     ...
 @typing.overload
-def alpha(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.DynamicSize('m', 'n')], colours: list[int]) -> tuple[chalc.filtration.FilteredComplex, bool]:
+def alpha(x: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], colours: list[int]) -> tuple[chalc.filtration.FilteredComplex, bool]:
     """
     Computes the chromatic alpha filtration of a coloured point cloud.
     
@@ -37,10 +35,10 @@ def alpha(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typ
     	:func:`delrips`, :func:`delcech`
     """
 @typing.overload
-def delaunay(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.DynamicSize('m', 'n')], colours: typing.Annotated[numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.DynamicSize('m', 1)]) -> chalc.filtration.FilteredComplex:
+def delaunay(x: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], colours: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.int32]]) -> chalc.filtration.FilteredComplex:
     ...
 @typing.overload
-def delaunay(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.DynamicSize('m', 'n')], colours: list[int]) -> chalc.filtration.FilteredComplex:
+def delaunay(x: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], colours: list[int]) -> chalc.filtration.FilteredComplex:
     """
     Returns the chromatic Delaunay triangulation of a coloured point cloud in Euclidean space.
     
@@ -55,10 +53,10 @@ def delaunay(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.
     	The Delaunay triangulation.
     """
 @typing.overload
-def delcech(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.DynamicSize('m', 'n')], colours: typing.Annotated[numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.DynamicSize('m', 1)]) -> tuple[chalc.filtration.FilteredComplex, bool]:
+def delcech(x: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], colours: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.int32]]) -> tuple[chalc.filtration.FilteredComplex, bool]:
     ...
 @typing.overload
-def delcech(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.DynamicSize('m', 'n')], colours: list[int]) -> tuple[chalc.filtration.FilteredComplex, bool]:
+def delcech(x: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], colours: list[int]) -> tuple[chalc.filtration.FilteredComplex, bool]:
     """
     Returns the chromatic Delaunay--Čech filtration of a coloured point cloud.
     
@@ -79,10 +77,10 @@ def delcech(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.t
     	:func:`alpha`, :func:`delrips`
     """
 @typing.overload
-def delrips(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.DynamicSize('m', 'n')], colours: typing.Annotated[numpy.ndarray, numpy.int32, pybind11_stubgen.typing_ext.DynamicSize('m', 1)]) -> tuple[chalc.filtration.FilteredComplex, bool]:
+def delrips(x: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], colours: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.int32]]) -> tuple[chalc.filtration.FilteredComplex, bool]:
     ...
 @typing.overload
-def delrips(x: typing.Annotated[numpy.ndarray, numpy.float64, pybind11_stubgen.typing_ext.DynamicSize('m', 'n')], colours: list[int]) -> tuple[chalc.filtration.FilteredComplex, bool]:
+def delrips(x: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], colours: list[int]) -> tuple[chalc.filtration.FilteredComplex, bool]:
     """
     Computes the chromatic Delaunay--Rips filtration of a coloured point cloud.
     

{chalc-3.1.3 → chalc-4.0.0.dev1}/src/chalc/chromatic_py.cxx

@@ -13,9 +13,6 @@ PYBIND11_MODULE(chromatic, m) {
 	m.doc() =
 		R"docstring(
 Module containing geometry routines to compute chromatic Delaunay filtrations.
-
-Attributes:
-	MaxColoursChromatic (int): Maximum number of colours that can be handled by the methods in this module.
         )docstring";
 	m.attr("MaxColoursChromatic") = py::int_(MAX_NUM_COLOURS);
 	m.def(

{chalc-3.1.3 → chalc-4.0.0.dev1}/src/chalc/filtration.pyi

@@ -68,12 +68,12 @@ class FilteredComplex:
         				Serialised representation of the simplicial complex in a format suitable for persistent homology computations.
         
         				:return:
-        					A list `x` of simplices in the simplicial complex ordered by dimension followed by filtration time. Each simplex :math:`\sigma` is represented by a tuple containing the following items.
+        					A list `x` of simplices in the simplicial complex ordered by dimension followed by filtration time. Each simplex :math:`\\sigma` is represented by a tuple containing the following items.
         
-        					1.  A list containing the indices in `x` of the facets of :math:`\sigma`, sorted in ascending order.
-        					2.  The lexicographic key of :math:`\sigma` in the simplicial complex.
-        					3.  The filtration time of :math:`\sigma`.
-        					4.  The colour bitmask of :math:`\sigma`.
+        					1.  A list containing the indices in `x` of the facets of :math:`\\sigma`, sorted in ascending order.
+        					2.  The lexicographic key of :math:`\\sigma` in the simplicial complex.
+        					3.  The filtration time of :math:`\\sigma`.
+        					4.  The colour bitmask of :math:`\\sigma`.
         """
     @property
     def dimension(self) -> int:
@@ -83,7 +83,7 @@ class FilteredComplex:
     @property
     def max_dimension(self) -> int:
         """
-        Maximum dimension of simplex that this complex can store. \
+        Maximum dimension of simplex that this complex can store. \\
         Set during initialisation.
         """
     @property
@@ -99,7 +99,7 @@ class FilteredComplex:
     @property
     def num_vertices(self) -> int:
         """
-        Number of vertices in the simplicial complex. \
+        Number of vertices in the simplicial complex. \\
         Set during initialisation.
         """
     @property
@@ -128,7 +128,7 @@ class Simplex:
     @property
     def colours(self) -> int:
         """
-        				Bitmask of colours in the simplex, where the rightmost bit represents the smallest colour index. More precisely, :math:`\mathrm{bitmask} = \sum_{c \in \mathrm{colours}(\sigma)} 2^c`. For example, a simplex having vertices of colours 0 and 1 has a colour bitmask of 3.
+        				Bitmask of colours in the simplex, where the rightmost bit represents the smallest colour index. More precisely, :math:`\\mathrm{bitmask} = \\sum_{c \\in \\mathrm{colours}(\\sigma)} 2^c`. For example, a simplex having vertices of colours 0 and 1 has a colour bitmask of 3.
         """
     @property
     def dimension(self) -> int:
@@ -151,7 +151,7 @@ class Simplex:
     @property
     def label(self) -> int:
         """
-        				Label of the simplex in its parent filtered complex. A :math:`k`-simplex :math:`\sigma` is labelled by the lexicographic index of :math:`\sigma` with respect to its vertex labels sorted in ascending order, counting all possible sorted subsequences of :math:`(0, ..., N-1)` of length :math:`k`.
+        				Label of the simplex in its parent filtered complex. A :math:`k`-simplex :math:`\\sigma` is labelled by the lexicographic index of :math:`\\sigma` with respect to its vertex labels sorted in ascending order, counting all possible sorted subsequences of :math:`(0, ..., N-1)` of length :math:`k`.
         """
     @property
     def vertices(self) -> list[int]:

{chalc-3.1.3 → chalc-4.0.0.dev1}/src/chalc/plotting.py

@@ -1,8 +1,10 @@
+"""Plotting and visualisation utilities."""
+
 from __future__ import annotations
 
 from collections.abc import Collection, Sequence
 from itertools import product
-from typing import Annotated
+from typing import Literal
 
 import matplotlib.animation as animation
 import matplotlib.pyplot as plt
@@ -14,7 +16,6 @@ from pandas import DataFrame
 
 from chalc.filtration import FilteredComplex
 
-from ._utils import interpolate_docstring
 from .sixpack import (
 	DiagramEnsemble,
 	_bitmask_to_colours,
@@ -25,15 +26,13 @@ from .sixpack import (
 
 plt.rcParams["animation.html"] = "jshtml"
 
-__doc__ = "Plotting and visualisation utilities."
-
 
 def plot_sixpack(
 	dgms: DiagramEnsemble,
 	truncation: float | None = None,
 	max_diagram_dimension: int | None = None,
 	tolerance: float = 0,
-) -> tuple[Figure, Annotated[np.ndarray, "Axes"]]:
+) -> tuple[Figure, np.ndarray[tuple[int, ...], np.dtype[Axes]]]:
 	"""
 	Plots the 6-pack of persistence diagrams returned by :func:`compute <.sixpack.compute>`.
 
@@ -100,10 +99,9 @@ def plot_sixpack(
 	return fig, axes
 
 
-@interpolate_docstring()
 def plot_diagram(
 	dgms: DiagramEnsemble,
-	diagram_name: str,
+	diagram_name: Literal["ker", "cok", "dom", "cod", "im", "rel"],
 	truncation: float | None = None,
 	max_diagram_dimension: int | None = None,
 	ax: Axes | None = None,
@@ -114,7 +112,7 @@ def plot_diagram(
 
 	Args:
 		dgms                  : The 6-pack of persistence diagrams.
-		diagram_name          : One of ``${str(DiagramEnsemble.diagram_names)}``.
+		diagram_name          : One of ``'ker'``, ``'cok'``, ``'dom'``, ``'cod'``, ``'im'``, or ``'rel'``.
 		truncation            : The maximum entrance time for which the diagrams are plotted. A sensible default will be calculated if not provided.
 		max_diagram_dimension : The maximum homological dimension for which to plot points. If not provided, all dimensions will be included in the plots.
 		ax                    : A matplotlib axes object. If provided then the diagram will be plotted on the given axes.
@@ -223,16 +221,16 @@ def _plot_diagram(
 
 def draw_filtration(
 	K: FilteredComplex,
-	points: Annotated[np.ndarray, np.float64],
+	points: np.ndarray[tuple[Literal[2], int], np.dtype[np.float64]],
 	time: float,
 	include_colours: Collection[int] | None = None,
 	ax: Axes | None = None,
 ) -> Axes:
 	"""
-	Visualise a filtration at given time, optionally including only certain colours.
+	Visualise a 2D filtration at given time, optionally including only certain colours.
 
 	Args:
-		K               : A filtered complex.
+		K               : A filtered 2-dimensional simplicial complex.
 		points          : The vertices of ``K`` as a :math:`2\\times N` numpy matrix.
 		time            : Filtration times for which to draw simplices.
 		include_colours : Optional collection of colours to include. If not specified then all colours will be drawn.
@@ -313,7 +311,7 @@ def draw_filtration(
 
 def animate_filtration(
 	K: FilteredComplex,
-	points: Annotated[np.ndarray, np.float64],
+	points: np.ndarray[tuple[Literal[2], int], np.dtype[np.float64]],
 	filtration_times: Sequence[float],
 	animation_length: float,
 ) -> animation.FuncAnimation:

{chalc-3.1.3 → chalc-4.0.0.dev1}/src/chalc/sixpack.py

@@ -1,8 +1,10 @@
+"""Routines for computing 6-packs of persistence diagrams."""
+
 from __future__ import annotations
 
 from collections.abc import Collection, Sequence
 from dataclasses import dataclass, field, fields
-from typing import Annotated, Callable, ClassVar, overload
+from typing import Callable, ClassVar, Literal, overload
 
 import numpy as np
 from h5py import Dataset, Group
@@ -11,9 +13,6 @@ from phimaker import compute_ensemble
 from chalc.chromatic import alpha, delcech, delrips
 from chalc.filtration import FilteredComplex
 
-from ._utils import interpolate_docstring
-
-__doc__ = "Routines for computing 6-packs of persistence diagrams."
 __all__ = [
 	"from_filtration",
 	"compute",
@@ -24,9 +23,9 @@ __all__ = [
 ]
 
 ChromaticMethod = {
-	"chromatic alpha": alpha,
-	"chromatic delcech": delcech,
-	"chromatic delrips": delrips,
+	"alpha": alpha,
+	"delcech": delcech,
+	"delrips": delrips,
 }
 
 BdMatType = list[tuple[bool, int, list[int]]]
@@ -92,7 +91,6 @@ def _get_diagrams(
 	return dgms.threshold(tolerance)
 
 
-@interpolate_docstring()
 def from_filtration(
 	K: FilteredComplex,
 	dom: Collection[int] | int | None = None,
@@ -155,13 +153,12 @@ def from_filtration(
 	return _get_diagrams(K, check_in_domain, max_diagram_dimension, tolerance)
 
 
-@interpolate_docstring()
 def compute(
-	x: Annotated[np.ndarray, np.float64],
+	x: np.ndarray[tuple[int, int], np.dtype[np.float64]],
 	colours: Sequence[int],
 	dom: Collection[int] | int | None = None,
 	k: int | None = None,
-	method: str = "chromatic alpha",
+	method: Literal["alpha", "delcech", "delrips"] = "alpha",
 	max_diagram_dimension: int | None = None,
 	tolerance: float = 0,
 ) -> DiagramEnsemble:
@@ -175,7 +172,7 @@ def compute(
 		colours               : Sequence of integers describing the colours of the points.
 		dom                   : Integer or collection of integers describing the colours of the points in the domain (the subcomplex :math:`L`).
 		k                     : If not ``None``, then the domain is taken to be the :math:`k`-chromatic subcomplex of :math:`K`, i.e., the subcomplex of simplices having at most :math:`k` colours.
-		method                : Filtration used to construct the chromatic complex. Must be one of ``${str(list(ChromaticMethod.keys()))}``.
+		method                : Filtration used to construct the chromatic complex. Must be one of ``'alpha'``, ``'delcech'``, or ``'delrips'``.
 		max_diagram_dimension : Maximum homological dimension for which the persistence diagrams are computed. By default diagrams of all dimensions are computed.
 		tolerance             : Retain only points with persistence strictly greater than this value.
 
@@ -248,7 +245,9 @@ class SimplexPairings:
 
 	@classmethod
 	def _from_matrices(
-		cls, p: Annotated[np.ndarray, np.int64], u: Annotated[np.ndarray, np.int64]
+		cls,
+		p: np.ndarray[tuple[int, int], np.dtype[np.int64]],
+		u: np.ndarray[tuple[int, int], np.dtype[np.int64]],
 	) -> SimplexPairings:
 		if p.shape[1] != 2:
 			raise ValueError(f"p must be a (m, 2) matrix, but received a matrix of size {p.shape}")
@@ -256,7 +255,7 @@ class SimplexPairings:
 		unpaired = list(u)
 		return cls(paired, unpaired)
 
-	def paired_as_matrix(self) -> Annotated[np.ndarray, np.int64]:
+	def paired_as_matrix(self) -> np.ndarray[tuple[int, int], np.dtype[np.int64]]:
 		return np.concatenate(list(self.paired)).reshape((-1, 2))
 
 	def __eq__(self, other) -> bool:
@@ -315,20 +314,23 @@ class DiagramEnsemble:
 		return self
 
 	@overload
-	def get(self, diagram_name: str, dim: int) -> Annotated[np.ndarray, np.float64]: ...
+	def get(
+		self, diagram_name: Literal["ker", "cok", "dom", "cod", "im", "rel"], dim: int
+	) -> np.ndarray[tuple[int, int], np.dtype[np.float64]]: ...
 
 	@overload
 	def get(
-		self, diagram_name: str, dim: list[int] | None = None
-	) -> list[Annotated[np.ndarray, np.float64]]: ...
+		self,
+		diagram_name: Literal["ker", "cok", "dom", "cod", "im", "rel"],
+		dim: list[int] | None = None,
+	) -> list[np.ndarray[tuple[int, int], np.dtype[np.float64]]]: ...
 
-	@interpolate_docstring({"diagram_names": diagram_names})
 	def get(self, diagram_name, dim=None):
 		"""
 		Get a specific diagram as a matrix of birth and death times.
 
 		Args:
-			diagram_name : One of ``${str(diagram_names)}``.
+			diagram_name : One of ``'ker'``, ``'cok'``, ``'dom'``, ``'cod'``, ``'im'``, or ``'rel'``.
 			dim          : Dimension(s) of the diagram desired. If a list is provided then a list of matrices is returned, with the order of matrices respecting the order of entries of `dim`. If `dim` is not provided then the returned matrix will contain persistent features from all homological dimensions from zero to ``max(self.dimensions)``.
 
 		Returns:

chalc-3.1.3/build_docs.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-
-# python docs/stubgen.py chalc --output-dir docs/stubs
-source build_stubs.sh
-shopt -s extglob
-mkdir -p docs/stubs/chalc/
-cp -rf src/chalc/!(__init__)*.py?(i) docs/stubs/chalc/
-for f in docs/stubs/chalc/*.pyi; do mv -- "$f" "${f%.pyi}.py"; done
-sphinx-build -E -b html docs docs/_build

chalc-3.1.3/build_stubs.sh

@@ -1,4 +0,0 @@
-#!/bin/bash
-
-python -m pybind11_stubgen chalc.chromatic --numpy-array-wrap-with-annotated --output-dir src
-python -m pybind11_stubgen chalc.filtration --numpy-array-wrap-with-annotated --output-dir src