pyafv 0.3.3__cp312-cp312-win_arm64.whl → 0.3.6__cp312-cp312-win_arm64.whl

pyafv/{finite_voronoi_fast.py → finite_voronoi.py}

@@ -12,16 +12,19 @@ Key public entry points:
 - update_params(): update physical parameters.
 """
 
-from typing import Dict, List, Tuple, Optional
-import numpy as np
-from scipy.spatial import Voronoi
-from matplotlib import pyplot as plt
-from matplotlib.axes import Axes
+# Enable postponed evaluation of annotations
+from __future__ import annotations
 
-from .physical_params import PhysicalParams
+# Only import typing modules when type checking, e.g., in VS Code or IDEs.
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:                             # pragma: no cover
+    from scipy.spatial import Voronoi
+    import matplotlib.axes
+    import numpy
+    import typing
 
-from .cell_geom import build_vertexpair_and_vertexpoints_cy
-from .cell_geom import pad_regions_cy, build_point_edges_cy, compute_vertex_derivatives_cy
+import numpy as np
+from .physical_params import PhysicalParams
 
 
 # ---- tiny helpers to avoid tiny allocations in hot loops ----
@@ -31,18 +34,86 @@ def _row_dot(a: np.ndarray, b: np.ndarray) -> np.ndarray:
 
 
 class FiniteVoronoiSimulator:
-    def __init__(self, pts: np.ndarray, phys: PhysicalParams):
+    """Simulator for the active-finite-Voronoi (AFV) model.
+
+    This class provides an interface to simulate the finite Voronoi model.
+    It wraps around the two backend implementations, which may be
+    either a Cython-accelerated version or a pure Python fallback.
+
+    Args:
+        pts: (N,2) array of initial cell center positions.
+        phys: Physical parameters used within this simulator.
+        backend: Optional, specify "python" to force the use of the pure Python fallback implementation.
+
+    Raises:
+        ValueError: If *pts* does not have shape (N,2).
+        TypeError: If *phys* is not an instance of PhysicalParams.
+    """
+
+    def __init__(self, pts: numpy.ndarray, phys: PhysicalParams, backend: typing.Literal["cython", "python"] | None = None):
+        """
+        Constructor of the simulator.
+        """
+        from .backend import backend_impl, _BACKEND_NAME
+        from scipy.spatial import Voronoi
+        self._voronoi = Voronoi
+        
+        pts = np.asarray(pts, dtype=float)
+        if pts.ndim != 2 or pts.shape[1] != 2:
+            raise ValueError("pts must have shape (N,2)")
+        if not isinstance(phys, PhysicalParams):
+            raise TypeError("phys must be an instance of PhysicalParams")
+        
         self.pts = pts.copy()            # (N,2) array of initial points
         self.N = pts.shape[0]            # Number of points
         self.phys = phys
+        self._preferred_areas = np.full(self.N, phys.A0, dtype=float)    # (N,) preferred areas A0
+        
+        if backend != "python":
+            self._BACKEND = _BACKEND_NAME
+            self._impl = backend_impl
+
+            if self._BACKEND not in {"cython", "numba"}:                 # pragma: no cover
+                # raise warning to inform user about fallback
+                import warnings
+                warnings.warn(
+                    "Could not import the Cython-built extension module. "
+                    "Falling back to the pure Python implementation, which may be slower. "
+                    "To enable the accelerated version, ensure that all dependencies are installed.",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+        else:  # force the use of the pure Python fallback implementation.
+            self._BACKEND = "python"
+            from . import cell_geom_fallback as _impl
+            self._impl = _impl
 
     # --------------------- Voronoi construction & extension ---------------------
-    def _build_voronoi_with_extensions(self) -> Tuple[Voronoi, np.ndarray, List[List[int]], int, Dict[Tuple[int,int], int], Dict[int, List[int]]]:
+    def _build_voronoi_with_extensions(self) -> tuple[Voronoi, np.ndarray, list[list[int]], int, dict[tuple[int,int], int], dict[int, list[int]]]:
         """
-        Build SciPy Voronoi for current points. For N<=2, emulate regions.
-        For N>=3, extend infinite ridges by adding long rays and update
-        regions accordingly. Return augmented structures.
+        Build standard Voronoi structure for current points.
+
+        For N<=2, emulate regions.
+        For N>=3, extend infinite ridges, add extension vertices, and update
+        regions accordingly. Return the augmented structures.
+        
+        .. warning::
+            
+            This is an internal method. Use with caution.
+
+        Returns: 
+            tuple[scipy.spatial.Voronoi, numpy.ndarray, list[list[int]], int, dict[tuple[int,int], int], dict[int, list[int]]] : A tuple containing:
+            
+                - **vor**: SciPy Voronoi object for current points with extensions.
+                - **vertices_all**: (M,2) array of all Voronoi vertices including extensions.
+                - **ridge_vertices_all**: list of lists of vertex indices for each ridge, including extensions.
+                - **num_vertices**: Number of Voronoi vertices before adding extension.
+                - **vertexpair2ridge**: dict mapping vertex index pairs to ridge index.
+                - **vertex_points**: dict mapping vertex index to list of associated point indices.
         """
+
+        Voronoi = self._voronoi
+
         r = self.phys.r
         pts = self.pts
         N = self.N
@@ -189,24 +260,53 @@ class FiniteVoronoiSimulator:
             # number of native (finite) vertices
             num_vertices = len(vor.vertices)
 
-        # Build vertexpair2ridge and vertex_points using Cython function
-        vertexpair2ridge, vertex_points = build_vertexpair_and_vertexpoints_cy(ridge_vertices_all, vor.ridge_points, num_vertices, N)
+        # Build vertexpair2ridge and vertex_points using Cython/Python backend function
+        vertexpair2ridge, vertex_points = self._impl.build_vertexpair_and_vertexpoints(ridge_vertices_all, vor.ridge_points, num_vertices, N)
 
         return vor, vertices_all, ridge_vertices_all, num_vertices, vertexpair2ridge, vertex_points
 
     # --------------------- Geometry & energy contributions per cell ---------------------
-    def _per_cell_geometry(self, vor: Voronoi, vertices_all: np.ndarray, ridge_vertices_all: np.ndarray, num_vertices: int, vertexpair2ridge: Dict[Tuple[int, int], int]) -> Dict:
+    def _per_cell_geometry(self, vor: Voronoi, vertices_all: np.ndarray, ridge_vertices_all: np.ndarray, num_vertices: int, vertexpair2ridge: dict[tuple[int, int], int]) -> dict[str,object]:
         """
-        Iterate cells to:
+        Build the finite-Voronoi per-cell geometry and energy contributions.
+
+        Iterate each cell to:
           - sort polygon/arc vertices around each cell
           - classify edges (1 = straight Voronoi edge; 0 = circular arc)
           - compute area/perimeter for each cell
           - accumulate derivatives w.r.t. vertices (dA_poly/dh, dP_poly/dh)
-          - register 'outer' vertices created at arc intersections and track their point pairs
+          - register "outer" vertices created at arc intersections and track their point pairs
+
+        .. warning::
+            This is an internal method. Use with caution.
+
+        Args:
+            vor: SciPy Voronoi object for current points with extensions.
+            vertices_all: (M,2) array of all Voronoi vertices including extensions.
+            ridge_vertices_all: list of lists of vertex indices for each ridge, including extensions.
+            num_vertices: Number of Voronoi vertices before adding extension.
+            vertexpair2ridge: dict mapping vertex index pairs to ridge index.
+        
+        Returns:
+            dict[str, object]: A diagnostics dictionary containing:
+
+                - **vertex_in_id**: set of inner vertex ids.
+                - **vertex_out_id**: set of outer vertex ids.
+                - **vertices_out**: (L,2) array of outer vertex coordinates.
+                - **vertex_out_points**: (L,2) array of point index pairs associated with each outer vertex.
+                - **vertex_out_da_dtheta**: array of dA/dtheta for all outer vertices.
+                - **vertex_out_dl_dtheta**: array of dL/dtheta for all outer vertices.
+                - **dA_poly_dh**: array of dA_polygon/dh for each vertex.
+                - **dP_poly_dh**: array of dP_polygon/dh for each vertex.
+                - **area_list**: array of polygon areas for each cell.
+                - **perimeter_list**: array of polygon perimeters for each cell.
+                - **point_edges_type**: list of lists of edge types per cell.
+                - **point_vertices_f_idx**: list of lists of vertex ids per cell.
+                - **num_vertices_ext**: number of vertices including infinite extension vertices.
         """
         N = self.N
         r = self.phys.r
-        A0 = self.phys.A0
+        A0_list = self._preferred_areas
         P0 = self.phys.P0
         pts = self.pts
 
@@ -337,10 +437,10 @@ class FiniteVoronoiSimulator:
         vertices_all = np.vstack([vertices_all, vertices_out])
 
         # --------------------------------------------------
-        # Part 1 in Cython
+        # Part 1 in Cython/Python backend
         # --------------------------------------------------
-        vor_regions = pad_regions_cy(vor.regions)            # (R, Kmax) int64 with -1 padding
-        point_edges_type, point_vertices_f_idx = build_point_edges_cy(
+        vor_regions = self._impl.pad_regions(vor.regions)            # (R, Kmax) int64 with -1 padding
+        point_edges_type, point_vertices_f_idx = self._impl.build_point_edges(
             vor_regions, vor.point_region.astype(np.int64),
             vertices_all.astype(np.float64), pts.astype(np.float64),
             int(num_vertices), vertexpair2ridge, 
@@ -349,15 +449,15 @@ class FiniteVoronoiSimulator:
         )
 
         # --------------------------------------------------
-        # Part 2 in Cython
+        # Part 2 in Cython/Python backend
         # --------------------------------------------------
-        vertex_out_da_dtheta, vertex_out_dl_dtheta, dA_poly_dh, dP_poly_dh, area_list, perimeter_list = compute_vertex_derivatives_cy(
+        vertex_out_da_dtheta, vertex_out_dl_dtheta, dA_poly_dh, dP_poly_dh, area_list, perimeter_list = self._impl.compute_vertex_derivatives(
             point_edges_type,            # list-of-lists / arrays of edge types
             point_vertices_f_idx,        # list-of-lists / arrays of vertex ids
             vertices_all.astype(np.float64, copy=False),
             pts.astype(np.float64, copy=False),
             float(r),
-            float(A0),
+            A0_list.astype(np.float64, copy=False),
             float(P0),
             int(num_vertices_ext),
             int(num_ridges),
@@ -383,8 +483,8 @@ class FiniteVoronoiSimulator:
 
     # --------------------- Force assembly ---------------------
     def _assemble_forces(self, vertices_all: np.ndarray, num_vertices_ext: int,
-                         vertex_points: Dict[int, List[int]], vertex_in_id: List[int], vertex_out_id: List[int],
-                         vertex_out_points: List[List[int]], vertex_out_da_dtheta: np.ndarray,
+                         vertex_points: dict[int, list[int]], vertex_in_id: list[int], vertex_out_id: list[int],
+                         vertex_out_points: list[list[int]], vertex_out_da_dtheta: np.ndarray,
                          vertex_out_dl_dtheta: np.ndarray, dA_poly_dh: np.ndarray, dP_poly_dh: np.ndarray,
                          area_list: np.ndarray, perimeter_list: np.ndarray) -> np.ndarray:
         """
@@ -392,7 +492,7 @@ class FiniteVoronoiSimulator:
         """
         N = self.N
         r = self.phys.r
-        A0 = self.phys.A0
+        A0_list = self._preferred_areas
         P0 = self.phys.P0
         KA = self.phys.KA
         KP = self.phys.KP
@@ -569,8 +669,8 @@ class FiniteVoronoiSimulator:
                 v_da = vertex_out_da_dtheta[h_idx]   # (M,2)
                 v_dl = vertex_out_dl_dtheta[h_idx]   # (M,2)
 
-                Ai_w_i = (area_list[I]      - A0) * v_da[:, 0]
-                Aj_w_j = (area_list[J]      - A0) * v_da[:, 1]
+                Ai_w_i = (area_list[I]      - A0_list[I]) * v_da[:, 0]
+                Aj_w_j = (area_list[J]      - A0_list[J]) * v_da[:, 1]
                 Pi_w_i = (perimeter_list[I] - P0) * v_dl[:, 0]
                 Pj_w_j = (perimeter_list[J] - P0) * v_dl[:, 1]
 
@@ -608,14 +708,26 @@ class FiniteVoronoiSimulator:
         return F
 
     # --------------------- One integration step ---------------------
-    def build(self) -> Dict:
-        """
+    def build(self) -> dict[str, object]:
+        """ Build the finite-Voronoi structure and compute forces, returning a dictionary of diagnostics.
+
         Do the following:
           - Build Voronoi (+ extensions)
           - Get cell connectivity
           - Compute per-cell quantities and derivatives
           - Assemble forces
-        Returns a dictionary of diagnostics.
+        
+          
+        Returns:
+            dict[str, object]: A dictionary containing geometric properties with keys:
+
+                - **forces**: (N,2) array of forces on cell centers
+                - **areas**: (N,) array of cell areas
+                - **perimeters**: (N,) array of cell perimeters
+                - **vertices**: (M,2) array of all Voronoi + extension vertices
+                - **edges_type**: list-of-lists of edge types per cell (1=straight, 0=circular arc)
+                - **regions**: list-of-lists of vertex indices per cell
+                - **connections**: (M',2) array of connected cell index pairs
         """
         (vor, vertices_all, ridge_vertices_all, num_vertices,
             vertexpair2ridge, vertex_points) = self._build_voronoi_with_extensions()
@@ -650,26 +762,26 @@ class FiniteVoronoiSimulator:
         )
 
     # --------------------- 2D plotting utilities ---------------------
-    def plot_2d(self, ax: Optional[Axes] = None, show: bool = False) -> Axes:
+    def plot_2d(self, ax: matplotlib.axes.Axes | None = None, show: bool = False) -> matplotlib.axes.Axes:
         """
-        Build the Voronoi(+extensions) and render a 2D snapshot.
-
-        Parameters
-        ----------
-        ax : matplotlib.axes.Axes or None
-            If provided, draw into this axes; otherwise get the current axes.
-        show : bool
-            Whether to call plt.show() at the end.
-
-        Returns
-        -------
-        ax : matplotlib.axes.Axes
+        Build the finite-Voronoi structure and render a 2D snapshot.
+
+        Basically a wrapper of :py:meth:`_build_voronoi_with_extensions` and :py:meth:`_per_cell_geometry` functions + plot.
+
+        Args:
+            ax: If provided, draw into this axes; otherwise get the current axes.
+            show: Whether to call ``plt.show()`` at the end.
+        
+        Returns:
+            The matplotlib axes containing the plot.
         """
         (vor, vertices_all, ridge_vertices_all, num_vertices,
             vertexpair2ridge, vertex_points) = self._build_voronoi_with_extensions()
 
         geom, vertices_all = self._per_cell_geometry(vor, vertices_all, ridge_vertices_all, num_vertices, vertexpair2ridge)
 
+        from matplotlib import pyplot as plt
+
         if ax is None:
             ax = plt.gca()
         
@@ -681,8 +793,8 @@ class FiniteVoronoiSimulator:
         return ax
 
     # --------------------- Paradigm of plotting ---------------------
-    def _plot_routine(self, ax: Axes, vor: Voronoi, vertices_all: np.ndarray, ridge_vertices_all: List[List[int]],
-                      point_edges_type: List[List[int]], point_vertices_f_idx: List[List[int]]) -> None:
+    def _plot_routine(self, ax: Axes, vor: Voronoi, vertices_all: np.ndarray, ridge_vertices_all: list[list[int]],
+                      point_edges_type: list[list[int]], point_vertices_f_idx: list[list[int]]) -> None:
         """
         Low-level plot routine. Draws:
           - All Voronoi edges (solid for finite, dashed for formerly-infinite)
@@ -746,7 +858,7 @@ class FiniteVoronoiSimulator:
         ax.set_ylim(center[1]-L, center[1]+L)
 
     # --------------------- Connections between cells ---------------------
-    def _get_connections(self, ridge_points: List[List[int]], vertices_all: np.ndarray, ridge_vertices_all: List[List[int]]) -> np.ndarray:
+    def _get_connections(self, ridge_points: list[list[int]], vertices_all: np.ndarray, ridge_vertices_all: list[list[int]]) -> np.ndarray:
         """
         Determine which pairs of cells are connected, i.e.,
         the distance from the cell center to its corresponding Voronoi ridge
@@ -784,19 +896,90 @@ class FiniteVoronoiSimulator:
         return connect
 
     # --------------------- Update positions ---------------------
-    def update_positions(self, pts: np.ndarray) -> None:
+    def update_positions(self, pts: numpy.ndarray, A0: float | numpy.ndarray | None = None) -> None:
         """
         Update cell center positions.
+
+        .. note::
+            If the number of cells changes, the preferred areas for all cells
+            are reset to the default value---defined either at simulator instantiation 
+            or by :py:meth:`update_params`---unless *A0* is explicitly specified.
+
+        Args:
+            pts: New cell center positions.
+            A0: Optional, set new preferred area(s).
+
+        Raises:
+            ValueError: If *pts* does not have shape (N,2).
+            ValueError: If *A0* is an array and does not have shape (N,).
         """
-        self.N, dim = pts.shape
-        if dim != 2:
-            raise ValueError("Positions must have shape (N,2)")
+        pts = np.asarray(pts, dtype=float)
+        if pts.ndim != 2 or pts.shape[1] != 2:
+            raise ValueError("pts must have shape (N,2)")
         
+        N = pts.shape[0]
         self.pts = pts
 
+        if N != self.N:
+            self.N = N
+            if A0 is None:
+                self._preferred_areas = np.full(N, self.phys.A0, dtype=float)
+            else:
+                self.update_preferred_areas(A0)
+        else:
+            if A0 is not None:
+                self.update_preferred_areas(A0)
+
     # --------------------- Update physical parameters ---------------------
     def update_params(self, phys: PhysicalParams) -> None:
         """
         Update physical parameters.
+
+        Args:
+            phys: New PhysicalParams object.
+        
+        Raises:
+            TypeError: If *phys* is not an instance of PhysicalParams.
+
+        .. warning::
+            This also resets all preferred cell areas to the new value of *A0*.
         """
+        if not isinstance(phys, PhysicalParams):
+            raise TypeError("phys must be an instance of PhysicalParams")
+        
         self.phys = phys
+        self.update_preferred_areas(phys.A0)
+
+    # --------------------- Update preferred area list ---------------------
+    def update_preferred_areas(self, A0: float | numpy.ndarray) -> None:
+        """
+        Update the preferred areas for all cells.
+
+        Args:
+            A0: New preferred area(s) for all cells.
+
+        Raises:
+            ValueError: If *A0* does not match cell number.
+        """
+        arr = np.asarray(A0, dtype=float)
+
+        # Accept scalar (0-d) or length-1 array as "uniform"
+        if arr.ndim == 0:
+            arr = np.full(self.N, float(arr), dtype=float)
+        elif arr.shape == (1,):
+            arr = np.full(self.N, float(arr[0]), dtype=float)
+        else:
+            if arr.shape != (self.N,):
+                raise ValueError(f"A0 must be scalar or have shape ({self.N},)")
+        
+        self._preferred_areas = arr
+
+    @property
+    def preferred_areas(self) -> np.ndarray:
+        """
+        Preferred areas for all cells (read-only).
+
+        Returns:
+            numpy.ndarray: A copy of the internal preferred area array.
+        """
+        return self._preferred_areas.copy()

pyafv/physical_params.py

@@ -1,5 +1,5 @@
+from __future__ import annotations
 import numpy as np
-from scipy.optimize import minimize
 from dataclasses import dataclass, replace
 
 
@@ -15,30 +15,60 @@ def sigmoid(x):
 
 @dataclass(frozen=True)
 class PhysicalParams:
-    # Radius (maximal) of the Voronoi cells
-    r: float = 1.0
-    A0: float = np.pi                    # Preferred area of the Voronoi cells
-    P0: float = 4.8                      # Preferred perimeter of the Voronoi cells
-    KA: float = 1.0                      # Area elasticity
-    KP: float = 1.0                      # Perimeter elasticity
-    lambda_tension: float = 0.2          # Tension difference
-    delta: float = 0.                    # Small offset to avoid singularities
-
-    def get_steady_state(self):
-        # compute steady-state (l,d) given physical params
+    """Physical parameters for the active-finite-Voronoi (AFV) model.
+
+    Caveat:
+        Frozen dataclass is used for :py:class:`PhysicalParams` to ensure immutability of instances.
+
+    Args:
+        r: Radius (maximal) of the Voronoi cells.
+        A0: Preferred area of the Voronoi cells.
+        P0: Preferred perimeter of the Voronoi cells.
+        KA: Area elasticity constant.
+        KP: Perimeter elasticity constant.
+        lambda_tension: Tension difference between non-contacting edges and contacting edges.
+        delta: Small offset to avoid singularities in computations.
+    """
+    
+    r: float = 1.0               #: Radius (maximal) of the Voronoi cells.
+    A0: float = np.pi            #: Preferred area of the Voronoi cells.
+    P0: float = 4.8              #: Preferred perimeter of the Voronoi cells.
+    KA: float = 1.0              #: Area elasticity constant.
+    KP: float = 1.0              #: Perimeter elasticity constant.
+    lambda_tension: float = 0.2  #: Tension difference between non-contacting edges and contacting edges.
+    delta: float = 0.0           #: Small offset to avoid singularities in computations.
+
+
+    def get_steady_state(self) -> tuple[float, float]:
+        r"""Compute steady-state (l,d) for the given physical parameters.
+        
+        Returns:
+            Steady-state :math:`(\ell,d)` values.
+        """
         params = [self.KA, self.KP, self.A0, self.P0, self.lambda_tension]
         result = self._minimize_energy(params, restarts=10)
         l, d = result[0]
         return l, d
 
-    def with_optimal_radius(self):
-        """Returns a new instance with the radius updated to steady state."""
+    def with_optimal_radius(self) -> PhysicalParams:
+        """Returns a new instance with the radius updated to steady state.
+        
+        Returns:
+            New instance with optimal radius.
+        """
         l, d = self.get_steady_state()
         new_params = replace(self, r=l)
         return new_params
 
-    def with_delta(self, delta_new: float):
-        """Returns a new instance with the specified delta."""
+    def with_delta(self, delta_new: float) -> PhysicalParams:
+        """Returns a new instance with the specified delta.
+        
+        Args:
+            delta_new: New delta value.
+
+        Returns:
+            New instance with updated delta.
+        """
         return replace(self, delta=delta_new)
 
     def _energy_unconstrained(self, z, params):
@@ -55,6 +85,9 @@ class PhysicalParams:
         return KA * (A - A0)**2 + KP * (P - P0)**2 + Lambda * ln
 
     def _minimize_energy(self, params, restarts=10, seed=None):
+
+        from scipy.optimize import minimize
+        
         rng = np.random.default_rng(seed)
         best = None
         for _ in range(restarts):
@@ -79,8 +112,15 @@ class PhysicalParams:
 
 
 def target_delta(params: PhysicalParams, target_force: float) -> float:
-    """
-    Given physical parameters and a target detachment force, compute the corresponding delta.
+    r"""
+    Given the physical parameters and a target detachment force, compute the corresponding delta.
+
+    Args:
+        params: Physical parameters of the AFV model.
+        target_force: Target detachment force.
+
+    Returns:
+        Corresponding small cutoff :math:`\delta`'s value.
     """
     KP, A0, P0, Lambda = params.KP, params.A0, params.P0, params.lambda_tension
     l = params.r

{pyafv-0.3.3.dist-info → pyafv-0.3.6.dist-info}/METADATA

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: pyafv
-Version: 0.3.3
+Version: 0.3.6
 Summary: Python implementation of the active-finite-Voronoi (AFV) model
 Author-email: "Wei Wang (汪巍)" <ww000721@gmail.com>
 License-Expression: MIT
 Project-URL: Download, https://pypi.org/project/pyafv/#files
 Project-URL: Source Code, https://github.com/wwang721/pyafv
+Project-URL: Documentation, https://pyafv.readthedocs.io/
+Project-URL: Changelog, https://github.com/wwang721/pyafv/releases/latest
 Keywords: voronoi-model,cellular-patterns,biological-modeling
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -19,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: <3.15,>=3.9
+Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.26.4
@@ -35,6 +36,7 @@ Dynamic: license-file
 [![Downloads](https://img.shields.io/pypi/dm/pyafv.svg)](https://pypi.org/project/pyafv/)
 [![Zenodo](https://zenodo.org/badge/1124385738.svg)](https://doi.org/10.5281/zenodo.18091659)
 <!--[![pytest](https://github.com/wwang721/pyafv/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/wwang721/pyafv/actions/workflows/tests.yml?query=branch:main)-->
+[![Tests on all platforms](https://github.com/wwang721/pyafv/actions/workflows/tests_all_platform.yml/badge.svg)](https://github.com/wwang721/pyafv/actions/workflows/tests_all_platform.yml)
 [![pytest](https://github.com/wwang721/pyafv/actions/workflows/tests.yml/badge.svg)](https://github.com/wwang721/pyafv/actions/workflows/tests.yml)
 [![codecov](https://codecov.io/github/wwang721/pyafv/branch/main/graph/badge.svg?token=VSXSOX8HVS)](https://codecov.io/github/wwang721/pyafv/tree/main)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
@@ -48,11 +50,16 @@ The AFV framework was introduced and developed in, for example, Refs. [[1](#huan
 
 ## Installation
 
-Install **PyAFV** with:
+To install **PyAFV** with `pip`, run:
 ```bash
 pip install pyafv
 ```
-This package requires Python ≥ 3.9 and < 3.15.
+The package supports Python ≥ 3.10 and < 3.15.
+To verify that the installation was successful and that the correct version is installed, run the following in Python:
+```python
+import pyafv
+print(pyafv.__version__)
+```
 
 
 ## Usage
@@ -85,6 +92,7 @@ See important [**issues**](https://github.com/wwang721/pyafv/issues?q=is%3Aissue
 *  [Add customized plotting to examples illustrating access to vertices and edges #5](https://github.com/wwang721/pyafv/issues/5) [Completed in PR [#7](https://github.com/wwang721/pyafv/pull/7)]
 * [Time step dependence of intercellular adhesion in simulations #8](https://github.com/wwang721/pyafv/issues/8) [Closed in PR [#9](https://github.com/wwang721/pyafv/pull/9)]
 
+Full documentation on [readthedocs](https://pyafv.readthedocs.io/en/latest/)!
 
 ## References
 

pyafv-0.3.6.dist-info/RECORD

@@ -0,0 +1,12 @@
+pyafv/__init__.py,sha256=xN4BFNCwjuWbWHEgLsUdIYuqBWTVstIm0enHNDewIUk,444
+pyafv/_version.py,sha256=kpvCym_suX_uqk67H7D0GmkqZvRCvhh175QxhcaQnnk,44
+pyafv/backend.py,sha256=MlQThqIlTGXt__dj44rSutZLexKJTl9NaOEZ5s1otns,438
+pyafv/cell_geom.cp312-win_arm64.pyd,sha256=jTe3rZl46tI-W-olfAGU0S0IW4p6ha0x9nxV2EEbiwE,190976
+pyafv/cell_geom_fallback.py,sha256=eyhDC6Qe8_E_H59pNSwXeYA1DvJW1bHEnemK2TC8P0Y,9391
+pyafv/finite_voronoi.py,sha256=nXAWsK9sLlfRFjAc1TKsPuKLRcy9WOb9Wcjx1WfB2wQ,45449
+pyafv/physical_params.py,sha256=hvu20tlJC7VHy8bonrBJmV-sMiIm5NCDhOAGtgixjXo,5344
+pyafv-0.3.6.dist-info/licenses/LICENSE,sha256=UHfiLQ93gkQMOoN559ZBeG9kywkNcvDgxA9MRniWOpY,1086
+pyafv-0.3.6.dist-info/METADATA,sha256=3hRgZSfDSnrtZyDI0Tn3ulo4D6MeXybmjnw2oq43kAU,5782
+pyafv-0.3.6.dist-info/WHEEL,sha256=me1aG6nvouDIdjWXNa5q_zebZZEPzD53N4rwsapSjvI,101
+pyafv-0.3.6.dist-info/top_level.txt,sha256=mrKQNqc4GQxuZ7hd5UrKxbA_AJsuSqiJyMxL7Nu7va0,6
+pyafv-0.3.6.dist-info/RECORD,,