zarr_metadata.v3.data_type

zarr_metadata.v3.data_type

Zarr v3 data type spec types.

Each v3 data type has its own submodule:

• Core primitives: bool, int8/16/32/64, uint8/16/32/64, float16/32/64, complex64/128, raw (for r<N>)
• zarr-extensions: bytes, string, numpy_datetime64, numpy_timedelta64, struct

The two canonical types per dtype are re-exported here:

• <X>DataTypeName -- the literal type of the dtype's data_type string (or, for named-config dtypes, the literal value of their name field)
• <X>FillValue -- the permitted JSON shape of the fill_value field

Named-config dtypes (numpy_datetime64, numpy_timedelta64, struct) also expose their envelope TypedDict here. For configuration TypedDicts, branded HexFloat<N> / Base64Bytes types, and the corresponding validator functions, import directly from the leaf submodule.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

zarr_metadata.v3.data_type.bool

Zarr v3 bool data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

BOOL_DATA_TYPE_NAME module-attribute

BOOL_DATA_TYPE_NAME: Final = 'bool'

The data_type value for the bool type.

BoolDataTypeName module-attribute

BoolDataTypeName = Literal['bool']

Literal type of the data_type field for bool.

BoolFillValue module-attribute

BoolFillValue = bool

Permitted JSON shape of the fill_value field for bool: a JSON boolean.

__all__ module-attribute

__all__ = [
    "BOOL_DATA_TYPE_NAME",
    "BoolDataTypeName",
    "BoolFillValue",
]

zarr_metadata.v3.data_type.int8

Zarr v3 int8 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

INT8_DATA_TYPE_NAME module-attribute

INT8_DATA_TYPE_NAME: Final = 'int8'

The data_type value for the int8 type.

Int8DataTypeName module-attribute

Int8DataTypeName = Literal['int8']

Literal type of the data_type field for int8.

Int8FillValue module-attribute

Int8FillValue = int

Permitted JSON shape of the fill_value field for int8: a JSON integer in [-128, 127].

__all__ module-attribute

__all__ = [
    "INT8_DATA_TYPE_NAME",
    "Int8DataTypeName",
    "Int8FillValue",
]

zarr_metadata.v3.data_type.int16

Zarr v3 int16 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

INT16_DATA_TYPE_NAME module-attribute

INT16_DATA_TYPE_NAME: Final = 'int16'

The data_type value for the int16 type.

Int16DataTypeName module-attribute

Int16DataTypeName = Literal['int16']

Literal type of the data_type field for int16.

Int16FillValue module-attribute

Int16FillValue = int

Permitted JSON shape of the fill_value field for int16: a JSON integer in [-32768, 32767].

__all__ module-attribute

__all__ = [
    "INT16_DATA_TYPE_NAME",
    "Int16DataTypeName",
    "Int16FillValue",
]

zarr_metadata.v3.data_type.int32

Zarr v3 int32 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

INT32_DATA_TYPE_NAME module-attribute

INT32_DATA_TYPE_NAME: Final = 'int32'

The data_type value for the int32 type.

Int32DataTypeName module-attribute

Int32DataTypeName = Literal['int32']

Literal type of the data_type field for int32.

Int32FillValue module-attribute

Int32FillValue = int

Permitted JSON shape of the fill_value field for int32: a JSON integer in [-231, 231 - 1].

__all__ module-attribute

__all__ = [
    "INT32_DATA_TYPE_NAME",
    "Int32DataTypeName",
    "Int32FillValue",
]

zarr_metadata.v3.data_type.int64

Zarr v3 int64 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

INT64_DATA_TYPE_NAME module-attribute

INT64_DATA_TYPE_NAME: Final = 'int64'

The data_type value for the int64 type.

Int64DataTypeName module-attribute

Int64DataTypeName = Literal['int64']

Literal type of the data_type field for int64.

Int64FillValue module-attribute

Int64FillValue = int

Permitted JSON shape of the fill_value field for int64: a JSON integer in [-263, 263 - 1].

__all__ module-attribute

__all__ = [
    "INT64_DATA_TYPE_NAME",
    "Int64DataTypeName",
    "Int64FillValue",
]

zarr_metadata.v3.data_type.uint8

Zarr v3 uint8 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

UINT8_DATA_TYPE_NAME module-attribute

UINT8_DATA_TYPE_NAME: Final = 'uint8'

The data_type value for the uint8 type.

Uint8DataTypeName module-attribute

Uint8DataTypeName = Literal['uint8']

Literal type of the data_type field for uint8.

Uint8FillValue module-attribute

Uint8FillValue = int

Permitted JSON shape of the fill_value field for uint8: a JSON integer in [0, 255].

__all__ module-attribute

__all__ = [
    "UINT8_DATA_TYPE_NAME",
    "Uint8DataTypeName",
    "Uint8FillValue",
]

zarr_metadata.v3.data_type.uint16

Zarr v3 uint16 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

UINT16_DATA_TYPE_NAME module-attribute

UINT16_DATA_TYPE_NAME: Final = 'uint16'

The data_type value for the uint16 type.

Uint16DataTypeName module-attribute

Uint16DataTypeName = Literal['uint16']

Literal type of the data_type field for uint16.

Uint16FillValue module-attribute

Uint16FillValue = int

Permitted JSON shape of the fill_value field for uint16: a JSON integer in [0, 65535].

__all__ module-attribute

__all__ = [
    "UINT16_DATA_TYPE_NAME",
    "Uint16DataTypeName",
    "Uint16FillValue",
]

zarr_metadata.v3.data_type.uint32

Zarr v3 uint32 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

UINT32_DATA_TYPE_NAME module-attribute

UINT32_DATA_TYPE_NAME: Final = 'uint32'

The data_type value for the uint32 type.

Uint32DataTypeName module-attribute

Uint32DataTypeName = Literal['uint32']

Literal type of the data_type field for uint32.

Uint32FillValue module-attribute

Uint32FillValue = int

Permitted JSON shape of the fill_value field for uint32: a JSON integer in [0, 2**32 - 1].

__all__ module-attribute

__all__ = [
    "UINT32_DATA_TYPE_NAME",
    "Uint32DataTypeName",
    "Uint32FillValue",
]

zarr_metadata.v3.data_type.uint64

Zarr v3 uint64 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

UINT64_DATA_TYPE_NAME module-attribute

UINT64_DATA_TYPE_NAME: Final = 'uint64'

The data_type value for the uint64 type.

Uint64DataTypeName module-attribute

Uint64DataTypeName = Literal['uint64']

Literal type of the data_type field for uint64.

Uint64FillValue module-attribute

Uint64FillValue = int

Permitted JSON shape of the fill_value field for uint64: a JSON integer in [0, 2**64 - 1].

__all__ module-attribute

__all__ = [
    "UINT64_DATA_TYPE_NAME",
    "Uint64DataTypeName",
    "Uint64FillValue",
]

zarr_metadata.v3.data_type.float16

Zarr v3 float16 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

CANONICAL_NAN_HEX_FLOAT16 module-attribute

CANONICAL_NAN_HEX_FLOAT16: Final = '0x7e00'

Canonical hex form of the float16 NaN sentinel "NaN".

Per spec the named "NaN" sentinel denotes the float with sign=0, the most significant mantissa bit set, and all other mantissa bits zero (the IEEE 754 default quiet NaN). Other NaN bit patterns must be encoded with the explicit hex-string form.

CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT16 module-attribute

CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT16: Final = '0xfc00'

Canonical hex form of the float16 "-Infinity" sentinel.

CANONICAL_POSITIVE_INFINITY_HEX_FLOAT16 module-attribute

CANONICAL_POSITIVE_INFINITY_HEX_FLOAT16: Final = '0x7c00'

Canonical hex form of the float16 "Infinity" sentinel.

FLOAT16_DATA_TYPE_NAME module-attribute

FLOAT16_DATA_TYPE_NAME: Final = 'float16'

The data_type value for the float16 type.

Float16DataTypeName module-attribute

Float16DataTypeName = Literal['float16']

Literal type of the data_type field for float16.

Float16FillValue module-attribute

Float16FillValue = (
    float | int | Float16SpecialFillValue | HexFloat16
)

Permitted JSON shape of the fill_value field for float16.

Either a JSON number, one of the named non-finite sentinels ("NaN", "Infinity", "-Infinity"), or a HexFloat16 (0xYYYY string encoding the unsigned-integer representation of the IEEE 754 value).

Float16SpecialFillValue module-attribute

Float16SpecialFillValue = Literal[
    "NaN", "Infinity", "-Infinity"
]

Named non-finite fill values permitted by the spec for IEEE 754 floats.

HexFloat16 module-attribute

HexFloat16 = NewType('HexFloat16', str)

A 6-character hex string (0x + 4 hex digits) encoding the unsigned-integer representation of a float16.

__all__ module-attribute

__all__ = [
    "CANONICAL_NAN_HEX_FLOAT16",
    "CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT16",
    "CANONICAL_POSITIVE_INFINITY_HEX_FLOAT16",
    "FLOAT16_DATA_TYPE_NAME",
    "Float16DataTypeName",
    "Float16FillValue",
    "Float16SpecialFillValue",
    "HexFloat16",
    "hex_float16",
]

hex_float16

hex_float16(value: str) -> HexFloat16

Validate value as a HexFloat16 and brand it.

Raises ValueError if value is not exactly 0x followed by 4 hex digits.

Source code in src/zarr_metadata/v3/data_type/float16.py

def hex_float16(value: str) -> HexFloat16:
    """Validate `value` as a HexFloat16 and brand it.

    Raises ValueError if `value` is not exactly `0x` followed by 4 hex
    digits.
    """
    if not _HEX_FLOAT16_RE.fullmatch(value):
        raise ValueError(f"Expected '0x' followed by 4 hex digits, got {value!r}")
    return HexFloat16(value)

zarr_metadata.v3.data_type.float32

Zarr v3 float32 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

CANONICAL_NAN_HEX_FLOAT32 module-attribute

CANONICAL_NAN_HEX_FLOAT32: Final = '0x7fc00000'

Canonical hex form of the float32 NaN sentinel "NaN".

Per spec the named "NaN" sentinel denotes the float with sign=0, the most significant mantissa bit set, and all other mantissa bits zero (the IEEE 754 default quiet NaN). Other NaN bit patterns must be encoded with the explicit hex-string form.

CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT32 module-attribute

CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT32: Final = (
    "0xff800000"
)

Canonical hex form of the float32 "-Infinity" sentinel.

CANONICAL_POSITIVE_INFINITY_HEX_FLOAT32 module-attribute

CANONICAL_POSITIVE_INFINITY_HEX_FLOAT32: Final = (
    "0x7f800000"
)

Canonical hex form of the float32 "Infinity" sentinel.

FLOAT32_DATA_TYPE_NAME module-attribute

FLOAT32_DATA_TYPE_NAME: Final = 'float32'

The data_type value for the float32 type.

Float32DataTypeName module-attribute

Float32DataTypeName = Literal['float32']

Literal type of the data_type field for float32.

Float32FillValue module-attribute

Float32FillValue = (
    float | int | Float32SpecialFillValue | HexFloat32
)

Permitted JSON shape of the fill_value field for float32.

Either a JSON number, one of the named non-finite sentinels ("NaN", "Infinity", "-Infinity"), or a HexFloat32 (0xYYYYYYYY string encoding the unsigned-integer representation of the IEEE 754 value).

Float32SpecialFillValue module-attribute

Float32SpecialFillValue = Literal[
    "NaN", "Infinity", "-Infinity"
]

Named non-finite fill values permitted by the spec for IEEE 754 floats.

HexFloat32 module-attribute

HexFloat32 = NewType('HexFloat32', str)

A 10-character hex string (0x + 8 hex digits) encoding the unsigned-integer representation of a float32.

__all__ module-attribute

__all__ = [
    "CANONICAL_NAN_HEX_FLOAT32",
    "CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT32",
    "CANONICAL_POSITIVE_INFINITY_HEX_FLOAT32",
    "FLOAT32_DATA_TYPE_NAME",
    "Float32DataTypeName",
    "Float32FillValue",
    "Float32SpecialFillValue",
    "HexFloat32",
    "hex_float32",
]

hex_float32

hex_float32(value: str) -> HexFloat32

Validate value as a HexFloat32 and brand it.

Raises ValueError if value is not exactly 0x followed by 8 hex digits.

Source code in src/zarr_metadata/v3/data_type/float32.py

def hex_float32(value: str) -> HexFloat32:
    """Validate `value` as a HexFloat32 and brand it.

    Raises ValueError if `value` is not exactly `0x` followed by 8 hex
    digits.
    """
    if not _HEX_FLOAT32_RE.fullmatch(value):
        raise ValueError(f"Expected '0x' followed by 8 hex digits, got {value!r}")
    return HexFloat32(value)

zarr_metadata.v3.data_type.float64

Zarr v3 float64 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

CANONICAL_NAN_HEX_FLOAT64 module-attribute

CANONICAL_NAN_HEX_FLOAT64: Final = '0x7ff8000000000000'

Canonical hex form of the float64 NaN sentinel "NaN".

Per spec the named "NaN" sentinel denotes the float with sign=0, the most significant mantissa bit set, and all other mantissa bits zero (the IEEE 754 default quiet NaN). Other NaN bit patterns must be encoded with the explicit hex-string form.

CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT64 module-attribute

CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT64: Final = (
    "0xfff0000000000000"
)

Canonical hex form of the float64 "-Infinity" sentinel.

CANONICAL_POSITIVE_INFINITY_HEX_FLOAT64 module-attribute

CANONICAL_POSITIVE_INFINITY_HEX_FLOAT64: Final = (
    "0x7ff0000000000000"
)

Canonical hex form of the float64 "Infinity" sentinel.

FLOAT64_DATA_TYPE_NAME module-attribute

FLOAT64_DATA_TYPE_NAME: Final = 'float64'

The data_type value for the float64 type.

Float64DataTypeName module-attribute

Float64DataTypeName = Literal['float64']

Literal type of the data_type field for float64.

Float64FillValue module-attribute

Float64FillValue = (
    float | int | Float64SpecialFillValue | HexFloat64
)

Permitted JSON shape of the fill_value field for float64.

Either a JSON number, one of the named non-finite sentinels ("NaN", "Infinity", "-Infinity"), or a HexFloat64 (0xYYYYYYYYYYYYYYYY string encoding the unsigned-integer representation of the IEEE 754 value).

Float64SpecialFillValue module-attribute

Float64SpecialFillValue = Literal[
    "NaN", "Infinity", "-Infinity"
]

Named non-finite fill values permitted by the spec for IEEE 754 floats.

HexFloat64 module-attribute

HexFloat64 = NewType('HexFloat64', str)

An 18-character hex string (0x + 16 hex digits) encoding the unsigned-integer representation of a float64.

__all__ module-attribute

__all__ = [
    "CANONICAL_NAN_HEX_FLOAT64",
    "CANONICAL_NEGATIVE_INFINITY_HEX_FLOAT64",
    "CANONICAL_POSITIVE_INFINITY_HEX_FLOAT64",
    "FLOAT64_DATA_TYPE_NAME",
    "Float64DataTypeName",
    "Float64FillValue",
    "Float64SpecialFillValue",
    "HexFloat64",
    "hex_float64",
]

hex_float64

hex_float64(value: str) -> HexFloat64

Validate value as a HexFloat64 and brand it.

Raises ValueError if value is not exactly 0x followed by 16 hex digits.

Source code in src/zarr_metadata/v3/data_type/float64.py

def hex_float64(value: str) -> HexFloat64:
    """Validate `value` as a HexFloat64 and brand it.

    Raises ValueError if `value` is not exactly `0x` followed by 16 hex
    digits.
    """
    if not _HEX_FLOAT64_RE.fullmatch(value):
        raise ValueError(f"Expected '0x' followed by 16 hex digits, got {value!r}")
    return HexFloat64(value)

zarr_metadata.v3.data_type.complex64

Zarr v3 complex64 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

COMPLEX64_DATA_TYPE_NAME module-attribute

COMPLEX64_DATA_TYPE_NAME: Final = 'complex64'

The data_type value for the complex64 type.

Complex64Component module-attribute

Complex64Component = Float32FillValue

One real or imaginary component of a complex64 fill value.

Same shape as a float32 fill value: a JSON number, a named sentinel, or a HexFloat32 string.

Complex64DataTypeName module-attribute

Complex64DataTypeName = Literal['complex64']

Literal type of the data_type field for complex64.

Complex64FillValue module-attribute

Complex64FillValue = tuple[
    Complex64Component, Complex64Component
]

Permitted JSON shape of the fill_value field for complex64.

A two-element JSON array [real, imag] where each component is a Complex64Component.

__all__ module-attribute

__all__ = [
    "COMPLEX64_DATA_TYPE_NAME",
    "Complex64Component",
    "Complex64DataTypeName",
    "Complex64FillValue",
]

zarr_metadata.v3.data_type.complex128

Zarr v3 complex128 data type.

See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html

COMPLEX128_DATA_TYPE_NAME module-attribute

COMPLEX128_DATA_TYPE_NAME: Final = 'complex128'

The data_type value for the complex128 type.

Complex128Component module-attribute

Complex128Component = Float64FillValue

One real or imaginary component of a complex128 fill value.

Same shape as a float64 fill value: a JSON number, a named sentinel, or a HexFloat64 string.

Complex128DataTypeName module-attribute

Complex128DataTypeName = Literal['complex128']

Literal type of the data_type field for complex128.

Complex128FillValue module-attribute

Complex128FillValue = tuple[
    Complex128Component, Complex128Component
]

Permitted JSON shape of the fill_value field for complex128.

A two-element JSON array [real, imag] where each component is a Complex128Component.

__all__ module-attribute

__all__ = [
    "COMPLEX128_DATA_TYPE_NAME",
    "Complex128Component",
    "Complex128DataTypeName",
    "Complex128FillValue",
]

zarr_metadata.v3.data_type.raw

Zarr v3 r<N> raw-bytes data type (parameterised by bit count).

The data_type value is a string of the form r<N> where N is a positive multiple of 8 (e.g. r8, r16, r24).

See https://zarr-specs.readthedocs.io/en/latest/v3/core/index.html

RawBytesDataTypeName module-attribute

RawBytesDataTypeName = NewType('RawBytesDataTypeName', str)

A spec-conformant r<N> raw-bytes name (e.g. "r8", "r16").

RawBytesFillValue module-attribute

RawBytesFillValue = tuple[int, ...]

Permitted JSON shape of the fill_value field for r<N>.

A JSON array of N/8 integers in [0, 255] (one per byte).

__all__ module-attribute

__all__ = [
    "RawBytesDataTypeName",
    "RawBytesFillValue",
    "raw_bytes_dtype_name",
]

raw_bytes_dtype_name

raw_bytes_dtype_name(value: str) -> RawBytesDataTypeName

Validate value as a r<N> raw-bytes name and brand it.

Raises ValueError if value is not r followed by a positive multiple of 8.

Source code in src/zarr_metadata/v3/data_type/raw.py

def raw_bytes_dtype_name(value: str) -> RawBytesDataTypeName:
    """Validate `value` as a `r<N>` raw-bytes name and brand it.

    Raises ValueError if `value` is not `r` followed by a positive
    multiple of 8.
    """
    match = _RAW_BYTES_RE.fullmatch(value)
    if match is None:
        raise ValueError(f"Expected 'r' followed by a positive integer, got {value!r}")
    bits = int(match.group(1))
    if bits == 0 or bits % 8 != 0:
        raise ValueError(f"Expected 'r<N>' where N is a positive multiple of 8, got {value!r}")
    return RawBytesDataTypeName(value)

zarr_metadata.v3.data_type.bytes

Zarr bytes data type (variable-length raw bytes, zarr-extensions).

See https://github.com/zarr-developers/zarr-extensions/tree/main/data-types/bytes

BYTES_DATA_TYPE_NAME module-attribute

BYTES_DATA_TYPE_NAME: Final = 'bytes'

The data_type value for the variable-length bytes type.

Base64Bytes module-attribute

Base64Bytes = NewType('Base64Bytes', str)

A standard-alphabet base64-encoded byte sequence.

BytesDataTypeName module-attribute

BytesDataTypeName = Literal['bytes']

Literal type of the data_type field for bytes.

BytesFillValue module-attribute

BytesFillValue = tuple[int, ...] | Base64Bytes

Permitted JSON shape of the fill_value field for bytes.

Either a JSON array of integers in [0, 255] (one per byte), or a Base64Bytes string encoding the byte sequence.

__all__ module-attribute

__all__ = [
    "BYTES_DATA_TYPE_NAME",
    "Base64Bytes",
    "BytesDataTypeName",
    "BytesFillValue",
    "base64_bytes",
]

base64_bytes

base64_bytes(value: str) -> Base64Bytes

Validate value as a Base64Bytes and brand it.

Raises ValueError if value is not standard-alphabet base64 (length must be a multiple of 4 once padded; only A-Z, a-z, 0-9, +, /, and trailing = padding are permitted).

Source code in src/zarr_metadata/v3/data_type/bytes.py

def base64_bytes(value: str) -> Base64Bytes:
    """Validate `value` as a Base64Bytes and brand it.

    Raises ValueError if `value` is not standard-alphabet base64
    (length must be a multiple of 4 once padded; only `A-Z`, `a-z`,
    `0-9`, `+`, `/`, and trailing `=` padding are permitted).
    """
    if len(value) % 4 != 0 or not _BASE64_RE.fullmatch(value):
        raise ValueError(f"Expected standard-alphabet base64, got {value!r}")
    return Base64Bytes(value)

zarr_metadata.v3.data_type.string

Zarr string data type (variable-length utf-8, zarr-extensions).

See https://github.com/zarr-developers/zarr-extensions/tree/main/data-types/string

STRING_DATA_TYPE_NAME module-attribute

STRING_DATA_TYPE_NAME: Final = 'string'

The data_type value for the string type.

StringDataTypeName module-attribute

StringDataTypeName = Literal['string']

Literal type of the data_type field for string.

StringFillValue module-attribute

StringFillValue = str

Permitted JSON shape of the fill_value field for string: a JSON unicode string.

__all__ module-attribute

__all__ = [
    "STRING_DATA_TYPE_NAME",
    "StringDataTypeName",
    "StringFillValue",
]

zarr_metadata.v3.data_type.numpy_datetime64

Zarr numpy.datetime64 data type (zarr-extensions).

See https://github.com/zarr-developers/zarr-extensions/tree/main/data-types/numpy.datetime64

NUMPY_DATETIME64_DATA_TYPE_NAME module-attribute

NUMPY_DATETIME64_DATA_TYPE_NAME: Final = 'numpy.datetime64'

The name field value of the numpy.datetime64 data type.

NumpyDatetime64DataTypeName module-attribute

NumpyDatetime64DataTypeName = Literal['numpy.datetime64']

Literal type of the name field of the numpy.datetime64 data type.

NumpyDatetime64FillValue module-attribute

NumpyDatetime64FillValue = int | Literal['NaT']

Permitted JSON shape of the fill_value field for numpy.datetime64.

Either a JSON integer (count of unit * scale_factor since the epoch), or the string "NaT" (equivalent to the integer -2**63).

NumpyTimeUnit module-attribute

NumpyTimeUnit = Literal[
    "Y",
    "M",
    "W",
    "D",
    "h",
    "m",
    "s",
    "ms",
    "us",
    "μs",
    "ns",
    "ps",
    "fs",
    "as",
    "generic",
]

Time unit codes used by numpy.datetime64.

__all__ module-attribute

__all__ = [
    "NUMPY_DATETIME64_DATA_TYPE_NAME",
    "NumpyDatetime64",
    "NumpyDatetime64Configuration",
    "NumpyDatetime64DataTypeName",
    "NumpyDatetime64FillValue",
    "NumpyTimeUnit",
]

NumpyDatetime64

Bases: TypedDict

numpy.datetime64 data type metadata.

Source code in src/zarr_metadata/v3/data_type/numpy_datetime64.py

class NumpyDatetime64(TypedDict):
    """`numpy.datetime64` data type metadata."""

    name: NumpyDatetime64DataTypeName
    configuration: NumpyDatetime64Configuration

configuration instance-attribute

configuration: NumpyDatetime64Configuration

name instance-attribute

name: NumpyDatetime64DataTypeName

NumpyDatetime64Configuration

Bases: TypedDict

Configuration for the numpy.datetime64 data type.

Attributes:

• unit (ReadOnly[NumpyTimeUnit]) –

  A string encoding a unit of time.

• scale_factor (ReadOnly[int]) –

  The multiplier relative to the unit.

Source code in src/zarr_metadata/v3/data_type/numpy_datetime64.py

class NumpyDatetime64Configuration(TypedDict):
    """
    Configuration for the `numpy.datetime64` data type.

    Attributes
    ----------
    unit
        A string encoding a unit of time.
    scale_factor
        The multiplier relative to the unit.
    """

    unit: ReadOnly[NumpyTimeUnit]
    scale_factor: ReadOnly[int]

scale_factor instance-attribute

scale_factor: ReadOnly[int]

unit instance-attribute

unit: ReadOnly[NumpyTimeUnit]

zarr_metadata.v3.data_type.numpy_timedelta64

Zarr numpy.timedelta64 data type (zarr-extensions).

See https://github.com/zarr-developers/zarr-extensions/tree/main/data-types/numpy.timedelta64

NUMPY_TIMEDELTA64_DATA_TYPE_NAME module-attribute

NUMPY_TIMEDELTA64_DATA_TYPE_NAME: Final = (
    "numpy.timedelta64"
)

The name field value of the numpy.timedelta64 data type.

NUMPY_TIME_UNIT module-attribute

NUMPY_TIME_UNIT: Final = (
    "Y",
    "M",
    "W",
    "D",
    "h",
    "m",
    "s",
    "ms",
    "us",
    "μs",
    "ns",
    "ps",
    "fs",
    "as",
    "generic",
)

Runtime tuple of the permitted numpy.timedelta64/numpy.datetime64 unit strings.

NumpyTimeUnit module-attribute

NumpyTimeUnit = Literal[
    "Y",
    "M",
    "W",
    "D",
    "h",
    "m",
    "s",
    "ms",
    "us",
    "μs",
    "ns",
    "ps",
    "fs",
    "as",
    "generic",
]

Time unit codes used by numpy.timedelta64.

NumpyTimedelta64DataTypeName module-attribute

NumpyTimedelta64DataTypeName = Literal['numpy.timedelta64']

Literal type of the name field of the numpy.timedelta64 data type.

NumpyTimedelta64FillValue module-attribute

NumpyTimedelta64FillValue = int | Literal['NaT']

Permitted JSON shape of the fill_value field for numpy.timedelta64.

Either a JSON integer (a count of unit * scale_factor), or the string "NaT" (equivalent to the integer -2**63).

__all__ module-attribute

__all__ = [
    "NUMPY_TIMEDELTA64_DATA_TYPE_NAME",
    "NUMPY_TIME_UNIT",
    "NumpyTimeUnit",
    "NumpyTimedelta64",
    "NumpyTimedelta64Configuration",
    "NumpyTimedelta64DataTypeName",
    "NumpyTimedelta64FillValue",
]

NumpyTimedelta64

Bases: TypedDict

numpy.timedelta64 data type metadata.

Source code in src/zarr_metadata/v3/data_type/numpy_timedelta64.py

class NumpyTimedelta64(TypedDict):
    """`numpy.timedelta64` data type metadata."""

    name: NumpyTimedelta64DataTypeName
    configuration: NumpyTimedelta64Configuration

configuration instance-attribute

configuration: NumpyTimedelta64Configuration

name instance-attribute

name: NumpyTimedelta64DataTypeName

NumpyTimedelta64Configuration

Bases: TypedDict

Configuration for the numpy.timedelta64 data type.

Attributes:

• unit (ReadOnly[NumpyTimeUnit]) –

  A string encoding a unit of time.

• scale_factor (ReadOnly[int]) –

  The multiplier relative to the unit.

Source code in src/zarr_metadata/v3/data_type/numpy_timedelta64.py

class NumpyTimedelta64Configuration(TypedDict):
    """
    Configuration for the `numpy.timedelta64` data type.

    Attributes
    ----------
    unit
        A string encoding a unit of time.
    scale_factor
        The multiplier relative to the unit.
    """

    unit: ReadOnly[NumpyTimeUnit]
    scale_factor: ReadOnly[int]

scale_factor instance-attribute

scale_factor: ReadOnly[int]

unit instance-attribute

unit: ReadOnly[NumpyTimeUnit]