diff --git a/src/_numtype/__init__.pyi b/src/_numtype/__init__.pyi index e583e73b..fd2b7943 100644 --- a/src/_numtype/__init__.pyi +++ b/src/_numtype/__init__.pyi @@ -22,28 +22,13 @@ _T_co = TypeVar("_T_co", covariant=True) _ShapeT_co = TypeVar("_ShapeT_co", bound=tuple[int, ...], default=Any, covariant=True) _ScalarT = TypeVar("_ScalarT", bound=np.generic, default=Any) _ScalarT_co = TypeVar("_ScalarT_co", bound=np.generic, default=Any, covariant=True) +_ToT = TypeVar("_ToT", default=_ScalarT) ### # Type constraints (bijective type mappings) -ShapeC = TypeVar( # noqa: PYI001 - "ShapeC", - NDim0, - NDim1, - NDim1 | NDim0, - NDim2, - NDim2 | NDim1, - NDim2 | NDim1 | NDim0, - NDim3, - NDim3 | NDim2, - NDim3 | NDim2 | NDim1, - NDim3 | NDim2 | NDim1 | NDim0, - NDim3p, - NDim2p, - NDim1p, - tuple[int, ...], - default=tuple[int, ...], -) +_ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...], default=tuple[int, ...]) + ItemC = TypeVar( # noqa: PYI001 "ItemC", bool, @@ -60,25 +45,25 @@ ItemC = TypeVar( # noqa: PYI001 ### # Protocols -# A slimmed down version of `_NestedSequence`, based on `optype.numpy.SequenceND`. -# https://github.com/jorenham/optype @type_check_only -class Sequence_nd(Protocol[_T_co]): - def __len__(self, /) -> int: ... - def __getitem__(self, index: int, /) -> _T_co | Sequence_nd[_T_co]: ... - def __contains__(self, x: object, /) -> bool: ... - def index(self, value: Any, /) -> int: ... - -@type_check_only -class Can(Protocol[_ScalarT_co, _ShapeT_co]): +class CanArray(Protocol[_ScalarT_co, _ShapeT_co]): def __array__(self, /) -> np.ndarray[_ShapeT_co, np.dtype[_ScalarT_co]]: ... # A shape-typed version of `numpy._typing._Can`, parametrized by the # scalar-type and shape-type, and excludes `np.generic` scalars (through `__len__`). @type_check_only -class CanLen(Can[_ScalarT_co, _ShapeT_co], Protocol[_ScalarT_co, _ShapeT_co]): +class CanArraySized(CanArray[_ScalarT_co, _ShapeT_co], Protocol[_ScalarT_co, _ShapeT_co]): def __len__(self, /) -> int: ... +# A slimmed down version of `_NestedSequence`, based on `optype.numpy.SequenceND`. +# https://github.com/jorenham/optype +@type_check_only +class NDSequence(Protocol[_T_co]): + def __len__(self, /) -> int: ... + def __getitem__(self, index: int, /) -> _T_co | NDSequence[_T_co]: ... + def __contains__(self, x: object, /) -> bool: ... + def index(self, value: Any, /) -> int: ... + # Type-check-only equivalent of `optype.Just`. # https://github.com/jorenham/optype#just @type_check_only @@ -94,13 +79,44 @@ class Unhashable(Protocol): __hash__: ClassVar[None] # type: ignore[assignment] # pyright: ignore[reportIncompatibleMethodOverride] ### -# Helper aliases +# Shape aliases + +Shape: TypeAlias = tuple[int, ...] + +Shape_l1d = TypeAliasType("Shape_l1d", tuple[int] | tuple[()]) +Shape_l2d = TypeAliasType("Shape_l2d", tuple[int, int] | tuple[int] | tuple[()]) +Shape_l3d = TypeAliasType("Shape_l3d", tuple[int, int, int] | tuple[int, int] | tuple[int] | tuple[()]) + +Shape_g1d = TypeAliasType("Shape_g1d", tuple[int, Unpack[tuple[int, ...]]]) +Shape_g2d = TypeAliasType("Shape_g2d", tuple[int, int, Unpack[tuple[int, ...]]]) +Shape_g3d = TypeAliasType("Shape_g3d", tuple[int, int, int, Unpack[tuple[int, ...]]]) +Shape_g4d = TypeAliasType("Shape_g4d", tuple[int, int, int, int, Unpack[tuple[int, ...]]]) + +### +# Shape-typed array aliases + +Array = TypeAliasType("Array", np.ndarray[_ShapeT, np.dtype[_ScalarT]], type_params=(_ScalarT, _ShapeT)) +Array_0d = TypeAliasType("Array_0d", np.ndarray[tuple[()], np.dtype[_ScalarT]], type_params=(_ScalarT,)) +Array_1d = TypeAliasType("Array_1d", np.ndarray[tuple[int], np.dtype[_ScalarT]], type_params=(_ScalarT,)) +Array_2d = TypeAliasType("Array_2d", np.ndarray[tuple[int, int], np.dtype[_ScalarT]], type_params=(_ScalarT,)) +Array_3d = TypeAliasType("Array_3d", np.ndarray[tuple[int, int, int], np.dtype[_ScalarT]], type_params=(_ScalarT,)) + +MArray = TypeAliasType("MArray", np.ma.MaskedArray[_ShapeT, np.dtype[_ScalarT]], type_params=(_ScalarT, _ShapeT)) +MArray_0d = TypeAliasType("MArray_0d", np.ma.MaskedArray[tuple[()], np.dtype[_ScalarT]], type_params=(_ScalarT,)) +MArray_1d = TypeAliasType("MArray_1d", np.ma.MaskedArray[tuple[int], np.dtype[_ScalarT]], type_params=(_ScalarT,)) +MArray_2d = TypeAliasType("MArray_2d", np.ma.MaskedArray[tuple[int, int], np.dtype[_ScalarT]], type_params=(_ScalarT,)) +MArray_3d = TypeAliasType("MArray_3d", np.ma.MaskedArray[tuple[int, int, int], np.dtype[_ScalarT]], type_params=(_ScalarT,)) + +Matrix = TypeAliasType("Matrix", np.matrix[tuple[int, int], np.dtype[_ScalarT]], type_params=(_ScalarT,)) + +### +# helper aliases _PyReal: TypeAlias = Is[int] | Is[float] _PyInexact: TypeAlias = Is[float] | Is[complex] _PyNumber: TypeAlias = Is[int] | _PyInexact _PyCharacter: TypeAlias = Is[bytes] | Is[str] -_PyObject: TypeAlias = ( # anything that will always result in something with a `object_` dtype +_PyObject: TypeAlias = ( # anything immutable that results in an `object_` dtype Is[object] | type | slice @@ -111,492 +127,454 @@ _PyObject: TypeAlias = ( # anything that will always result in something with a | uuid.UUID | ip.IPv4Address | ip.IPv6Address - | set[Any] - | frozenset[Any] - | dict[Any, Any] ) -_AsFloat64: TypeAlias = np.floating[_64Bit] -_AsComplex128: TypeAlias = np.complexfloating[_64Bit] - -_ToBool: TypeAlias = np.generic[bool] -_ToUInt8: TypeAlias = np.uint8 | _ToBool -_ToUInt16: TypeAlias = np.uint16 | _ToUInt8 -_ToUInt32: TypeAlias = np.uint32 | _ToUInt16 -_ToUInt64: TypeAlias = np.uint64 | _ToUInt32 -_ToULong: TypeAlias = np.ulong | _ToUInt32 -_ToUIntP: TypeAlias = np.uintp | _ToULong -_ToULongLong: TypeAlias = np.unsignedinteger | _ToBool -_ToInt8: TypeAlias = np.int8 | _ToBool -_ToInt16: TypeAlias = np.int16 | np.uint8 | _ToInt8 -_ToInt32: TypeAlias = np.int32 | np.uint16 | _ToInt16 -_ToInt64: TypeAlias = np.int64 | np.uint32 | _ToInt32 -_ToLong: TypeAlias = np.long | _ToInt32 -_ToIntP: TypeAlias = np.intp | _ToLong -_ToLongLong: TypeAlias = np.signedinteger | _ToUInt32 -_ToInteger: TypeAlias = np.generic[int] -_ToFloat16: TypeAlias = np.float16 | np.uint8 | np.int16 | _ToBool -_ToFloat32: TypeAlias = np.float32 | np.uint16 | np.int16 | _ToFloat16 -_ToFloat64: TypeAlias = _AsFloat64 | np.float32 | np.float16 | _ToInteger -_ToFloating: TypeAlias = np.generic[float | int] -_ToComplex64: TypeAlias = np.complex64 | _ToFloat32 -_ToComplex128: TypeAlias = _AsComplex128 | np.complex64 | _ToFloat64 -_ToNumber: TypeAlias = np.generic[complex | float | int] -_ToTimeDelta: TypeAlias = np.timedelta64[Any] | _ToInteger -_ToDateTime: TypeAlias = np.datetime64[Any] | np.timedelta64[Any] # scalars may also accepts `integer | _ToBool` -_ToBytes: TypeAlias = np.character[bytes] -_ToStr: TypeAlias = np.character -_ToObject: TypeAlias = np.generic - -_To1_0d: TypeAlias = _ScalarT | Can[_ScalarT, tuple[()]] -_To2_0d: TypeAlias = _ScalarT | _T | Can[_ScalarT, tuple[()]] - -_To1_1d: TypeAlias = CanLen[_ScalarT, tuple[int]] | Sequence[_To1_0d[_ScalarT]] -_To2_1d: TypeAlias = CanLen[_ScalarT, tuple[int]] | Sequence[_To2_0d[_ScalarT, _T]] - -_To1_2d: TypeAlias = CanLen[_ScalarT, tuple[int, int]] | Sequence[_To1_1d[_ScalarT]] -_To2_2d: TypeAlias = CanLen[_ScalarT, tuple[int, int]] | Sequence[_To2_1d[_ScalarT, _T]] - -_To1_3d: TypeAlias = CanLen[_ScalarT, tuple[int, int, int]] | Sequence[_To1_2d[_ScalarT]] -_To2_3d: TypeAlias = CanLen[_ScalarT, tuple[int, int, int]] | Sequence[_To2_2d[_ScalarT, _T]] - -_To1_nd: TypeAlias = CanLen[_ScalarT] | Sequence_nd[CanLen[_ScalarT]] -_To2_nd: TypeAlias = CanLen[_ScalarT] | Sequence_nd[_T | _ScalarT] | Sequence_nd[CanLen[_ScalarT]] - -### -# Shaped array aliases - -NDim0: TypeAlias = tuple[()] -NDim1: TypeAlias = tuple[int] -NDim2: TypeAlias = tuple[int, int] -NDim3: TypeAlias = tuple[int, int, int] - -NDim: TypeAlias = tuple[int, ...] -NDim1p: TypeAlias = tuple[int, Unpack[tuple[int, ...]]] -NDim2p: TypeAlias = tuple[int, int, Unpack[tuple[int, ...]]] -NDim3p: TypeAlias = tuple[int, int, int, Unpack[tuple[int, ...]]] - -Array = TypeAliasType("Array", np.ndarray[ShapeC, np.dtype[_ScalarT]], type_params=(_ScalarT, ShapeC)) -Array0 = TypeAliasType("Array0", np.ndarray[NDim0, np.dtype[_ScalarT]], type_params=(_ScalarT,)) -Array1 = TypeAliasType("Array1", np.ndarray[NDim1, np.dtype[_ScalarT]], type_params=(_ScalarT,)) -Array2 = TypeAliasType("Array2", np.ndarray[NDim2, np.dtype[_ScalarT]], type_params=(_ScalarT,)) -Array3 = TypeAliasType("Array3", np.ndarray[NDim3, np.dtype[_ScalarT]], type_params=(_ScalarT,)) - -MArray = TypeAliasType("MArray", np.ma.MaskedArray[ShapeC, np.dtype[_ScalarT]], type_params=(_ScalarT, ShapeC)) -MArray0 = TypeAliasType("MArray0", np.ma.MaskedArray[NDim0, np.dtype[_ScalarT]], type_params=(_ScalarT,)) -MArray1 = TypeAliasType("MArray1", np.ma.MaskedArray[NDim1, np.dtype[_ScalarT]], type_params=(_ScalarT,)) -MArray2 = TypeAliasType("MArray2", np.ma.MaskedArray[NDim2, np.dtype[_ScalarT]], type_params=(_ScalarT,)) -MArray3 = TypeAliasType("MArray3", np.ma.MaskedArray[NDim3, np.dtype[_ScalarT]], type_params=(_ScalarT,)) - -Matrix = TypeAliasType("Matrix", np.matrix[tuple[int, int], np.dtype[_ScalarT]], type_params=(_ScalarT,)) +_ToArray_0d = TypeAliasType("_ToArray_0d", _ToT | CanArray[_ScalarT, tuple[()]], type_params=(_ScalarT, _ToT)) +_ToArray_1d: TypeAlias = CanArraySized[_ScalarT, tuple[int]] | Sequence[_ToArray_0d[_ScalarT, _ToT]] +_ToArray_2d: TypeAlias = CanArraySized[_ScalarT, tuple[int, int]] | Sequence[_ToArray_1d[_ScalarT, _ToT]] +_ToArray_3d: TypeAlias = CanArraySized[_ScalarT, tuple[int, int, int]] | Sequence[_ToArray_2d[_ScalarT, _ToT]] +_ToArray_nd: TypeAlias = CanArraySized[_ScalarT] | NDSequence[_ToT | _ScalarT] | NDSequence[CanArray[_ScalarT]] ### # Non-overlapping scalar- and array-like aliases for all scalar types. -AsBool = TypeAliasType("AsBool", _To2_0d[np.bool, bool]) -AsBool_1d = TypeAliasType("AsBool_1d", _To2_1d[np.bool, bool]) -AsBool_2d = TypeAliasType("AsBool_2d", _To2_2d[np.bool, bool]) -AsBool_3d = TypeAliasType("AsBool_3d", _To2_3d[np.bool, bool]) -AsBool_nd = TypeAliasType("AsBool_nd", _To2_nd[np.bool, bool]) +# bool +_ToBool: TypeAlias = np.bool[Any] +ToBool_0d = TypeAliasType("ToBool_0d", _ToArray_0d[_ToBool, bool]) +ToBool_1d = TypeAliasType("ToBool_1d", _ToArray_1d[_ToBool, bool]) +ToBool_2d = TypeAliasType("ToBool_2d", _ToArray_2d[_ToBool, bool]) +ToBool_3d = TypeAliasType("ToBool_3d", _ToArray_3d[_ToBool, bool]) +ToBool_nd = TypeAliasType("ToBool_nd", _ToArray_nd[_ToBool, bool]) # unsigned integers -AsUInt8 = TypeAliasType("AsUInt8", _To1_0d[np.uint8]) -AsUInt8_1d = TypeAliasType("AsUInt8_1d", _To1_1d[np.uint8]) -AsUInt8_2d = TypeAliasType("AsUInt8_2d", _To1_2d[np.uint8]) -AsUInt8_3d = TypeAliasType("AsUInt8_3d", _To1_3d[np.uint8]) -AsUInt8_nd = TypeAliasType("AsUInt8_nd", _To1_nd[np.uint8]) - -AsUInt16 = TypeAliasType("AsUInt16", _To1_0d[np.uint16]) -AsUInt16_1d = TypeAliasType("AsUInt16_1d", _To1_1d[np.uint16]) -AsUInt16_2d = TypeAliasType("AsUInt16_2d", _To1_2d[np.uint16]) -AsUInt16_3d = TypeAliasType("AsUInt16_3d", _To1_3d[np.uint16]) -AsUInt16_nd = TypeAliasType("AsUInt16_nd", _To1_nd[np.uint16]) - -AsUInt32 = TypeAliasType("AsUInt32", _To1_0d[np.uint32]) -AsUInt32_1d = TypeAliasType("AsUInt32_1d", _To1_1d[np.uint32]) -AsUInt32_2d = TypeAliasType("AsUInt32_2d", _To1_2d[np.uint32]) -AsUInt32_3d = TypeAliasType("AsUInt32_3d", _To1_3d[np.uint32]) -AsUInt32_nd = TypeAliasType("AsUInt32_nd", _To1_nd[np.uint32]) - -AsUInt64 = TypeAliasType("AsUInt64", _To1_0d[np.uint64]) -AsUInt64_1d = TypeAliasType("AsUInt64_1d", _To1_1d[np.uint64]) -AsUInt64_2d = TypeAliasType("AsUInt64_2d", _To1_2d[np.uint64]) -AsUInt64_3d = TypeAliasType("AsUInt64_3d", _To1_3d[np.uint64]) -AsUInt64_nd = TypeAliasType("AsUInt64_nd", _To1_nd[np.uint64]) - -AsULong = TypeAliasType("AsULong", _To1_0d[np.ulong]) -AsULong_1d = TypeAliasType("AsULong_1d", _To1_1d[np.ulong]) -AsULong_2d = TypeAliasType("AsULong_2d", _To1_2d[np.ulong]) -AsULong_3d = TypeAliasType("AsULong_3d", _To1_3d[np.ulong]) -AsULong_nd = TypeAliasType("AsULong_nd", _To1_nd[np.ulong]) - -AsUIntP = TypeAliasType("AsUIntP", _To1_0d[np.uintp]) -AsUIntP_1d = TypeAliasType("AsUIntP_1d", _To1_1d[np.uintp]) -AsUIntP_2d = TypeAliasType("AsUIntP_2d", _To1_2d[np.uintp]) -AsUIntP_3d = TypeAliasType("AsUIntP_3d", _To1_3d[np.uintp]) -AsUIntP_nd = TypeAliasType("AsUIntP_nd", _To1_nd[np.uintp]) - -AsULongLong = TypeAliasType("AsULongLong", _To1_0d[np.ulonglong]) -AsULongLong_1d = TypeAliasType("AsULongLong_1d", _To1_1d[np.ulonglong]) -AsULongLong_2d = TypeAliasType("AsULongLong_2d", _To1_2d[np.ulonglong]) -AsULongLong_3d = TypeAliasType("AsULongLong_3d", _To1_3d[np.ulonglong]) -AsULongLong_nd = TypeAliasType("AsULongLong_nd", _To1_nd[np.ulonglong]) - -AsUInteger = TypeAliasType("AsUInteger", _To1_0d[np.unsignedinteger]) -AsUInteger_1d = TypeAliasType("AsUInteger_1d", _To1_1d[np.unsignedinteger]) -AsUInteger_2d = TypeAliasType("AsUInteger_2d", _To1_2d[np.unsignedinteger]) -AsUInteger_3d = TypeAliasType("AsUInteger_3d", _To1_3d[np.unsignedinteger]) -AsUInteger_nd = TypeAliasType("AsUInteger_nd", _To1_nd[np.unsignedinteger]) +ToUInt8_0d = TypeAliasType("ToUInt8_0d", _ToArray_0d[np.uint8]) +ToUInt8_1d = TypeAliasType("ToUInt8_1d", _ToArray_1d[np.uint8]) +ToUInt8_2d = TypeAliasType("ToUInt8_2d", _ToArray_2d[np.uint8]) +ToUInt8_3d = TypeAliasType("ToUInt8_3d", _ToArray_3d[np.uint8]) +ToUInt8_nd = TypeAliasType("ToUInt8_nd", _ToArray_nd[np.uint8]) + +ToUInt16_0d = TypeAliasType("ToUInt16_0d", _ToArray_0d[np.uint16]) +ToUInt16_1d = TypeAliasType("ToUInt16_1d", _ToArray_1d[np.uint16]) +ToUInt16_2d = TypeAliasType("ToUInt16_2d", _ToArray_2d[np.uint16]) +ToUInt16_3d = TypeAliasType("ToUInt16_3d", _ToArray_3d[np.uint16]) +ToUInt16_nd = TypeAliasType("ToUInt16_nd", _ToArray_nd[np.uint16]) + +ToUInt32_0d = TypeAliasType("ToUInt32_0d", _ToArray_0d[np.uint32]) +ToUInt32_1d = TypeAliasType("ToUInt32_1d", _ToArray_1d[np.uint32]) +ToUInt32_2d = TypeAliasType("ToUInt32_2d", _ToArray_2d[np.uint32]) +ToUInt32_3d = TypeAliasType("ToUInt32_3d", _ToArray_3d[np.uint32]) +ToUInt32_nd = TypeAliasType("ToUInt32_nd", _ToArray_nd[np.uint32]) + +ToUInt64_0d = TypeAliasType("ToUInt64_0d", _ToArray_0d[np.uint64]) +ToUInt64_1d = TypeAliasType("ToUInt64_1d", _ToArray_1d[np.uint64]) +ToUInt64_2d = TypeAliasType("ToUInt64_2d", _ToArray_2d[np.uint64]) +ToUInt64_3d = TypeAliasType("ToUInt64_3d", _ToArray_3d[np.uint64]) +ToUInt64_nd = TypeAliasType("ToUInt64_nd", _ToArray_nd[np.uint64]) + +ToULong_0d = TypeAliasType("ToULong_0d", _ToArray_0d[np.ulong]) +ToULong_1d = TypeAliasType("ToULong_1d", _ToArray_1d[np.ulong]) +ToULong_2d = TypeAliasType("ToULong_2d", _ToArray_2d[np.ulong]) +ToULong_3d = TypeAliasType("ToULong_3d", _ToArray_3d[np.ulong]) +ToULong_nd = TypeAliasType("ToULong_nd", _ToArray_nd[np.ulong]) + +ToUIntP_0d = TypeAliasType("ToUIntP_0d", _ToArray_0d[np.uintp]) +ToUIntP_1d = TypeAliasType("ToUIntP_1d", _ToArray_1d[np.uintp]) +ToUIntP_2d = TypeAliasType("ToUIntP_2d", _ToArray_2d[np.uintp]) +ToUIntP_3d = TypeAliasType("ToUIntP_3d", _ToArray_3d[np.uintp]) +ToUIntP_nd = TypeAliasType("ToUIntP_nd", _ToArray_nd[np.uintp]) + +ToULongLong_0d = TypeAliasType("ToULongLong_0d", _ToArray_0d[np.ulonglong]) +ToULongLong_1d = TypeAliasType("ToULongLong_1d", _ToArray_1d[np.ulonglong]) +ToULongLong_2d = TypeAliasType("ToULongLong_2d", _ToArray_2d[np.ulonglong]) +ToULongLong_3d = TypeAliasType("ToULongLong_3d", _ToArray_3d[np.ulonglong]) +ToULongLong_nd = TypeAliasType("ToULongLong_nd", _ToArray_nd[np.ulonglong]) + +ToUInteger_0d = TypeAliasType("ToUInteger_0d", _ToArray_0d[np.unsignedinteger]) +ToUInteger_1d = TypeAliasType("ToUInteger_1d", _ToArray_1d[np.unsignedinteger]) +ToUInteger_2d = TypeAliasType("ToUInteger_2d", _ToArray_2d[np.unsignedinteger]) +ToUInteger_3d = TypeAliasType("ToUInteger_3d", _ToArray_3d[np.unsignedinteger]) +ToUInteger_nd = TypeAliasType("ToUInteger_nd", _ToArray_nd[np.unsignedinteger]) # signed integers -AsInt8 = TypeAliasType("AsInt8", _To1_0d[np.int8]) -AsInt8_1d = TypeAliasType("AsInt8_1d", _To1_1d[np.int8]) -AsInt8_2d = TypeAliasType("AsInt8_2d", _To1_2d[np.int8]) -AsInt8_3d = TypeAliasType("AsInt8_3d", _To1_3d[np.int8]) -AsInt8_nd = TypeAliasType("AsInt8_nd", _To1_nd[np.int8]) - -AsInt16 = TypeAliasType("AsInt16", _To1_0d[np.int16]) -AsInt16_1d = TypeAliasType("AsInt16_1d", _To1_1d[np.int16]) -AsInt16_2d = TypeAliasType("AsInt16_2d", _To1_2d[np.int16]) -AsInt16_3d = TypeAliasType("AsInt16_3d", _To1_3d[np.int16]) -AsInt16_nd = TypeAliasType("AsInt16_nd", _To1_nd[np.int16]) - -AsInt32 = TypeAliasType("AsInt32", _To1_0d[np.int32]) -AsInt32_1d = TypeAliasType("AsInt32_1d", _To1_1d[np.int32]) -AsInt32_2d = TypeAliasType("AsInt32_2d", _To1_2d[np.int32]) -AsInt32_3d = TypeAliasType("AsInt32_3d", _To1_3d[np.int32]) -AsInt32_nd = TypeAliasType("AsInt32_nd", _To1_nd[np.int32]) - -AsInt64 = TypeAliasType("AsInt64", _To1_0d[np.int64]) -AsInt64_1d = TypeAliasType("AsInt64_1d", _To1_1d[np.int64]) -AsInt64_2d = TypeAliasType("AsInt64_2d", _To1_2d[np.int64]) -AsInt64_3d = TypeAliasType("AsInt64_3d", _To1_3d[np.int64]) -AsInt64_nd = TypeAliasType("AsInt64_nd", _To1_nd[np.int64]) - -AsLong = TypeAliasType("AsLong", _To1_0d[np.long]) -AsLong_1d = TypeAliasType("AsLong_1d", _To1_1d[np.long]) -AsLong_2d = TypeAliasType("AsLong_2d", _To1_2d[np.long]) -AsLong_3d = TypeAliasType("AsLong_3d", _To1_3d[np.long]) -AsLong_nd = TypeAliasType("AsLong_nd", _To1_nd[np.long]) - -AsIntP = TypeAliasType("AsIntP", _To2_0d[np.intp, Is[int]]) -AsIntP_1d = TypeAliasType("AsIntP_1d", _To2_1d[np.intp, Is[int]]) -AsIntP_2d = TypeAliasType("AsIntP_2d", _To2_2d[np.intp, Is[int]]) -AsIntP_3d = TypeAliasType("AsIntP_3d", _To2_3d[np.intp, Is[int]]) -AsIntP_nd = TypeAliasType("AsIntP_nd", _To2_nd[np.intp, Is[int]]) - -AsLongLong = TypeAliasType("AsLongLong", _To1_0d[np.longlong]) -AsLongLong_1d = TypeAliasType("AsLongLong_1d", _To1_1d[np.longlong]) -AsLongLong_2d = TypeAliasType("AsLongLong_2d", _To1_2d[np.longlong]) -AsLongLong_3d = TypeAliasType("AsLongLong_3d", _To1_3d[np.longlong]) -AsLongLong_nd = TypeAliasType("AsLongLong_nd", _To1_nd[np.longlong]) - -AsSInteger = TypeAliasType("AsSInteger", _To2_0d[np.signedinteger, Is[int]]) -AsSInteger_1d = TypeAliasType("AsSInteger_1d", _To2_1d[np.signedinteger, Is[int]]) -AsSInteger_2d = TypeAliasType("AsSInteger_2d", _To2_2d[np.signedinteger, Is[int]]) -AsSInteger_3d = TypeAliasType("AsSInteger_3d", _To2_3d[np.signedinteger, Is[int]]) -AsSInteger_nd = TypeAliasType("AsSInteger_nd", _To2_nd[np.signedinteger, Is[int]]) +ToInt8_0d = TypeAliasType("ToInt8_0d", _ToArray_0d[np.int8]) +ToInt8_1d = TypeAliasType("ToInt8_1d", _ToArray_1d[np.int8]) +ToInt8_2d = TypeAliasType("ToInt8_2d", _ToArray_2d[np.int8]) +ToInt8_3d = TypeAliasType("ToInt8_3d", _ToArray_3d[np.int8]) +ToInt8_nd = TypeAliasType("ToInt8_nd", _ToArray_nd[np.int8]) + +ToInt16_0d = TypeAliasType("ToInt16_0d", _ToArray_0d[np.int16]) +ToInt16_1d = TypeAliasType("ToInt16_1d", _ToArray_1d[np.int16]) +ToInt16_2d = TypeAliasType("ToInt16_2d", _ToArray_2d[np.int16]) +ToInt16_3d = TypeAliasType("ToInt16_3d", _ToArray_3d[np.int16]) +ToInt16_nd = TypeAliasType("ToInt16_nd", _ToArray_nd[np.int16]) + +ToInt32_0d = TypeAliasType("ToInt32_0d", _ToArray_0d[np.int32]) +ToInt32_1d = TypeAliasType("ToInt32_1d", _ToArray_1d[np.int32]) +ToInt32_2d = TypeAliasType("ToInt32_2d", _ToArray_2d[np.int32]) +ToInt32_3d = TypeAliasType("ToInt32_3d", _ToArray_3d[np.int32]) +ToInt32_nd = TypeAliasType("ToInt32_nd", _ToArray_nd[np.int32]) + +ToInt64_0d = TypeAliasType("ToInt64_0d", _ToArray_0d[np.int64]) +ToInt64_1d = TypeAliasType("ToInt64_1d", _ToArray_1d[np.int64]) +ToInt64_2d = TypeAliasType("ToInt64_2d", _ToArray_2d[np.int64]) +ToInt64_3d = TypeAliasType("ToInt64_3d", _ToArray_3d[np.int64]) +ToInt64_nd = TypeAliasType("ToInt64_nd", _ToArray_nd[np.int64]) + +ToLong_0d = TypeAliasType("ToLong_0d", _ToArray_0d[np.long]) +ToLong_1d = TypeAliasType("ToLong_1d", _ToArray_1d[np.long]) +ToLong_2d = TypeAliasType("ToLong_2d", _ToArray_2d[np.long]) +ToLong_3d = TypeAliasType("ToLong_3d", _ToArray_3d[np.long]) +ToLong_nd = TypeAliasType("ToLong_nd", _ToArray_nd[np.long]) + +_ToIntP: TypeAlias = np.intp | Is[int] +ToIntP_0d = TypeAliasType("ToIntP_0d", _ToArray_0d[np.intp, _ToIntP]) +ToIntP_1d = TypeAliasType("ToIntP_1d", _ToArray_1d[np.intp, _ToIntP]) +ToIntP_2d = TypeAliasType("ToIntP_2d", _ToArray_2d[np.intp, _ToIntP]) +ToIntP_3d = TypeAliasType("ToIntP_3d", _ToArray_3d[np.intp, _ToIntP]) +ToIntP_nd = TypeAliasType("ToIntP_nd", _ToArray_nd[np.intp, _ToIntP]) + +ToLongLong_0d = TypeAliasType("ToLongLong_0d", _ToArray_0d[np.longlong]) +ToLongLong_1d = TypeAliasType("ToLongLong_1d", _ToArray_1d[np.longlong]) +ToLongLong_2d = TypeAliasType("ToLongLong_2d", _ToArray_2d[np.longlong]) +ToLongLong_3d = TypeAliasType("ToLongLong_3d", _ToArray_3d[np.longlong]) +ToLongLong_nd = TypeAliasType("ToLongLong_nd", _ToArray_nd[np.longlong]) + +_ToInteger: TypeAlias = np.signedinteger | Is[int] +ToSInteger_0d = TypeAliasType("ToSInteger_0d", _ToArray_0d[np.signedinteger, _ToInteger]) +ToSInteger_1d = TypeAliasType("ToSInteger_1d", _ToArray_1d[np.signedinteger, _ToInteger]) +ToSInteger_2d = TypeAliasType("ToSInteger_2d", _ToArray_2d[np.signedinteger, _ToInteger]) +ToSInteger_3d = TypeAliasType("ToSInteger_3d", _ToArray_3d[np.signedinteger, _ToInteger]) +ToSInteger_nd = TypeAliasType("ToSInteger_nd", _ToArray_nd[np.signedinteger, _ToInteger]) # integers -AsInteger = TypeAliasType("AsInteger", _To2_0d[np.integer, Is[int]]) -AsInteger_1d = TypeAliasType("AsInteger_1d", _To2_1d[np.integer, Is[int]]) -AsInteger_2d = TypeAliasType("AsInteger_2d", _To2_2d[np.integer, Is[int]]) -AsInteger_3d = TypeAliasType("AsInteger_3d", _To2_3d[np.integer, Is[int]]) -AsInteger_nd = TypeAliasType("AsInteger_nd", _To2_nd[np.integer, Is[int]]) +ToInteger_0d = TypeAliasType("ToInteger_0d", _ToArray_0d[np.integer, Is[int]]) +ToInteger_1d = TypeAliasType("ToInteger_1d", _ToArray_1d[np.integer, Is[int]]) +ToInteger_2d = TypeAliasType("ToInteger_2d", _ToArray_2d[np.integer, Is[int]]) +ToInteger_3d = TypeAliasType("ToInteger_3d", _ToArray_3d[np.integer, Is[int]]) +ToInteger_nd = TypeAliasType("ToInteger_nd", _ToArray_nd[np.integer, Is[int]]) # real floats -AsFloat16 = TypeAliasType("AsFloat16", _To1_0d[np.float16]) -AsFloat16_1d = TypeAliasType("AsFloat16_1d", _To1_1d[np.float16]) -AsFloat16_2d = TypeAliasType("AsFloat16_2d", _To1_2d[np.float16]) -AsFloat16_3d = TypeAliasType("AsFloat16_3d", _To1_3d[np.float16]) -AsFloat16_nd = TypeAliasType("AsFloat16_nd", _To1_nd[np.float16]) - -AsFloat32 = TypeAliasType("AsFloat32", _To1_0d[np.float32]) -AsFloat32_1d = TypeAliasType("AsFloat32_1d", _To1_1d[np.float32]) -AsFloat32_2d = TypeAliasType("AsFloat32_2d", _To1_2d[np.float32]) -AsFloat32_3d = TypeAliasType("AsFloat32_3d", _To1_3d[np.float32]) -AsFloat32_nd = TypeAliasType("AsFloat32_nd", _To1_nd[np.float32]) - -AsFloat = TypeAliasType("AsFloat", _To2_0d[_AsFloat64, Is[float]]) -AsFloat_1d = TypeAliasType("AsFloat_1d", _To2_1d[_AsFloat64, Is[float]]) -AsFloat_2d = TypeAliasType("AsFloat_2d", _To2_2d[_AsFloat64, Is[float]]) -AsFloat_3d = TypeAliasType("AsFloat_3d", _To2_3d[_AsFloat64, Is[float]]) -AsFloat_nd = TypeAliasType("AsFloat_nd", _To2_nd[_AsFloat64, Is[float]]) - -AsLongDouble = TypeAliasType("AsLongDouble", _To1_0d[np.longdouble]) -AsLongDouble_1d = TypeAliasType("AsLongDouble_1d", _To1_1d[np.longdouble]) -AsLongDouble_2d = TypeAliasType("AsLongDouble_2d", _To1_2d[np.longdouble]) -AsLongDouble_3d = TypeAliasType("AsLongDouble_3d", _To1_3d[np.longdouble]) -AsLongDouble_nd = TypeAliasType("AsLongDouble_nd", _To1_nd[np.longdouble]) - -AsFloating = TypeAliasType("AsFloating", _To2_0d[np.floating, Is[float]]) -AsFloating_1d = TypeAliasType("AsFloating_1d", _To2_1d[np.floating, Is[float]]) -AsFloating_2d = TypeAliasType("AsFloating_2d", _To2_2d[np.floating, Is[float]]) -AsFloating_3d = TypeAliasType("AsFloating_3d", _To2_3d[np.floating, Is[float]]) -AsFloating_nd = TypeAliasType("AsFloating_nd", _To2_nd[np.floating, Is[float]]) +ToFloat16_0d = TypeAliasType("ToFloat16_0d", _ToArray_0d[np.float16]) +ToFloat16_1d = TypeAliasType("ToFloat16_1d", _ToArray_1d[np.float16]) +ToFloat16_2d = TypeAliasType("ToFloat16_2d", _ToArray_2d[np.float16]) +ToFloat16_3d = TypeAliasType("ToFloat16_3d", _ToArray_3d[np.float16]) +ToFloat16_nd = TypeAliasType("ToFloat16_nd", _ToArray_nd[np.float16]) + +ToFloat32_0d = TypeAliasType("ToFloat32_0d", _ToArray_0d[np.float32]) +ToFloat32_1d = TypeAliasType("ToFloat32_1d", _ToArray_1d[np.float32]) +ToFloat32_2d = TypeAliasType("ToFloat32_2d", _ToArray_2d[np.float32]) +ToFloat32_3d = TypeAliasType("ToFloat32_3d", _ToArray_3d[np.float32]) +ToFloat32_nd = TypeAliasType("ToFloat32_nd", _ToArray_nd[np.float32]) + +_ToFloat64: TypeAlias = np.floating[_64Bit] +ToFloat64_0d = TypeAliasType("ToFloat64_0d", _ToArray_0d[_ToFloat64, Is[float]]) +ToFloat64_1d = TypeAliasType("ToFloat64_1d", _ToArray_1d[_ToFloat64, Is[float]]) +ToFloat64_2d = TypeAliasType("ToFloat64_2d", _ToArray_2d[_ToFloat64, Is[float]]) +ToFloat64_3d = TypeAliasType("ToFloat64_3d", _ToArray_3d[_ToFloat64, Is[float]]) +ToFloat64_nd = TypeAliasType("ToFloat64_nd", _ToArray_nd[_ToFloat64, Is[float]]) + +ToLongDouble_0d = TypeAliasType("ToLongDouble_0d", _ToArray_0d[np.longdouble]) +ToLongDouble_1d = TypeAliasType("ToLongDouble_1d", _ToArray_1d[np.longdouble]) +ToLongDouble_2d = TypeAliasType("ToLongDouble_2d", _ToArray_2d[np.longdouble]) +ToLongDouble_3d = TypeAliasType("ToLongDouble_3d", _ToArray_3d[np.longdouble]) +ToLongDouble_nd = TypeAliasType("ToLongDouble_nd", _ToArray_nd[np.longdouble]) + +ToFloating_0d = TypeAliasType("ToFloating_0d", _ToArray_0d[np.floating, Is[float]]) +ToFloating_1d = TypeAliasType("ToFloating_1d", _ToArray_1d[np.floating, Is[float]]) +ToFloating_2d = TypeAliasType("ToFloating_2d", _ToArray_2d[np.floating, Is[float]]) +ToFloating_3d = TypeAliasType("ToFloating_3d", _ToArray_3d[np.floating, Is[float]]) +ToFloating_nd = TypeAliasType("ToFloating_nd", _ToArray_nd[np.floating, Is[float]]) # complex floats -AsComplex64 = TypeAliasType("AsComplex64", _To1_0d[np.complex64]) -AsComplex64_1d = TypeAliasType("AsComplex64_1d", _To1_1d[np.complex64]) -AsComplex64_2d = TypeAliasType("AsComplex64_2d", _To1_2d[np.complex64]) -AsComplex64_3d = TypeAliasType("AsComplex64_3d", _To1_3d[np.complex64]) -AsComplex64_nd = TypeAliasType("AsComplex64_nd", _To1_nd[np.complex64]) - -AsComplex = TypeAliasType("AsComplex", _To2_0d[_AsComplex128, Is[complex]]) -AsComplex_1d = TypeAliasType("AsComplex_1d", _To2_1d[_AsComplex128, Is[complex]]) -AsComplex_2d = TypeAliasType("AsComplex_2d", _To2_2d[_AsComplex128, Is[complex]]) -AsComplex_3d = TypeAliasType("AsComplex_3d", _To2_3d[_AsComplex128, Is[complex]]) -AsComplex_nd = TypeAliasType("AsComplex_nd", _To2_nd[_AsComplex128, Is[complex]]) - -AsCLongDouble = TypeAliasType("AsCLongDouble", _To1_0d[np.clongdouble]) -AsCLongDouble_1d = TypeAliasType("AsCLongDouble_1d", _To1_1d[np.clongdouble]) -AsCLongDouble_2d = TypeAliasType("AsCLongDouble_2d", _To1_2d[np.clongdouble]) -AsCLongDouble_3d = TypeAliasType("AsCLongDouble_3d", _To1_3d[np.clongdouble]) -AsCLongDouble_nd = TypeAliasType("AsCLongDouble_nd", _To1_nd[np.clongdouble]) - -AsCFloating = TypeAliasType("AsCFloating", _To2_0d[np.complexfloating, Is[complex]]) -AsCFloating_1d = TypeAliasType("AsCFloating_1d", _To2_1d[np.complexfloating, Is[complex]]) -AsCFloating_2d = TypeAliasType("AsCFloating_2d", _To2_2d[np.complexfloating, Is[complex]]) -AsCFloating_3d = TypeAliasType("AsCFloating_3d", _To2_3d[np.complexfloating, Is[complex]]) -AsCFloating_nd = TypeAliasType("AsCFloating_nd", _To2_nd[np.complexfloating, Is[complex]]) +ToComplex64_0d = TypeAliasType("ToComplex64_0d", _ToArray_0d[np.complex64]) +ToComplex64_1d = TypeAliasType("ToComplex64_1d", _ToArray_1d[np.complex64]) +ToComplex64_2d = TypeAliasType("ToComplex64_2d", _ToArray_2d[np.complex64]) +ToComplex64_3d = TypeAliasType("ToComplex64_3d", _ToArray_3d[np.complex64]) +ToComplex64_nd = TypeAliasType("ToComplex64_nd", _ToArray_nd[np.complex64]) + +_ToComplex128: TypeAlias = np.complexfloating[_64Bit] +ToComplex128_0d = TypeAliasType("ToComplex128_0d", _ToArray_0d[_ToComplex128, Is[complex]]) +ToComplex128_1d = TypeAliasType("ToComplex128_1d", _ToArray_1d[_ToComplex128, Is[complex]]) +ToComplex128_2d = TypeAliasType("ToComplex128_2d", _ToArray_2d[_ToComplex128, Is[complex]]) +ToComplex128_3d = TypeAliasType("ToComplex128_3d", _ToArray_3d[_ToComplex128, Is[complex]]) +ToComplex128_nd = TypeAliasType("ToComplex128_nd", _ToArray_nd[_ToComplex128, Is[complex]]) + +ToCLongDouble_0d = TypeAliasType("ToCLongDouble_0d", _ToArray_0d[np.clongdouble]) +ToCLongDouble_1d = TypeAliasType("ToCLongDouble_1d", _ToArray_1d[np.clongdouble]) +ToCLongDouble_2d = TypeAliasType("ToCLongDouble_2d", _ToArray_2d[np.clongdouble]) +ToCLongDouble_3d = TypeAliasType("ToCLongDouble_3d", _ToArray_3d[np.clongdouble]) +ToCLongDouble_nd = TypeAliasType("ToCLongDouble_nd", _ToArray_nd[np.clongdouble]) + +ToCFloating_0d = TypeAliasType("ToCFloating_0d", _ToArray_0d[np.complexfloating, Is[complex]]) +ToCFloating_1d = TypeAliasType("ToCFloating_1d", _ToArray_1d[np.complexfloating, Is[complex]]) +ToCFloating_2d = TypeAliasType("ToCFloating_2d", _ToArray_2d[np.complexfloating, Is[complex]]) +ToCFloating_3d = TypeAliasType("ToCFloating_3d", _ToArray_3d[np.complexfloating, Is[complex]]) +ToCFloating_nd = TypeAliasType("ToCFloating_nd", _ToArray_nd[np.complexfloating, Is[complex]]) + +# integers, real- and complex floats +ToNumber_0d = TypeAliasType("ToNumber_0d", _ToArray_0d[np.number, _PyNumber]) +ToNumber_1d = TypeAliasType("ToNumber_1d", _ToArray_1d[np.number, _PyNumber]) +ToNumber_2d = TypeAliasType("ToNumber_2d", _ToArray_2d[np.number, _PyNumber]) +ToNumber_3d = TypeAliasType("ToNumber_3d", _ToArray_3d[np.number, _PyNumber]) +ToNumber_nd = TypeAliasType("ToNumber_nd", _ToArray_nd[np.number, _PyNumber]) # integers and real floats -AsReal = TypeAliasType("AsReal", _To2_0d[np.number[Any, float | int], _PyReal]) -AsReal_1d = TypeAliasType("AsReal_1d", _To2_1d[np.number[Any, float | int], _PyReal]) -AsReal_2d = TypeAliasType("AsReal_2d", _To2_2d[np.number[Any, float | int], _PyReal]) -AsReal_3d = TypeAliasType("AsReal_3d", _To2_3d[np.number[Any, float | int], _PyReal]) -AsReal_nd = TypeAliasType("AsReal_nd", _To2_nd[np.number[Any, float | int], _PyReal]) +ToReal_0d = TypeAliasType("ToReal_0d", _ToArray_0d[np.number[Any, float | int], _PyReal]) +ToReal_1d = TypeAliasType("ToReal_1d", _ToArray_1d[np.number[Any, float | int], _PyReal]) +ToReal_2d = TypeAliasType("ToReal_2d", _ToArray_2d[np.number[Any, float | int], _PyReal]) +ToReal_3d = TypeAliasType("ToReal_3d", _ToArray_3d[np.number[Any, float | int], _PyReal]) +ToReal_nd = TypeAliasType("ToReal_nd", _ToArray_nd[np.number[Any, float | int], _PyReal]) # real- and complex floats -AsInexact = TypeAliasType("AsInexact", _To2_0d[np.inexact, _PyInexact]) -AsInexact_1d = TypeAliasType("AsInexact_1d", _To2_1d[np.inexact, _PyInexact]) -AsInexact_2d = TypeAliasType("AsInexact_2d", _To2_2d[np.inexact, _PyInexact]) -AsInexact_3d = TypeAliasType("AsInexact_3d", _To2_3d[np.inexact, _PyInexact]) -AsInexact_nd = TypeAliasType("AsInexact_nd", _To2_nd[np.inexact, _PyInexact]) - -# integers, real- and complex floats -AsNumber = TypeAliasType("AsNumber", _To2_0d[np.number, _PyNumber]) -AsNumber_1d = TypeAliasType("AsNumber_1d", _To2_1d[np.number, _PyNumber]) -AsNumber_2d = TypeAliasType("AsNumber_2d", _To2_2d[np.number, _PyNumber]) -AsNumber_3d = TypeAliasType("AsNumber_3d", _To2_3d[np.number, _PyNumber]) -AsNumber_nd = TypeAliasType("AsNumber_nd", _To2_nd[np.number, _PyNumber]) +ToInexact_0d = TypeAliasType("ToInexact_0d", _ToArray_0d[np.inexact, _PyInexact]) +ToInexact_1d = TypeAliasType("ToInexact_1d", _ToArray_1d[np.inexact, _PyInexact]) +ToInexact_2d = TypeAliasType("ToInexact_2d", _ToArray_2d[np.inexact, _PyInexact]) +ToInexact_3d = TypeAliasType("ToInexact_3d", _ToArray_3d[np.inexact, _PyInexact]) +ToInexact_nd = TypeAliasType("ToInexact_nd", _ToArray_nd[np.inexact, _PyInexact]) # temporal -AsTimeDelta = TypeAliasType("AsTimeDelta", _To1_0d[np.timedelta64]) -AsTimeDelta_1d = TypeAliasType("AsTimeDelta_1d", _To1_1d[np.timedelta64]) -AsTimeDelta_2d = TypeAliasType("AsTimeDelta_2d", _To1_2d[np.timedelta64]) -AsTimeDelta_3d = TypeAliasType("AsTimeDelta_3d", _To1_3d[np.timedelta64]) -AsTimeDelta_nd = TypeAliasType("AsTimeDelta_nd", _To1_nd[np.timedelta64]) - -AsDateTime = TypeAliasType("AsDateTime", _To1_0d[np.datetime64]) -AsDateTime_1d = TypeAliasType("AsDateTime_1d", _To1_1d[np.datetime64]) -AsDateTime_2d = TypeAliasType("AsDateTime_2d", _To1_2d[np.datetime64]) -AsDateTime_3d = TypeAliasType("AsDateTime_3d", _To1_3d[np.datetime64]) -AsDateTime_nd = TypeAliasType("AsDateTime_nd", _To1_nd[np.datetime64]) +_ToTimeDelta: TypeAlias = np.timedelta64[Any] +ToTimeDelta_0d = TypeAliasType("ToTimeDelta_0d", _ToArray_0d[np.timedelta64]) +ToTimeDelta_1d = TypeAliasType("ToTimeDelta_1d", _ToArray_1d[np.timedelta64]) +ToTimeDelta_2d = TypeAliasType("ToTimeDelta_2d", _ToArray_2d[np.timedelta64]) +ToTimeDelta_3d = TypeAliasType("ToTimeDelta_3d", _ToArray_3d[np.timedelta64]) +ToTimeDelta_nd = TypeAliasType("ToTimeDelta_nd", _ToArray_nd[np.timedelta64]) + +_ToDateTime: TypeAlias = np.datetime64[Any] +ToDateTime_0d = TypeAliasType("ToDateTime_0d", _ToArray_0d[np.datetime64]) +ToDateTime_1d = TypeAliasType("ToDateTime_1d", _ToArray_1d[np.datetime64]) +ToDateTime_2d = TypeAliasType("ToDateTime_2d", _ToArray_2d[np.datetime64]) +ToDateTime_3d = TypeAliasType("ToDateTime_3d", _ToArray_3d[np.datetime64]) +ToDateTime_nd = TypeAliasType("ToDateTime_nd", _ToArray_nd[np.datetime64]) # fixed strings -AsBytes = TypeAliasType("AsBytes", _To2_0d[np.character[bytes], Is[bytes]]) -AsBytes_1d = TypeAliasType("AsBytes_1d", _To2_1d[np.character[bytes], Is[bytes]]) -AsBytes_2d = TypeAliasType("AsBytes_2d", _To2_2d[np.character[bytes], Is[bytes]]) -AsBytes_3d = TypeAliasType("AsBytes_3d", _To2_3d[np.character[bytes], Is[bytes]]) -AsBytes_nd = TypeAliasType("AsBytes_nd", _To2_nd[np.character[bytes], Is[bytes]]) - -AsStr = TypeAliasType("AsStr", _To2_0d[np.character[str], Is[str]]) -AsStr_1d = TypeAliasType("AsStr_1d", _To2_1d[np.character[str], Is[str]]) -AsStr_2d = TypeAliasType("AsStr_2d", _To2_2d[np.character[str], Is[str]]) -AsStr_3d = TypeAliasType("AsStr_3d", _To2_3d[np.character[str], Is[str]]) -AsStr_nd = TypeAliasType("AsStr_nd", _To2_nd[np.character[str], Is[str]]) - -AsCharacter = TypeAliasType("AsCharacter", _To2_0d[np.character, _PyCharacter]) -AsCharacter_1d = TypeAliasType("AsCharacter_1d", _To2_1d[np.character, _PyCharacter]) -AsCharacter_2d = TypeAliasType("AsCharacter_2d", _To2_2d[np.character, _PyCharacter]) -AsCharacter_3d = TypeAliasType("AsCharacter_3d", _To2_3d[np.character, _PyCharacter]) -AsCharacter_nd = TypeAliasType("AsCharacter_nd", _To2_nd[np.character, _PyCharacter]) +_ToBytes: TypeAlias = np.character[bytes] +ToBytes_0d = TypeAliasType("ToBytes_0d", _ToArray_0d[_ToBytes, Is[bytes]]) +ToBytes_1d = TypeAliasType("ToBytes_1d", _ToArray_1d[_ToBytes, Is[bytes]]) +ToBytes_2d = TypeAliasType("ToBytes_2d", _ToArray_2d[_ToBytes, Is[bytes]]) +ToBytes_3d = TypeAliasType("ToBytes_3d", _ToArray_3d[_ToBytes, Is[bytes]]) +ToBytes_nd = TypeAliasType("ToBytes_nd", _ToArray_nd[_ToBytes, Is[bytes]]) + +_ToStr: TypeAlias = np.character[str] +ToStr_0d = TypeAliasType("ToStr_0d", _ToArray_0d[_ToStr, Is[str]]) +ToStr_1d = TypeAliasType("ToStr_1d", _ToArray_1d[_ToStr, Is[str]]) +ToStr_2d = TypeAliasType("ToStr_2d", _ToArray_2d[_ToStr, Is[str]]) +ToStr_3d = TypeAliasType("ToStr_3d", _ToArray_3d[_ToStr, Is[str]]) +ToStr_nd = TypeAliasType("ToStr_nd", _ToArray_nd[_ToStr, Is[str]]) + +ToCharacter_0d = TypeAliasType("ToCharacter_0d", _ToArray_0d[np.character, _PyCharacter]) +ToCharacter_1d = TypeAliasType("ToCharacter_1d", _ToArray_1d[np.character, _PyCharacter]) +ToCharacter_2d = TypeAliasType("ToCharacter_2d", _ToArray_2d[np.character, _PyCharacter]) +ToCharacter_3d = TypeAliasType("ToCharacter_3d", _ToArray_3d[np.character, _PyCharacter]) +ToCharacter_nd = TypeAliasType("ToCharacter_nd", _ToArray_nd[np.character, _PyCharacter]) # python object -AsObject = TypeAliasType("AsObject", _To2_0d[np.object_, _PyObject]) -AsObject_1d = TypeAliasType("AsObject_1d", _To2_1d[np.object_, _PyObject]) -AsObject_2d = TypeAliasType("AsObject_2d", _To2_2d[np.object_, _PyObject]) -AsObject_3d = TypeAliasType("AsObject_3d", _To2_3d[np.object_, _PyObject]) -AsObject_nd = TypeAliasType("AsObject_nd", _To2_nd[np.object_, _PyObject]) +ToObject_0d = TypeAliasType("ToObject_0d", _ToArray_0d[np.object_, _PyObject]) +ToObject_1d = TypeAliasType("ToObject_1d", _ToArray_1d[np.object_, _PyObject]) +ToObject_2d = TypeAliasType("ToObject_2d", _ToArray_2d[np.object_, _PyObject]) +ToObject_3d = TypeAliasType("ToObject_3d", _ToArray_3d[np.object_, _PyObject]) +ToObject_nd = TypeAliasType("ToObject_nd", _ToArray_nd[np.object_, _PyObject]) + +# any scalar +ToAny_0d = TypeAliasType("ToAny_0d", _ToArray_0d[np.generic, object]) +ToAny_1d = TypeAliasType("ToAny_1d", _ToArray_1d[np.generic, object]) +ToAny_2d = TypeAliasType("ToAny_2d", _ToArray_2d[np.generic, object]) +ToAny_3d = TypeAliasType("ToAny_3d", _ToArray_3d[np.generic, object]) +ToAny_nd = TypeAliasType("ToAny_nd", _ToArray_nd[np.generic, object]) ### # Coercible (overlapping) scalar- and array-likes -ToBool = TypeAliasType("ToBool", _To2_0d[_ToBool, bool]) -ToBool_1d = TypeAliasType("ToBool_1d", _To2_1d[_ToBool, bool]) -ToBool_2d = TypeAliasType("ToBool_2d", _To2_2d[_ToBool, bool]) -ToBool_3d = TypeAliasType("ToBool_3d", _To2_3d[_ToBool, bool]) -ToBool_nd = TypeAliasType("ToBool_nd", _To2_nd[_ToBool, bool]) - -# signed integers -ToInt8 = TypeAliasType("ToInt8", _To2_0d[_ToInt8, bool]) -ToInt8_1d = TypeAliasType("ToInt8_1d", _To2_1d[_ToInt8, bool]) -ToInt8_2d = TypeAliasType("ToInt8_2d", _To2_2d[_ToInt8, bool]) -ToInt8_3d = TypeAliasType("ToInt8_3d", _To2_3d[_ToInt8, bool]) -ToInt8_nd = TypeAliasType("ToInt8_nd", _To2_nd[_ToInt8, bool]) - -ToInt16 = TypeAliasType("ToInt16", _To2_0d[_ToInt16, bool]) -ToInt16_1d = TypeAliasType("ToInt16_1d", _To2_1d[_ToInt16, bool]) -ToInt16_2d = TypeAliasType("ToInt16_2d", _To2_2d[_ToInt16, bool]) -ToInt16_3d = TypeAliasType("ToInt16_3d", _To2_3d[_ToInt16, bool]) -ToInt16_nd = TypeAliasType("ToInt16_nd", _To2_nd[_ToInt16, bool]) - -ToInt32 = TypeAliasType("ToInt32", _To2_0d[_ToInt32, bool]) -ToInt32_1d = TypeAliasType("ToInt32_1d", _To2_1d[_ToInt32, bool]) -ToInt32_2d = TypeAliasType("ToInt32_2d", _To2_2d[_ToInt32, bool]) -ToInt32_3d = TypeAliasType("ToInt32_3d", _To2_3d[_ToInt32, bool]) -ToInt32_nd = TypeAliasType("ToInt32_nd", _To2_nd[_ToInt32, bool]) - -ToInt64 = TypeAliasType("ToInt64", _To2_0d[_ToInt64, int]) -ToInt64_1d = TypeAliasType("ToInt64_1d", _To2_1d[_ToInt64, int]) -ToInt64_2d = TypeAliasType("ToInt64_2d", _To2_2d[_ToInt64, int]) -ToInt64_3d = TypeAliasType("ToInt64_3d", _To2_3d[_ToInt64, int]) -ToInt64_nd = TypeAliasType("ToInt64_nd", _To2_nd[_ToInt64, int]) - -ToLong = TypeAliasType("ToLong", _To2_0d[_ToLong, bool]) -ToLong_1d = TypeAliasType("ToLong_1d", _To2_1d[_ToLong, bool]) -ToLong_2d = TypeAliasType("ToLong_2d", _To2_2d[_ToLong, bool]) -ToLong_3d = TypeAliasType("ToLong_3d", _To2_3d[_ToLong, bool]) -ToLong_nd = TypeAliasType("ToLong_nd", _To2_nd[_ToLong, bool]) - -ToIntP = TypeAliasType("ToIntP", _To2_0d[_ToIntP, int]) -ToIntP_1d = TypeAliasType("ToIntP_1d", _To2_1d[_ToIntP, int]) -ToIntP_2d = TypeAliasType("ToIntP_2d", _To2_2d[_ToIntP, int]) -ToIntP_3d = TypeAliasType("ToIntP_3d", _To2_3d[_ToIntP, int]) -ToIntP_nd = TypeAliasType("ToIntP_nd", _To2_nd[_ToIntP, int]) - -ToLongLong = TypeAliasType("ToLongLong", _To2_0d[_ToLongLong, int]) -ToLongLong_1d = TypeAliasType("ToLongLong_1d", _To2_1d[_ToLongLong, int]) -ToLongLong_2d = TypeAliasType("ToLongLong_2d", _To2_2d[_ToLongLong, int]) -ToLongLong_3d = TypeAliasType("ToLongLong_3d", _To2_3d[_ToLongLong, int]) -ToLongLong_nd = TypeAliasType("ToLongLong_nd", _To2_nd[_ToLongLong, int]) +# bool +CoBool_0d = TypeAliasType("CoBool_0d", _ToArray_0d[_ToBool, bool]) +CoBool_1d = TypeAliasType("CoBool_1d", _ToArray_1d[_ToBool, bool]) +CoBool_2d = TypeAliasType("CoBool_2d", _ToArray_2d[_ToBool, bool]) +CoBool_3d = TypeAliasType("CoBool_3d", _ToArray_3d[_ToBool, bool]) +CoBool_nd = TypeAliasType("CoBool_nd", _ToArray_nd[_ToBool, bool]) # unsigned integers -ToUInt8 = TypeAliasType("ToUInt8", _To2_0d[_ToUInt8, bool]) -ToUInt8_1d = TypeAliasType("ToUInt8_1d", _To2_1d[_ToUInt8, bool]) -ToUInt8_2d = TypeAliasType("ToUInt8_2d", _To2_2d[_ToUInt8, bool]) -ToUInt8_3d = TypeAliasType("ToUInt8_3d", _To2_3d[_ToUInt8, bool]) -ToUInt8_nd = TypeAliasType("ToUInt8_nd", _To2_nd[_ToUInt8, bool]) - -ToUInt16 = TypeAliasType("ToUInt16", _To2_0d[_ToUInt16, bool]) -ToUInt16_1d = TypeAliasType("ToUInt16_1d", _To2_1d[_ToUInt16, bool]) -ToUInt16_2d = TypeAliasType("ToUInt16_2d", _To2_2d[_ToUInt16, bool]) -ToUInt16_3d = TypeAliasType("ToUInt16_3d", _To2_3d[_ToUInt16, bool]) -ToUInt16_nd = TypeAliasType("ToUInt16_nd", _To2_nd[_ToUInt16, bool]) - -ToUInt32 = TypeAliasType("ToUInt32", _To2_0d[_ToUInt32, bool]) -ToUInt32_1d = TypeAliasType("ToUInt32_1d", _To2_1d[_ToUInt32, bool]) -ToUInt32_2d = TypeAliasType("ToUInt32_2d", _To2_2d[_ToUInt32, bool]) -ToUInt32_3d = TypeAliasType("ToUInt32_3d", _To2_3d[_ToUInt32, bool]) -ToUInt32_nd = TypeAliasType("ToUInt32_nd", _To2_nd[_ToUInt32, bool]) - -ToUInt64 = TypeAliasType("ToUInt64", _To2_0d[_ToUInt64, bool]) -ToUInt64_1d = TypeAliasType("ToUInt64_1d", _To2_1d[_ToUInt64, bool]) -ToUInt64_2d = TypeAliasType("ToUInt64_2d", _To2_2d[_ToUInt64, bool]) -ToUInt64_3d = TypeAliasType("ToUInt64_3d", _To2_3d[_ToUInt64, bool]) -ToUInt64_nd = TypeAliasType("ToUInt64_nd", _To2_nd[_ToUInt64, bool]) - -ToULong = TypeAliasType("ToULong", _To2_0d[_ToULong, bool]) -ToULong_1d = TypeAliasType("ToULong_1d", _To2_1d[_ToULong, bool]) -ToULong_2d = TypeAliasType("ToULong_2d", _To2_2d[_ToULong, bool]) -ToULong_3d = TypeAliasType("ToULong_3d", _To2_3d[_ToULong, bool]) -ToULong_nd = TypeAliasType("ToULong_nd", _To2_nd[_ToULong, bool]) - -ToUIntP = TypeAliasType("ToUIntP", _To2_0d[_ToUIntP, bool]) -ToUIntP_1d = TypeAliasType("ToUIntP_1d", _To2_1d[_ToUIntP, bool]) -ToUIntP_2d = TypeAliasType("ToUIntP_2d", _To2_2d[_ToUIntP, bool]) -ToUIntP_3d = TypeAliasType("ToUIntP_3d", _To2_3d[_ToUIntP, bool]) -ToUIntP_nd = TypeAliasType("ToUIntP_nd", _To2_nd[_ToUIntP, bool]) - -ToULongLong = TypeAliasType("ToULongLong", _To2_0d[_ToULongLong, bool]) -ToULongLong_1d = TypeAliasType("ToULongLong_1d", _To2_1d[_ToULongLong, bool]) -ToULongLong_2d = TypeAliasType("ToULongLong_2d", _To2_2d[_ToULongLong, bool]) -ToULongLong_3d = TypeAliasType("ToULongLong_3d", _To2_3d[_ToULongLong, bool]) -ToULongLong_nd = TypeAliasType("ToULongLong_nd", _To2_nd[_ToULongLong, bool]) +_CoUInt8: TypeAlias = np.uint8 | _ToBool +CoUInt8_0d = TypeAliasType("CoUInt8_0d", _ToArray_0d[_CoUInt8, bool]) +CoUInt8_1d = TypeAliasType("CoUInt8_1d", _ToArray_1d[_CoUInt8, bool]) +CoUInt8_2d = TypeAliasType("CoUInt8_2d", _ToArray_2d[_CoUInt8, bool]) +CoUInt8_3d = TypeAliasType("CoUInt8_3d", _ToArray_3d[_CoUInt8, bool]) +CoUInt8_nd = TypeAliasType("CoUInt8_nd", _ToArray_nd[_CoUInt8, bool]) + +_CoUInt16: TypeAlias = np.uint16 | _CoUInt8 +CoUInt16_0d = TypeAliasType("CoUInt16_0d", _ToArray_0d[_CoUInt16, bool]) +CoUInt16_1d = TypeAliasType("CoUInt16_1d", _ToArray_1d[_CoUInt16, bool]) +CoUInt16_2d = TypeAliasType("CoUInt16_2d", _ToArray_2d[_CoUInt16, bool]) +CoUInt16_3d = TypeAliasType("CoUInt16_3d", _ToArray_3d[_CoUInt16, bool]) +CoUInt16_nd = TypeAliasType("CoUInt16_nd", _ToArray_nd[_CoUInt16, bool]) + +_CoUInt32: TypeAlias = np.uint32 | _CoUInt16 +CoUInt32_0d = TypeAliasType("CoUInt32_0d", _ToArray_0d[_CoUInt32, bool]) +CoUInt32_1d = TypeAliasType("CoUInt32_1d", _ToArray_1d[_CoUInt32, bool]) +CoUInt32_2d = TypeAliasType("CoUInt32_2d", _ToArray_2d[_CoUInt32, bool]) +CoUInt32_3d = TypeAliasType("CoUInt32_3d", _ToArray_3d[_CoUInt32, bool]) +CoUInt32_nd = TypeAliasType("CoUInt32_nd", _ToArray_nd[_CoUInt32, bool]) + +_CoUInt64: TypeAlias = np.uint64 | _CoUInt32 +CoUInt64_0d = TypeAliasType("CoUInt64_0d", _ToArray_0d[_CoUInt64, bool]) +CoUInt64_1d = TypeAliasType("CoUInt64_1d", _ToArray_1d[_CoUInt64, bool]) +CoUInt64_2d = TypeAliasType("CoUInt64_2d", _ToArray_2d[_CoUInt64, bool]) +CoUInt64_3d = TypeAliasType("CoUInt64_3d", _ToArray_3d[_CoUInt64, bool]) +CoUInt64_nd = TypeAliasType("CoUInt64_nd", _ToArray_nd[_CoUInt64, bool]) + +_CoULong: TypeAlias = np.ulong | _CoUInt32 +CoULong_0d = TypeAliasType("CoULong_0d", _ToArray_0d[_CoULong, bool]) +CoULong_1d = TypeAliasType("CoULong_1d", _ToArray_1d[_CoULong, bool]) +CoULong_2d = TypeAliasType("CoULong_2d", _ToArray_2d[_CoULong, bool]) +CoULong_3d = TypeAliasType("CoULong_3d", _ToArray_3d[_CoULong, bool]) +CoULong_nd = TypeAliasType("CoULong_nd", _ToArray_nd[_CoULong, bool]) + +_CoUIntP: TypeAlias = np.uintp | _CoULong +CoUIntP_0d = TypeAliasType("CoUIntP_0d", _ToArray_0d[_CoUIntP, bool]) +CoUIntP_1d = TypeAliasType("CoUIntP_1d", _ToArray_1d[_CoUIntP, bool]) +CoUIntP_2d = TypeAliasType("CoUIntP_2d", _ToArray_2d[_CoUIntP, bool]) +CoUIntP_3d = TypeAliasType("CoUIntP_3d", _ToArray_3d[_CoUIntP, bool]) +CoUIntP_nd = TypeAliasType("CoUIntP_nd", _ToArray_nd[_CoUIntP, bool]) + +_CoULongLong: TypeAlias = np.unsignedinteger | _ToBool +CoULongLong_0d = TypeAliasType("CoULongLong_0d", _ToArray_0d[_CoULongLong, bool]) +CoULongLong_1d = TypeAliasType("CoULongLong_1d", _ToArray_1d[_CoULongLong, bool]) +CoULongLong_2d = TypeAliasType("CoULongLong_2d", _ToArray_2d[_CoULongLong, bool]) +CoULongLong_3d = TypeAliasType("CoULongLong_3d", _ToArray_3d[_CoULongLong, bool]) +CoULongLong_nd = TypeAliasType("CoULongLong_nd", _ToArray_nd[_CoULongLong, bool]) + +# signed integers +_CoInt8: TypeAlias = np.int8 | _ToBool +CoInt8_0d = TypeAliasType("CoInt8_0d", _ToArray_0d[_CoInt8, bool]) +CoInt8_1d = TypeAliasType("CoInt8_1d", _ToArray_1d[_CoInt8, bool]) +CoInt8_2d = TypeAliasType("CoInt8_2d", _ToArray_2d[_CoInt8, bool]) +CoInt8_3d = TypeAliasType("CoInt8_3d", _ToArray_3d[_CoInt8, bool]) +CoInt8_nd = TypeAliasType("CoInt8_nd", _ToArray_nd[_CoInt8, bool]) + +_CoInt16: TypeAlias = np.int16 | np.uint8 | _CoInt8 +CoInt16_0d = TypeAliasType("CoInt16_0d", _ToArray_0d[_CoInt16, bool]) +CoInt16_1d = TypeAliasType("CoInt16_1d", _ToArray_1d[_CoInt16, bool]) +CoInt16_2d = TypeAliasType("CoInt16_2d", _ToArray_2d[_CoInt16, bool]) +CoInt16_3d = TypeAliasType("CoInt16_3d", _ToArray_3d[_CoInt16, bool]) +CoInt16_nd = TypeAliasType("CoInt16_nd", _ToArray_nd[_CoInt16, bool]) + +_CoInt32: TypeAlias = np.int32 | np.uint16 | _CoInt16 +CoInt32_0d = TypeAliasType("CoInt32_0d", _ToArray_0d[_CoInt32, bool]) +CoInt32_1d = TypeAliasType("CoInt32_1d", _ToArray_1d[_CoInt32, bool]) +CoInt32_2d = TypeAliasType("CoInt32_2d", _ToArray_2d[_CoInt32, bool]) +CoInt32_3d = TypeAliasType("CoInt32_3d", _ToArray_3d[_CoInt32, bool]) +CoInt32_nd = TypeAliasType("CoInt32_nd", _ToArray_nd[_CoInt32, bool]) + +_CoInt64: TypeAlias = np.int64 | np.uint32 | _CoInt32 +CoInt64_0d = TypeAliasType("CoInt64_0d", _ToArray_0d[_CoInt64, int]) +CoInt64_1d = TypeAliasType("CoInt64_1d", _ToArray_1d[_CoInt64, int]) +CoInt64_2d = TypeAliasType("CoInt64_2d", _ToArray_2d[_CoInt64, int]) +CoInt64_3d = TypeAliasType("CoInt64_3d", _ToArray_3d[_CoInt64, int]) +CoInt64_nd = TypeAliasType("CoInt64_nd", _ToArray_nd[_CoInt64, int]) + +_CoLong: TypeAlias = np.long | _CoInt32 +CoLong_0d = TypeAliasType("CoLong_0d", _ToArray_0d[_CoLong, bool]) +CoLong_1d = TypeAliasType("CoLong_1d", _ToArray_1d[_CoLong, bool]) +CoLong_2d = TypeAliasType("CoLong_2d", _ToArray_2d[_CoLong, bool]) +CoLong_3d = TypeAliasType("CoLong_3d", _ToArray_3d[_CoLong, bool]) +CoLong_nd = TypeAliasType("CoLong_nd", _ToArray_nd[_CoLong, bool]) + +_CoIntP: TypeAlias = np.intp | _CoLong +CoIntP_0d = TypeAliasType("CoIntP_0d", _ToArray_0d[_CoIntP, int]) +CoIntP_1d = TypeAliasType("CoIntP_1d", _ToArray_1d[_CoIntP, int]) +CoIntP_2d = TypeAliasType("CoIntP_2d", _ToArray_2d[_CoIntP, int]) +CoIntP_3d = TypeAliasType("CoIntP_3d", _ToArray_3d[_CoIntP, int]) +CoIntP_nd = TypeAliasType("CoIntP_nd", _ToArray_nd[_CoIntP, int]) + +_CoLongLong: TypeAlias = np.signedinteger | _CoUInt32 +CoLongLong_0d = TypeAliasType("CoLongLong_0d", _ToArray_0d[_CoLongLong, int]) +CoLongLong_1d = TypeAliasType("CoLongLong_1d", _ToArray_1d[_CoLongLong, int]) +CoLongLong_2d = TypeAliasType("CoLongLong_2d", _ToArray_2d[_CoLongLong, int]) +CoLongLong_3d = TypeAliasType("CoLongLong_3d", _ToArray_3d[_CoLongLong, int]) +CoLongLong_nd = TypeAliasType("CoLongLong_nd", _ToArray_nd[_CoLongLong, int]) + +_CoInteger: TypeAlias = np.integer | _ToBool # real floats -ToFloat16 = TypeAliasType("ToFloat16", _To2_0d[_ToFloat16, bool]) -ToFloat16_1d = TypeAliasType("ToFloat16_1d", _To2_1d[_ToFloat16, bool]) -ToFloat16_2d = TypeAliasType("ToFloat16_2d", _To2_2d[_ToFloat16, bool]) -ToFloat16_3d = TypeAliasType("ToFloat16_3d", _To2_3d[_ToFloat16, bool]) -ToFloat16_nd = TypeAliasType("ToFloat16_nd", _To2_nd[_ToFloat16, bool]) - -ToFloat32 = TypeAliasType("ToFloat32", _To2_0d[_ToFloat32, bool]) -ToFloat32_1d = TypeAliasType("ToFloat32_1d", _To2_1d[_ToFloat32, bool]) -ToFloat32_2d = TypeAliasType("ToFloat32_2d", _To2_2d[_ToFloat32, bool]) -ToFloat32_3d = TypeAliasType("ToFloat32_3d", _To2_3d[_ToFloat32, bool]) -ToFloat32_nd = TypeAliasType("ToFloat32_nd", _To2_nd[_ToFloat32, bool]) - -ToFloat64 = TypeAliasType("ToFloat64", _To2_0d[_ToFloat64, float]) -ToFloat64_1d = TypeAliasType("ToFloat64_1d", _To2_1d[_ToFloat64, float]) -ToFloat64_2d = TypeAliasType("ToFloat64_2d", _To2_2d[_ToFloat64, float]) -ToFloat64_3d = TypeAliasType("ToFloat64_3d", _To2_3d[_ToFloat64, float]) -ToFloat64_nd = TypeAliasType("ToFloat64_nd", _To2_nd[_ToFloat64, float]) - -ToFloating = TypeAliasType("ToFloating", _To2_0d[_ToFloating, float]) -ToFloating_1d = TypeAliasType("ToFloating_1d", _To2_1d[_ToFloating, float]) -ToFloating_2d = TypeAliasType("ToFloating_2d", _To2_2d[_ToFloating, float]) -ToFloating_3d = TypeAliasType("ToFloating_3d", _To2_3d[_ToFloating, float]) -ToFloating_nd = TypeAliasType("ToFloating_nd", _To2_nd[_ToFloating, float]) + +_CoFloat16: TypeAlias = np.float16 | np.uint8 | np.int16 | _ToBool +CoFloat16_0d = TypeAliasType("CoFloat16_0d", _ToArray_0d[_CoFloat16, bool]) +CoFloat16_1d = TypeAliasType("CoFloat16_1d", _ToArray_1d[_CoFloat16, bool]) +CoFloat16_2d = TypeAliasType("CoFloat16_2d", _ToArray_2d[_CoFloat16, bool]) +CoFloat16_3d = TypeAliasType("CoFloat16_3d", _ToArray_3d[_CoFloat16, bool]) +CoFloat16_nd = TypeAliasType("CoFloat16_nd", _ToArray_nd[_CoFloat16, bool]) + +_CoFloat32: TypeAlias = np.float32 | np.uint16 | np.int16 | _CoFloat16 +CoFloat32_0d = TypeAliasType("CoFloat32_0d", _ToArray_0d[_CoFloat32, bool]) +CoFloat32_1d = TypeAliasType("CoFloat32_1d", _ToArray_1d[_CoFloat32, bool]) +CoFloat32_2d = TypeAliasType("CoFloat32_2d", _ToArray_2d[_CoFloat32, bool]) +CoFloat32_3d = TypeAliasType("CoFloat32_3d", _ToArray_3d[_CoFloat32, bool]) +CoFloat32_nd = TypeAliasType("CoFloat32_nd", _ToArray_nd[_CoFloat32, bool]) + +_CoFloat64: TypeAlias = _ToFloat64 | np.float32 | np.float16 | _CoInteger +CoFloat64_0d = TypeAliasType("CoFloat64_0d", _ToArray_0d[_CoFloat64, float]) +CoFloat64_1d = TypeAliasType("CoFloat64_1d", _ToArray_1d[_CoFloat64, float]) +CoFloat64_2d = TypeAliasType("CoFloat64_2d", _ToArray_2d[_CoFloat64, float]) +CoFloat64_3d = TypeAliasType("CoFloat64_3d", _ToArray_3d[_CoFloat64, float]) +CoFloat64_nd = TypeAliasType("CoFloat64_nd", _ToArray_nd[_CoFloat64, float]) + +_CoFloating: TypeAlias = np.floating | np.integer | _ToBool +CoFloating_0d = TypeAliasType("CoFloating_0d", _ToArray_0d[_CoFloating, float]) +CoFloating_1d = TypeAliasType("CoFloating_1d", _ToArray_1d[_CoFloating, float]) +CoFloating_2d = TypeAliasType("CoFloating_2d", _ToArray_2d[_CoFloating, float]) +CoFloating_3d = TypeAliasType("CoFloating_3d", _ToArray_3d[_CoFloating, float]) +CoFloating_nd = TypeAliasType("CoFloating_nd", _ToArray_nd[_CoFloating, float]) # complex floats -ToComplex64 = TypeAliasType("ToComplex64", _To2_0d[_ToComplex64, bool]) -ToComplex64_1d = TypeAliasType("ToComplex64_1d", _To2_1d[_ToComplex64, bool]) -ToComplex64_2d = TypeAliasType("ToComplex64_2d", _To2_2d[_ToComplex64, bool]) -ToComplex64_3d = TypeAliasType("ToComplex64_3d", _To2_3d[_ToComplex64, bool]) -ToComplex64_nd = TypeAliasType("ToComplex64_nd", _To2_nd[_ToComplex64, bool]) - -ToComplex128 = TypeAliasType("ToComplex128", _To2_0d[_ToComplex128, complex]) -ToComplex128_1d = TypeAliasType("ToComplex128_1d", _To2_1d[_ToComplex128, complex]) -ToComplex128_2d = TypeAliasType("ToComplex128_2d", _To2_2d[_ToComplex128, complex]) -ToComplex128_3d = TypeAliasType("ToComplex128_3d", _To2_3d[_ToComplex128, complex]) -ToComplex128_nd = TypeAliasType("ToComplex128_nd", _To2_nd[_ToComplex128, complex]) - -ToComplexFloating = TypeAliasType("ToComplexFloating", _To2_0d[_ToNumber, complex]) -ToComplexFloating_1d = TypeAliasType("ToComplexFloating_1d", _To2_1d[_ToNumber, complex]) -ToComplexFloating_2d = TypeAliasType("ToComplexFloating_2d", _To2_2d[_ToNumber, complex]) -ToComplexFloating_3d = TypeAliasType("ToComplexFloating_3d", _To2_3d[_ToNumber, complex]) -ToComplexFloating_nd = TypeAliasType("ToComplexFloating_nd", _To2_nd[_ToNumber, complex]) - -ToTimeDelta = TypeAliasType("ToTimeDelta", _To2_0d[_ToTimeDelta, int]) -ToTimeDelta_1d = TypeAliasType("ToTimeDelta_1d", _To2_1d[_ToTimeDelta, int]) -ToTimeDelta_2d = TypeAliasType("ToTimeDelta_2d", _To2_2d[_ToTimeDelta, int]) -ToTimeDelta_3d = TypeAliasType("ToTimeDelta_3d", _To2_3d[_ToTimeDelta, int]) -ToTimeDelta_nd = TypeAliasType("ToTimeDelta_nd", _To2_nd[_ToTimeDelta, int]) - -ToDateTime = TypeAliasType("ToDateTime", _To1_0d[_ToDateTime]) -ToDateTime_1d = TypeAliasType("ToDateTime_1d", _To1_1d[_ToDateTime]) -ToDateTime_2d = TypeAliasType("ToDateTime_2d", _To1_2d[_ToDateTime]) -ToDateTime_3d = TypeAliasType("ToDateTime_3d", _To1_3d[_ToDateTime]) -ToDateTime_nd = TypeAliasType("ToDateTime_nd", _To1_nd[_ToDateTime]) - -ToBytes = TypeAliasType("ToBytes", _To2_0d[_ToBytes, Is[bytes]]) -ToBytes_1d = TypeAliasType("ToBytes_1d", _To2_1d[_ToBytes, Is[bytes]]) -ToBytes_2d = TypeAliasType("ToBytes_2d", _To2_2d[_ToBytes, Is[bytes]]) -ToBytes_3d = TypeAliasType("ToBytes_3d", _To2_3d[_ToBytes, Is[bytes]]) -ToBytes_nd = TypeAliasType("ToBytes_nd", _To2_nd[_ToBytes, Is[bytes]]) - -ToStr = TypeAliasType("ToStr", _To2_0d[_ToStr, _PyCharacter]) -ToStr_1d = TypeAliasType("ToStr_1d", _To2_1d[_ToStr, _PyCharacter]) -ToStr_2d = TypeAliasType("ToStr_2d", _To2_2d[_ToStr, _PyCharacter]) -ToStr_3d = TypeAliasType("ToStr_3d", _To2_3d[_ToStr, _PyCharacter]) -ToStr_nd = TypeAliasType("ToStr_nd", _To2_nd[_ToStr, _PyCharacter]) - -ToGeneric = TypeAliasType("ToGeneric", _To2_0d[_ToObject, object]) -ToGeneric_1d = TypeAliasType("ToGeneric_1d", _To2_1d[_ToObject, object]) -ToGeneric_2d = TypeAliasType("ToGeneric_2d", _To2_2d[_ToObject, object]) -ToGeneric_3d = TypeAliasType("ToGeneric_3d", _To2_3d[_ToObject, object]) -ToGeneric_nd = TypeAliasType("ToGeneric_nd", _To2_nd[_ToObject, object]) +_CoComplex64: TypeAlias = np.complex64 | _CoFloat32 +CoComplex64_0d = TypeAliasType("CoComplex64_0d", _ToArray_0d[_CoComplex64, bool]) +CoComplex64_1d = TypeAliasType("CoComplex64_1d", _ToArray_1d[_CoComplex64, bool]) +CoComplex64_2d = TypeAliasType("CoComplex64_2d", _ToArray_2d[_CoComplex64, bool]) +CoComplex64_3d = TypeAliasType("CoComplex64_3d", _ToArray_3d[_CoComplex64, bool]) +CoComplex64_nd = TypeAliasType("CoComplex64_nd", _ToArray_nd[_CoComplex64, bool]) + +_CoComplex128: TypeAlias = _ToComplex128 | np.complex64 | _CoFloat64 +CoComplex128_0d = TypeAliasType("CoComplex128_0d", _ToArray_0d[_CoComplex128, complex]) +CoComplex128_1d = TypeAliasType("CoComplex128_1d", _ToArray_1d[_CoComplex128, complex]) +CoComplex128_2d = TypeAliasType("CoComplex128_2d", _ToArray_2d[_CoComplex128, complex]) +CoComplex128_3d = TypeAliasType("CoComplex128_3d", _ToArray_3d[_CoComplex128, complex]) +CoComplex128_nd = TypeAliasType("CoComplex128_nd", _ToArray_nd[_CoComplex128, complex]) + +_CoCFloating: TypeAlias = np.number | _ToBool +CoCFloating_0d = TypeAliasType("CoCFloating_0d", _ToArray_0d[_CoCFloating, complex]) +CoCFloating_1d = TypeAliasType("CoCFloating_1d", _ToArray_1d[_CoCFloating, complex]) +CoCFloating_2d = TypeAliasType("CoCFloating_2d", _ToArray_2d[_CoCFloating, complex]) +CoCFloating_3d = TypeAliasType("CoCFloating_3d", _ToArray_3d[_CoCFloating, complex]) +CoCFloating_nd = TypeAliasType("CoCFloating_nd", _ToArray_nd[_CoCFloating, complex]) -### -# `npt.ND` variant with (optional) 2nd shape-typing parameter +# temporal +_CoTimeDelta: TypeAlias = _ToTimeDelta | _CoInteger +CoTimeDelta_0d = TypeAliasType("CoTimeDelta_0d", _ToArray_0d[_CoTimeDelta, int]) +CoTimeDelta_1d = TypeAliasType("CoTimeDelta_1d", _ToArray_1d[_CoTimeDelta, int]) +CoTimeDelta_2d = TypeAliasType("CoTimeDelta_2d", _ToArray_2d[_CoTimeDelta, int]) +CoTimeDelta_3d = TypeAliasType("CoTimeDelta_3d", _ToArray_3d[_CoTimeDelta, int]) +CoTimeDelta_nd = TypeAliasType("CoTimeDelta_nd", _ToArray_nd[_CoTimeDelta, int]) + +_CoDateTime: TypeAlias = _ToDateTime | _ToTimeDelta +CoDateTime_0d = TypeAliasType("CoDateTime_0d", _ToArray_0d[_CoDateTime]) +CoDateTime_1d = TypeAliasType("CoDateTime_1d", _ToArray_1d[_CoDateTime]) +CoDateTime_2d = TypeAliasType("CoDateTime_2d", _ToArray_2d[_CoDateTime]) +CoDateTime_3d = TypeAliasType("CoDateTime_3d", _ToArray_3d[_CoDateTime]) +CoDateTime_nd = TypeAliasType("CoDateTime_nd", _ToArray_nd[_CoDateTime]) -ScalarLike = TypeAliasType("ScalarLike", _To2_0d[np.generic[ItemC], ItemC], type_params=(ItemC,)) -ArrayLike = TypeAliasType("ArrayLike", _To2_nd[np.generic[ItemC], ItemC], type_params=(ItemC,)) -ArrayLike1D = TypeAliasType("ArrayLike1D", _To2_1d[np.generic[ItemC], ItemC], type_params=(ItemC,)) -ArrayLike2D = TypeAliasType("ArrayLike2D", _To2_2d[np.generic[ItemC], ItemC], type_params=(ItemC,)) -ArrayLike3D = TypeAliasType("ArrayLike3D", _To2_3d[np.generic[ItemC], ItemC], type_params=(ItemC,)) +# fixed strings +_CoBytes: TypeAlias = _ToBytes +CoBytes_0d = TypeAliasType("CoBytes_0d", _ToArray_0d[_CoBytes, Is[bytes]]) +CoBytes_1d = TypeAliasType("CoBytes_1d", _ToArray_1d[_CoBytes, Is[bytes]]) +CoBytes_2d = TypeAliasType("CoBytes_2d", _ToArray_2d[_CoBytes, Is[bytes]]) +CoBytes_3d = TypeAliasType("CoBytes_3d", _ToArray_3d[_CoBytes, Is[bytes]]) +CoBytes_nd = TypeAliasType("CoBytes_nd", _ToArray_nd[_CoBytes, Is[bytes]]) + +_CoStr: TypeAlias = np.character +CoStr_0d = TypeAliasType("CoStr_0d", _ToArray_0d[_CoStr, _PyCharacter]) +CoStr_1d = TypeAliasType("CoStr_1d", _ToArray_1d[_CoStr, _PyCharacter]) +CoStr_2d = TypeAliasType("CoStr_2d", _ToArray_2d[_CoStr, _PyCharacter]) +CoStr_3d = TypeAliasType("CoStr_3d", _ToArray_3d[_CoStr, _PyCharacter]) +CoStr_nd = TypeAliasType("CoStr_nd", _ToArray_nd[_CoStr, _PyCharacter]) ### # DType-likes diff --git a/test/static/test__numtype.pyi b/test/static/test__numtype.pyi index a7645a4f..8ae7bcde 100644 --- a/test/static/test__numtype.pyi +++ b/test/static/test__numtype.pyi @@ -36,44 +36,44 @@ like_bool_2d: list[list[bool | np.bool]] | list[_1D[np.bool]] | _2D[np.bool] like_bool_3d: list[list[list[bool | np.bool]]] | list[_2D[np.bool]] | list[list[_1D[np.bool]]] | _3D[np.bool] like_bool_nd: list[list[list[list[bool | np.bool]]]] | list[_2D[np.bool]] | _ND[np.bool] -bool_0d_accept: _nt.AsBool = like_bool_0d -bool_0d_reject_sc: _nt.AsBool = f_ # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_0d_reject_1d: _nt.AsBool = b1_1d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_0d_reject_2d: _nt.AsBool = b1_2d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_0d_reject_3d: _nt.AsBool = b1_3d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_0d_reject_nd: _nt.AsBool = b1_nd # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_0d_accept: _nt.ToBool_0d = like_bool_0d +bool_0d_reject_sc: _nt.ToBool_0d = f_ # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_0d_reject_1d: _nt.ToBool_0d = b1_1d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_0d_reject_2d: _nt.ToBool_0d = b1_2d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_0d_reject_3d: _nt.ToBool_0d = b1_3d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_0d_reject_nd: _nt.ToBool_0d = b1_nd # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_1d_accept: _nt.AsBool_1d = like_bool_1d -bool_1d_reject_sc: _nt.AsBool_1d = [f_] # type: ignore[list-item] # pyright: ignore[reportAssignmentType] -bool_1d_reject_0d: _nt.AsBool_1d = b1 # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_1d_reject_2d: _nt.AsBool_1d = b1_2d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_1d_reject_3d: _nt.AsBool_1d = b1_3d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_1d_reject_nd: _nt.AsBool_1d = b1_nd # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_1d_accept: _nt.ToBool_1d = like_bool_1d +bool_1d_reject_sc: _nt.ToBool_1d = [f_] # type: ignore[list-item] # pyright: ignore[reportAssignmentType] +bool_1d_reject_0d: _nt.ToBool_1d = b1 # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_1d_reject_2d: _nt.ToBool_1d = b1_2d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_1d_reject_3d: _nt.ToBool_1d = b1_3d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_1d_reject_nd: _nt.ToBool_1d = b1_nd # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_2d_accept: _nt.AsBool_2d = like_bool_2d -bool_2d_reject_sc: _nt.AsBool_2d = [[f_]] # type: ignore[list-item] # pyright: ignore[reportAssignmentType] -bool_2d_reject_0d: _nt.AsBool_2d = b1 # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_2d_reject_1d: _nt.AsBool_2d = b1_1d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_2d_reject_3d: _nt.AsBool_2d = b1_3d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_2d_reject_nd: _nt.AsBool_2d = b1_nd # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_2d_accept: _nt.ToBool_2d = like_bool_2d +bool_2d_reject_sc: _nt.ToBool_2d = [[f_]] # type: ignore[list-item] # pyright: ignore[reportAssignmentType] +bool_2d_reject_0d: _nt.ToBool_2d = b1 # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_2d_reject_1d: _nt.ToBool_2d = b1_1d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_2d_reject_3d: _nt.ToBool_2d = b1_3d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_2d_reject_nd: _nt.ToBool_2d = b1_nd # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_3d_accept: _nt.AsBool_3d = like_bool_3d -bool_3d_reject_sc: _nt.AsBool_3d = [[[f_]]] # type: ignore[list-item] # pyright: ignore[reportAssignmentType] -bool_3d_reject_0d: _nt.AsBool_3d = b1 # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_3d_reject_1d: _nt.AsBool_3d = b1_1d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_3d_reject_2d: _nt.AsBool_3d = b1_2d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_3d_reject_nd: _nt.AsBool_3d = b1_nd # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_3d_accept: _nt.ToBool_3d = like_bool_3d +bool_3d_reject_sc: _nt.ToBool_3d = [[[f_]]] # type: ignore[list-item] # pyright: ignore[reportAssignmentType] +bool_3d_reject_0d: _nt.ToBool_3d = b1 # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_3d_reject_1d: _nt.ToBool_3d = b1_1d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_3d_reject_2d: _nt.ToBool_3d = b1_2d # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_3d_reject_nd: _nt.ToBool_3d = b1_nd # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_nd_accept_0d: _nt.AsBool_nd = b1_0d -bool_nd_accept_1d: _nt.AsBool_nd = like_bool_1d -bool_nd_accept_2d: _nt.AsBool_nd = like_bool_2d -bool_nd_accept_3d: _nt.AsBool_nd = like_bool_3d -bool_nd_reject_0d: _nt.AsBool_nd = b1 # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_nd_reject_1d_sc: _nt.AsBool_nd = [f_] # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_nd_reject_2d_sc: _nt.AsBool_nd = [[f_]] # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -bool_nd_reject_3d_sc: _nt.AsBool_nd = [[[f_]]] # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_nd_accept_0d: _nt.ToBool_nd = b1_0d +bool_nd_accept_1d: _nt.ToBool_nd = like_bool_1d +bool_nd_accept_2d: _nt.ToBool_nd = like_bool_2d +bool_nd_accept_3d: _nt.ToBool_nd = like_bool_3d +bool_nd_reject_0d: _nt.ToBool_nd = b1 # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_nd_reject_1d_sc: _nt.ToBool_nd = [f_] # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_nd_reject_2d_sc: _nt.ToBool_nd = [[f_]] # type: ignore[assignment] # pyright: ignore[reportAssignmentType] +bool_nd_reject_3d_sc: _nt.ToBool_nd = [[[f_]]] # type: ignore[assignment] # pyright: ignore[reportAssignmentType] -# TODO(jorenham): also do this for`ToBool*` +# TODO(jorenham): also do this for`CoBool*` ### # TODO(jorenham): repeat for all the other `_As` types