nrl-tracker 1.6.0__py3-none-any.whl → 1.7.1__py3-none-any.whl

pytcl/clustering/dbscan.py

@@ -12,7 +12,7 @@ References
        with Noise," KDD 1996.
 """
 
-from typing import List, NamedTuple, Set
+from typing import Any, List, NamedTuple, Set
 
 import numpy as np
 from numba import njit
@@ -42,7 +42,7 @@ class DBSCANResult(NamedTuple):
 
 
 @njit(cache=True)
-def _compute_distance_matrix(X: np.ndarray) -> np.ndarray:
+def _compute_distance_matrix(X: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
     """Compute pairwise Euclidean distance matrix (JIT-compiled)."""
     n = X.shape[0]
     dist = np.zeros((n, n), dtype=np.float64)

pytcl/clustering/gaussian_mixture.py

@@ -674,9 +674,9 @@ class GaussianMixture:
 
     def _gaussian_pdf(
         self,
-        x: NDArray,
-        mean: NDArray,
-        cov: NDArray,
+        x: NDArray[np.floating],
+        mean: NDArray[np.floating],
+        cov: NDArray[np.floating],
     ) -> float:
         """Evaluate single Gaussian PDF."""
         n = len(x)

pytcl/clustering/hierarchical.py

@@ -12,7 +12,7 @@ References
 """
 
 from enum import Enum
-from typing import List, Literal, NamedTuple, Optional
+from typing import Any, List, Literal, NamedTuple, Optional
 
 import numpy as np
 from numba import njit
@@ -72,7 +72,7 @@ class HierarchicalResult(NamedTuple):
 
 
 @njit(cache=True)
-def _compute_distance_matrix_jit(X: np.ndarray) -> np.ndarray:
+def _compute_distance_matrix_jit(X: np.ndarray[Any, Any]) -> np.ndarray[Any, Any]:
     """JIT-compiled pairwise Euclidean distance computation."""
     n = X.shape[0]
     n_features = X.shape[1]
@@ -112,43 +112,43 @@ def compute_distance_matrix(
 
 
 def _single_linkage(
-    dist_i: NDArray,
-    dist_j: NDArray,
+    dist_i: NDArray[Any],
+    dist_j: NDArray[Any],
     size_i: int,
     size_j: int,
-) -> NDArray:
+) -> NDArray[Any]:
     """Single linkage: minimum of distances."""
     return np.minimum(dist_i, dist_j)
 
 
 def _complete_linkage(
-    dist_i: NDArray,
-    dist_j: NDArray,
+    dist_i: NDArray[Any],
+    dist_j: NDArray[Any],
     size_i: int,
     size_j: int,
-) -> NDArray:
+) -> NDArray[Any]:
     """Complete linkage: maximum of distances."""
     return np.maximum(dist_i, dist_j)
 
 
 def _average_linkage(
-    dist_i: NDArray,
-    dist_j: NDArray,
+    dist_i: NDArray[Any],
+    dist_j: NDArray[Any],
     size_i: int,
     size_j: int,
-) -> NDArray:
+) -> NDArray[Any]:
     """Average linkage: weighted average of distances."""
     return (size_i * dist_i + size_j * dist_j) / (size_i + size_j)
 
 
 def _ward_linkage(
-    dist_i: NDArray,
-    dist_j: NDArray,
+    dist_i: NDArray[Any],
+    dist_j: NDArray[Any],
     size_i: int,
     size_j: int,
-    size_k: NDArray,
+    size_k: NDArray[Any],
     dist_ij: float,
-) -> NDArray:
+) -> NDArray[Any]:
     """Ward's linkage: minimum variance merge."""
     total = size_i + size_j + size_k
     return np.sqrt(

pytcl/clustering/kmeans.py

@@ -10,7 +10,7 @@ References
        Careful Seeding," SODA 2007.
 """
 
-from typing import Literal, NamedTuple, Optional, Union
+from typing import Any, Literal, NamedTuple, Optional, Union
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -305,7 +305,7 @@ def _kmeans_single(
 
         # Handle empty clusters: keep old center
         for k in range(n_clusters):
-            if np.all(new_centers[k] == 0) and np.any(labels == k) is False:
+            if np.all(new_centers[k] == 0) and not np.any(labels == k):
                 new_centers[k] = centers[k]
 
         # Check convergence
@@ -336,8 +336,8 @@ def _kmeans_single(
 def kmeans_elbow(
     X: ArrayLike,
     k_range: Optional[range] = None,
-    **kwargs,
-) -> dict:
+    **kwargs: Any,
+) -> dict[str, Any]:
     """
     Compute K-means for a range of k values for elbow method.
 

pytcl/containers/base.py

@@ -8,7 +8,7 @@ Cover trees.
 
 import logging
 from abc import ABC, abstractmethod
-from typing import Callable, List, NamedTuple, Optional
+from typing import Any, Callable, List, NamedTuple, Optional
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -155,7 +155,7 @@ class MetricSpatialIndex(BaseSpatialIndex):
     def __init__(
         self,
         data: ArrayLike,
-        metric: Optional[Callable[[NDArray, NDArray], float]] = None,
+        metric: Optional[Callable[[NDArray[Any], NDArray[Any]], float]] = None,
     ):
         super().__init__(data)
 
@@ -165,7 +165,7 @@ class MetricSpatialIndex(BaseSpatialIndex):
             self.metric = metric
 
     @staticmethod
-    def _euclidean_distance(x: NDArray, y: NDArray) -> float:
+    def _euclidean_distance(x: NDArray[Any], y: NDArray[Any]) -> float:
         """Default Euclidean distance metric."""
         return float(np.sqrt(np.sum((x - y) ** 2)))
 

pytcl/containers/cluster_set.py

@@ -7,7 +7,17 @@ that move together (formations, convoys, etc.).
 
 from __future__ import annotations
 
-from typing import Dict, Iterable, Iterator, List, NamedTuple, Optional, Tuple, Union
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    NamedTuple,
+    Optional,
+    Tuple,
+    Union,
+)
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -303,7 +313,7 @@ class ClusterSet:
         cls,
         tracks: TrackList,
         method: str = "dbscan",
-        **kwargs,
+        **kwargs: Any,
     ) -> ClusterSet:
         """
         Create a ClusterSet by clustering tracks.

pytcl/containers/covertree.py

@@ -12,7 +12,7 @@ References
 """
 
 import logging
-from typing import Callable, List, NamedTuple, Optional, Set, Tuple
+from typing import Any, Callable, List, NamedTuple, Optional, Set, Tuple
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -109,7 +109,9 @@ class CoverTree(MetricSpatialIndex):
     def __init__(
         self,
         data: ArrayLike,
-        metric: Optional[Callable[[NDArray, NDArray], float]] = None,
+        metric: Optional[
+            Callable[[np.ndarray[Any, Any], np.ndarray[Any, Any]], float]
+        ] = None,
         base: float = 2.0,
     ):
         super().__init__(data, metric)
@@ -141,7 +143,7 @@ class CoverTree(MetricSpatialIndex):
             self._distance_cache[key] = self.metric(self.data[i], self.data[j])
         return self._distance_cache[key]
 
-    def _distance_to_point(self, idx: int, query: NDArray) -> float:
+    def _distance_to_point(self, idx: int, query: NDArray[np.floating]) -> float:
         """Distance from data point to query point."""
         return self.metric(self.data[idx], query)
 

pytcl/containers/rtree.py

@@ -654,7 +654,7 @@ class RTree:
         query = np.asarray(query_point, dtype=np.float64)
         neighbors: List[Tuple[float, int]] = []
 
-        def min_dist_to_box(point: NDArray, bbox: BoundingBox) -> float:
+        def min_dist_to_box(point: NDArray[np.floating], bbox: BoundingBox) -> float:
             """Minimum distance from point to bounding box."""
             clamped = np.clip(point, bbox.min_coords, bbox.max_coords)
             return float(np.sqrt(np.sum((point - clamped) ** 2)))

pytcl/containers/vptree.py

@@ -12,7 +12,7 @@ References
 """
 
 import logging
-from typing import Callable, List, NamedTuple, Optional, Tuple
+from typing import Any, Callable, List, NamedTuple, Optional, Tuple
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -105,7 +105,9 @@ class VPTree(MetricSpatialIndex):
     def __init__(
         self,
         data: ArrayLike,
-        metric: Optional[Callable[[NDArray, NDArray], float]] = None,
+        metric: Optional[
+            Callable[[np.ndarray[Any, Any], np.ndarray[Any, Any]], float]
+        ] = None,
     ):
         super().__init__(data, metric)
 

pytcl/coordinate_systems/conversions/geodetic.py

@@ -165,11 +165,13 @@ def ecef2geodetic(
         N = a / np.sqrt(1 - e2 * sin_lat**2)
 
         # Altitude
-        alt = np.where(
-            np.abs(cos_lat) > 1e-10,
-            p / cos_lat - N,
-            np.abs(z) / np.abs(sin_lat) - N * (1 - e2),
-        )
+        # Use cos_lat when available, otherwise use sin_lat with guard against division by zero
+        with np.errstate(divide="ignore", invalid="ignore"):
+            alt = np.where(
+                np.abs(cos_lat) > 1e-10,
+                p / cos_lat - N,
+                np.abs(z) / np.abs(sin_lat) - N * (1 - e2),
+            )
     else:
         # Direct/closed-form method (simplified Vermeille)
         zp = np.abs(z)
@@ -525,6 +527,267 @@ def ned2enu(ned: ArrayLike) -> NDArray[np.floating]:
     return np.array([ned[1], ned[0], -ned[2]], dtype=np.float64)
 
 
+def geodetic2sez(
+    lat: ArrayLike,
+    lon: ArrayLike,
+    alt: ArrayLike,
+    lat_ref: float,
+    lon_ref: float,
+    alt_ref: float,
+    a: float = WGS84.a,
+    f: float = WGS84.f,
+) -> NDArray[np.floating]:
+    """
+    Convert geodetic coordinates to local SEZ (South-East-Zenith) coordinates.
+
+    SEZ is a horizon-relative coordinate frame where:
+    - S (South) points in the southward direction
+    - E (East) points in the eastward direction
+    - Z (Zenith) points upward (away from Earth center)
+
+    Parameters
+    ----------
+    lat : array_like
+        Geodetic latitude in radians.
+    lon : array_like
+        Geodetic longitude in radians.
+    alt : array_like
+        Altitude in meters.
+    lat_ref : float
+        Reference point latitude in radians.
+    lon_ref : float
+        Reference point longitude in radians.
+    alt_ref : float
+        Reference point altitude in meters.
+    a : float, optional
+        Semi-major axis of the reference ellipsoid.
+    f : float, optional
+        Flattening of the reference ellipsoid.
+
+    Returns
+    -------
+    sez : ndarray
+        Local SEZ coordinates [south, east, zenith] in meters.
+
+    See Also
+    --------
+    sez2geodetic : Inverse conversion.
+    ecef2sez : ECEF to SEZ conversion.
+
+    Notes
+    -----
+    SEZ is equivalent to NED when azimuth is measured from south.
+    Conversion: SEZ = [S, E, Z] = [NED[0], NED[1], -NED[2]]
+
+    Examples
+    --------
+    >>> sez = geodetic2sez(lat, lon, alt, lat_ref, lon_ref, alt_ref)
+    """
+    # Convert both to ECEF
+    ecef = geodetic2ecef(lat, lon, alt, a, f)
+    ecef_ref = geodetic2ecef(lat_ref, lon_ref, alt_ref, a, f)
+
+    # Get SEZ from ECEF difference
+    return ecef2sez(ecef, lat_ref, lon_ref, ecef_ref)
+
+
+def ecef2sez(
+    ecef: ArrayLike,
+    lat_ref: float,
+    lon_ref: float,
+    ecef_ref: Optional[ArrayLike] = None,
+) -> NDArray[np.floating]:
+    """
+    Convert ECEF coordinates to local SEZ coordinates.
+
+    Parameters
+    ----------
+    ecef : array_like
+        ECEF coordinates [X, Y, Z] in meters, shape (3,) or (3, N).
+    lat_ref : float
+        Reference point latitude in radians.
+    lon_ref : float
+        Reference point longitude in radians.
+    ecef_ref : array_like, optional
+        Reference ECEF position. If None, the reference point is
+        at (lat_ref, lon_ref) with zero altitude.
+
+    Returns
+    -------
+    sez : ndarray
+        SEZ coordinates [south, east, zenith] in meters.
+
+    See Also
+    --------
+    sez2ecef : Inverse conversion.
+    """
+    ecef = np.asarray(ecef, dtype=np.float64)
+
+    if ecef_ref is None:
+        ecef_ref = geodetic2ecef(lat_ref, lon_ref, 0.0)
+    else:
+        ecef_ref = np.asarray(ecef_ref, dtype=np.float64)
+
+    # Relative position in ECEF
+    if ecef.ndim == 1:
+        delta_ecef = ecef - ecef_ref
+    else:
+        if ecef.shape[0] != 3:
+            ecef = ecef.T
+        if ecef_ref.ndim == 1:
+            delta_ecef = ecef - ecef_ref[:, np.newaxis]
+        else:
+            delta_ecef = ecef - ecef_ref[:, np.newaxis]
+
+    # Rotation matrix from ECEF to SEZ
+    sin_lat = np.sin(lat_ref)
+    cos_lat = np.cos(lat_ref)
+    sin_lon = np.sin(lon_ref)
+    cos_lon = np.cos(lon_ref)
+
+    # SEZ rotation matrix (transforms ECEF delta to SEZ)
+    # S = -sin(lat)*cos(lon)*dX - sin(lat)*sin(lon)*dY + cos(lat)*dZ
+    # E = -sin(lon)*dX + cos(lon)*dY
+    # Z = cos(lat)*cos(lon)*dX + cos(lat)*sin(lon)*dY + sin(lat)*dZ
+
+    if delta_ecef.ndim == 1:
+        s = (
+            -sin_lat * cos_lon * delta_ecef[0]
+            - sin_lat * sin_lon * delta_ecef[1]
+            + cos_lat * delta_ecef[2]
+        )
+        e = -sin_lon * delta_ecef[0] + cos_lon * delta_ecef[1]
+        z = (
+            cos_lat * cos_lon * delta_ecef[0]
+            + cos_lat * sin_lon * delta_ecef[1]
+            + sin_lat * delta_ecef[2]
+        )
+        return np.array([s, e, z], dtype=np.float64)
+    else:
+        s = (
+            -sin_lat * cos_lon * delta_ecef[0, :]
+            - sin_lat * sin_lon * delta_ecef[1, :]
+            + cos_lat * delta_ecef[2, :]
+        )
+        e = -sin_lon * delta_ecef[0, :] + cos_lon * delta_ecef[1, :]
+        z = (
+            cos_lat * cos_lon * delta_ecef[0, :]
+            + cos_lat * sin_lon * delta_ecef[1, :]
+            + sin_lat * delta_ecef[2, :]
+        )
+        return np.array([s, e, z], dtype=np.float64)
+
+
+def sez2ecef(
+    sez: ArrayLike,
+    lat_ref: float,
+    lon_ref: float,
+    ecef_ref: Optional[ArrayLike] = None,
+) -> NDArray[np.floating]:
+    """
+    Convert local SEZ coordinates to ECEF coordinates.
+
+    Parameters
+    ----------
+    sez : array_like
+        SEZ coordinates [south, east, zenith] in meters, shape (3,) or (3, N).
+    lat_ref : float
+        Reference point latitude in radians.
+    lon_ref : float
+        Reference point longitude in radians.
+    ecef_ref : array_like, optional
+        Reference ECEF position. If None, the reference point is
+        at (lat_ref, lon_ref) with zero altitude.
+
+    Returns
+    -------
+    ecef : ndarray
+        ECEF coordinates [X, Y, Z] in meters.
+
+    See Also
+    --------
+    ecef2sez : Forward conversion.
+    """
+    sez = np.asarray(sez, dtype=np.float64)
+
+    if ecef_ref is None:
+        ecef_ref = geodetic2ecef(lat_ref, lon_ref, 0.0)
+    else:
+        ecef_ref = np.asarray(ecef_ref, dtype=np.float64)
+
+    # Rotation matrix from SEZ to ECEF (transpose of ECEF to SEZ)
+    sin_lat = np.sin(lat_ref)
+    cos_lat = np.cos(lat_ref)
+    sin_lon = np.sin(lon_ref)
+    cos_lon = np.cos(lon_ref)
+
+    # Inverse rotation: ECEF = ECEF_ref + R_inv @ SEZ
+    if sez.ndim == 1:
+        dX = -sin_lat * cos_lon * sez[0] - sin_lon * sez[1] + cos_lat * cos_lon * sez[2]
+        dY = -sin_lat * sin_lon * sez[0] + cos_lon * sez[1] + cos_lat * sin_lon * sez[2]
+        dZ = cos_lat * sez[0] + sin_lat * sez[2]
+        return ecef_ref + np.array([dX, dY, dZ], dtype=np.float64)
+    else:
+        if sez.shape[0] != 3:
+            sez = sez.T
+        dX = (
+            -sin_lat * cos_lon * sez[0, :]
+            - sin_lon * sez[1, :]
+            + cos_lat * cos_lon * sez[2, :]
+        )
+        dY = (
+            -sin_lat * sin_lon * sez[0, :]
+            + cos_lon * sez[1, :]
+            + cos_lat * sin_lon * sez[2, :]
+        )
+        dZ = cos_lat * sez[0, :] + sin_lat * sez[2, :]
+        return ecef_ref[:, np.newaxis] + np.array([dX, dY, dZ], dtype=np.float64)
+
+
+def sez2geodetic(
+    sez: ArrayLike,
+    lat_ref: float,
+    lon_ref: float,
+    alt_ref: float,
+    a: float = WGS84.a,
+    f: float = WGS84.f,
+) -> Tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.floating]]:
+    """
+    Convert local SEZ coordinates to geodetic coordinates.
+
+    Parameters
+    ----------
+    sez : array_like
+        SEZ coordinates [south, east, zenith] in meters.
+    lat_ref : float
+        Reference point latitude in radians.
+    lon_ref : float
+        Reference point longitude in radians.
+    alt_ref : float
+        Reference point altitude in meters.
+    a : float, optional
+        Semi-major axis.
+    f : float, optional
+        Flattening.
+
+    Returns
+    -------
+    lat : ndarray
+        Geodetic latitude in radians.
+    lon : ndarray
+        Geodetic longitude in radians.
+    alt : ndarray
+        Altitude in meters.
+
+    See Also
+    --------
+    geodetic2sez : Forward conversion.
+    """
+    ecef_ref = geodetic2ecef(lat_ref, lon_ref, alt_ref, a, f)
+    ecef = sez2ecef(sez, lat_ref, lon_ref, ecef_ref)
+    return ecef2geodetic(ecef, a, f)
+
+
 def geocentric_radius(
     lat: ArrayLike,
     a: float = WGS84.a,
@@ -625,6 +888,10 @@ __all__ = [
     "ned2ecef",
     "enu2ned",
     "ned2enu",
+    "geodetic2sez",
+    "ecef2sez",
+    "sez2ecef",
+    "sez2geodetic",
     "geocentric_radius",
     "prime_vertical_radius",
     "meridional_radius",

pytcl/coordinate_systems/jacobians/jacobians.py

@@ -6,7 +6,7 @@ coordinate transformations, essential for error propagation in tracking
 filters (e.g., converting measurement covariances between coordinate systems).
 """
 
-from typing import Literal
+from typing import Callable, Literal
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -431,7 +431,7 @@ def cross_covariance_transform(
 
 
 def numerical_jacobian(
-    func,
+    func: Callable[[ArrayLike], ArrayLike],
     x: ArrayLike,
     dx: float = 1e-7,
 ) -> NDArray[np.floating]:

pytcl/coordinate_systems/projections/projections.py

@@ -25,7 +25,7 @@ References
        nanometers." Journal of Geodesy 85.8 (2011): 475-485.
 """
 
-from typing import NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple, Optional, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -1253,7 +1253,7 @@ def geodetic2utm_batch(
     lats: NDArray[np.floating],
     lons: NDArray[np.floating],
     zone: Optional[int] = None,
-) -> Tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.int_], NDArray]:
+) -> tuple[NDArray[np.floating], NDArray[np.floating], NDArray[np.intp], NDArray[Any]]:
     """
     Batch convert geodetic coordinates to UTM.
 

pytcl/coordinate_systems/rotations/rotations.py

@@ -6,7 +6,7 @@ representations including rotation matrices, quaternions, Euler angles,
 axis-angle, and Rodrigues parameters.
 """
 
-from typing import Tuple
+from typing import Any, Tuple
 
 import numpy as np
 from numba import njit
@@ -14,7 +14,7 @@ from numpy.typing import ArrayLike, NDArray
 
 
 @njit(cache=True, fastmath=True)
-def _rotx_inplace(angle: float, R: np.ndarray) -> None:
+def _rotx_inplace(angle: float, R: np.ndarray[Any, Any]) -> None:
     """JIT-compiled rotation about x-axis (fills existing matrix)."""
     c = np.cos(angle)
     s = np.sin(angle)
@@ -30,7 +30,7 @@ def _rotx_inplace(angle: float, R: np.ndarray) -> None:
 
 
 @njit(cache=True, fastmath=True)
-def _roty_inplace(angle: float, R: np.ndarray) -> None:
+def _roty_inplace(angle: float, R: np.ndarray[Any, Any]) -> None:
     """JIT-compiled rotation about y-axis (fills existing matrix)."""
     c = np.cos(angle)
     s = np.sin(angle)
@@ -46,7 +46,7 @@ def _roty_inplace(angle: float, R: np.ndarray) -> None:
 
 
 @njit(cache=True, fastmath=True)
-def _rotz_inplace(angle: float, R: np.ndarray) -> None:
+def _rotz_inplace(angle: float, R: np.ndarray[Any, Any]) -> None:
     """JIT-compiled rotation about z-axis (fills existing matrix)."""
     c = np.cos(angle)
     s = np.sin(angle)
@@ -62,7 +62,9 @@ def _rotz_inplace(angle: float, R: np.ndarray) -> None:
 
 
 @njit(cache=True, fastmath=True)
-def _euler_zyx_to_rotmat(yaw: float, pitch: float, roll: float, R: np.ndarray) -> None:
+def _euler_zyx_to_rotmat(
+    yaw: float, pitch: float, roll: float, R: np.ndarray[Any, Any]
+) -> None:
     """JIT-compiled ZYX Euler angles to rotation matrix."""
     cy = np.cos(yaw)
     sy = np.sin(yaw)
@@ -84,7 +86,9 @@ def _euler_zyx_to_rotmat(yaw: float, pitch: float, roll: float, R: np.ndarray) -
 
 
 @njit(cache=True, fastmath=True)
-def _matmul_3x3(A: np.ndarray, B: np.ndarray, C: np.ndarray) -> None:
+def _matmul_3x3(
+    A: np.ndarray[Any, Any], B: np.ndarray[Any, Any], C: np.ndarray[Any, Any]
+) -> None:
     """JIT-compiled 3x3 matrix multiplication C = A @ B."""
     for i in range(3):
         for j in range(3):

pytcl/core/validation.py

@@ -28,7 +28,7 @@ def validate_array(
     arr: ArrayLike,
     name: str = "array",
     *,
-    dtype: type | np.dtype | None = None,
+    dtype: type | np.dtype[Any] | None = None,
     ndim: int | tuple[int, ...] | None = None,
     shape: tuple[int | None, ...] | None = None,
     min_ndim: int | None = None,
@@ -415,7 +415,7 @@ def validate_same_shape(*arrays: ArrayLike, names: Sequence[str] | None = None)
 def validated_array_input(
     param_name: str,
     *,
-    dtype: type | np.dtype | None = None,
+    dtype: type | np.dtype[Any] | None = None,
     ndim: int | tuple[int, ...] | None = None,
     shape: tuple[int | None, ...] | None = None,
     finite: bool = False,
@@ -516,7 +516,7 @@ class ArraySpec:
     def __init__(
         self,
         *,
-        dtype: type | np.dtype | None = None,
+        dtype: type | np.dtype[Any] | None = None,
         ndim: int | tuple[int, ...] | None = None,
         shape: tuple[int | None, ...] | None = None,
         min_ndim: int | None = None,