cast-value 0.1.0__py3-none-any.whl

cast_value/__init__.py

@@ -0,0 +1,10 @@
+"""Copyright (c) 2026 Davis Bennett. All rights reserved.
+
+cast-value: Python implementation of the `cast_value` codec.
+"""
+
+from __future__ import annotations
+
+from ._version import version as __version__
+
+__all__ = ["__version__"]

cast_value/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

cast_value/_version.pyi

@@ -0,0 +1,2 @@
+version: str
+version_tuple: tuple[int, int, int] | tuple[int, int, int, str, str]

cast_value/core.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from cast_value.types import (
+        MapEntry,
+        OutOfRangeMode,
+        RoundingMode,
+        ScalarMapJSON,
+    )
+
+
+def apply_scalar_map(work: np.ndarray, entries: list[MapEntry]) -> None:
+    """Apply scalar map entries in-place. Single pass per entry."""
+    for src, tgt in entries:
+        if isinstance(src, (float, np.floating)) and np.isnan(src):
+            mask = np.isnan(work)
+        else:
+            mask = work == src
+        work[mask] = tgt
+
+
+def round_inplace(arr: np.ndarray, mode: RoundingMode) -> np.ndarray:
+    """Round array, returning result (may or may not be a new array).
+
+    For nearest-away, requires 3 numpy ops. All others are a single op.
+    """
+    match mode:
+        case "nearest-even":
+            return np.rint(arr)  # type: ignore [no-any-return]
+        case "towards-zero":
+            return np.trunc(arr)  # type: ignore [no-any-return]
+        case "towards-positive":
+            return np.ceil(arr)  # type: ignore [no-any-return]
+        case "towards-negative":
+            return np.floor(arr)  # type: ignore [no-any-return]
+        case "nearest-away":
+            return np.sign(arr) * np.floor(np.abs(arr) + 0.5)  # type: ignore [no-any-return]
+    msg = f"Unknown rounding mode: {mode}"
+    raise ValueError(msg)
+
+
+def cast_array(
+    arr: np.ndarray,
+    *,
+    target_dtype: np.dtype,
+    rounding_mode: RoundingMode,
+    out_of_range_mode: OutOfRangeMode | None,
+    scalar_map_entries: list[MapEntry] | None,
+) -> np.ndarray:
+    """Cast an array to target_dtype with rounding, out-of-range, and scalar_map handling.
+
+    Optimized to minimize allocations and passes over the data.
+    For the simple case (no scalar_map, no rounding needed, no out-of-range),
+    this is essentially just ``arr.astype(target_dtype)``.
+
+    All casts are performed under ``np.errstate(over='raise', invalid='raise')``
+    so that numpy overflow or invalid-value warnings become hard errors instead
+    of being silently swallowed.
+    """
+    with np.errstate(over="raise", invalid="raise"):
+        return _cast_array_impl(
+            arr,
+            target_dtype=target_dtype,
+            rounding=rounding_mode,
+            out_of_range=out_of_range_mode,
+            scalar_map_entries=scalar_map_entries,
+        )
+
+
+def check_int_range(
+    work: np.ndarray,
+    *,
+    target_dtype: np.dtype,
+    out_of_range: OutOfRangeMode | None,
+) -> np.ndarray:
+    """Check integer range and apply out-of-range handling, then cast."""
+    info = np.iinfo(target_dtype)
+    lo, hi = int(info.min), int(info.max)
+    w_min, w_max = int(work.min()), int(work.max())
+    if w_min >= lo and w_max <= hi:
+        return work.astype(target_dtype)
+    match out_of_range:
+        case "clamp":
+            return np.clip(work, lo, hi).astype(target_dtype)
+        case "wrap":
+            range_size = hi - lo + 1
+            return ((work.astype(np.int64) - lo) % range_size + lo).astype(target_dtype)
+        case None:
+            oor_vals = work[(work < lo) | (work > hi)]
+            msg = (
+                f"Values out of range for {target_dtype} (valid range: [{lo}, {hi}]), "
+                f"got values in [{w_min}, {w_max}]. "
+                f"Out-of-range values: {oor_vals.ravel()!r}. "
+                f"Set out_of_range='clamp' or out_of_range='wrap' to handle this."
+            )
+            raise ValueError(msg)
+
+
+def _cast_float(
+    arr: np.ndarray,
+    target_dtype: np.dtype,
+    rounding: RoundingMode,
+) -> np.ndarray:
+    """Cast a float (or int) array to a float target dtype, respecting the rounding mode.
+
+    numpy's ``astype`` always uses nearest-even. For other rounding modes we
+    detect which values lost precision and correct them by choosing between
+    the two adjacent representable values in the target dtype.
+    """
+    result = arr.astype(target_dtype)
+
+    if rounding == "nearest-even":
+        return result
+
+    # Widen source to a float type so we can compare. For integer sources,
+    # float64 is the widest available; for float sources, keep the original dtype.
+    wide_dtype = np.float64 if np.issubdtype(arr.dtype, np.integer) else arr.dtype
+
+    wide_src = arr.astype(wide_dtype)
+    roundtrip = result.astype(wide_dtype)
+    inexact = roundtrip != wide_src
+
+    # Skip NaN/Inf — they are exact in any float type that supports them.
+    if np.issubdtype(wide_dtype, np.floating):
+        inexact &= np.isfinite(wide_src)
+
+    if not inexact.any():
+        return result
+
+    # For inexact values, ``result`` holds the nearest-even candidate.
+    # The other adjacent representable value is one ULP towards the original.
+    ne = result[inexact]  # nearest-even candidates
+    src = wide_src[inexact]  # original values in wide dtype
+    ne_wide = ne.astype(wide_dtype)
+
+    # If nearest-even rounded up (ne > original), the other candidate is one ULP lower.
+    # If nearest-even rounded down (ne < original), the other candidate is one ULP higher.
+    toward = np.where(ne_wide > src, np.float64(-np.inf), np.float64(np.inf)).astype(
+        target_dtype
+    )
+    other = np.nextafter(ne, toward)
+    other_wide = other.astype(wide_dtype)
+
+    match rounding:
+        case "towards-zero":
+            use_other = np.abs(other_wide) < np.abs(ne_wide)
+        case "towards-positive":
+            use_other = other_wide > ne_wide
+        case "towards-negative":
+            use_other = other_wide < ne_wide
+        case "nearest-away":
+            use_other = np.abs(other_wide) > np.abs(ne_wide)
+
+    corrected = result.copy()
+    indices = np.where(inexact)[0]
+    corrected[indices[use_other]] = other[use_other]
+    return corrected
+
+
+def _cast_array_impl(
+    arr: np.ndarray,
+    *,
+    target_dtype: np.dtype,
+    rounding: RoundingMode,
+    out_of_range: OutOfRangeMode | None,
+    scalar_map_entries: list[MapEntry] | None,
+) -> np.ndarray:
+    src_type: Literal["int", "float"] = (
+        "int" if np.issubdtype(arr.dtype, np.integer) else "float"
+    )
+    tgt_type: Literal["int", "float"] = (
+        "int" if np.issubdtype(target_dtype, np.integer) else "float"
+    )
+    has_map = bool(scalar_map_entries)
+
+    match (src_type, tgt_type, has_map):
+        # float→float or int→float without scalar_map
+        case (_, "float", False):
+            return _cast_float(arr, target_dtype, rounding)
+
+        # int→float with scalar_map — widen to float64, apply map, cast
+        case ("int", "float", True):
+            assert scalar_map_entries is not None
+            work = arr.astype(np.float64)
+            apply_scalar_map(work, scalar_map_entries)
+            return _cast_float(work, target_dtype, rounding)
+
+        # float→float with scalar_map — copy, apply map, cast
+        case ("float", "float", True):
+            assert scalar_map_entries is not None
+            work = arr.copy()
+            apply_scalar_map(work, scalar_map_entries)
+            return _cast_float(work, target_dtype, rounding)
+
+        # int→int without scalar_map — range check then astype
+        case ("int", "int", False):
+            if arr.dtype.itemsize > target_dtype.itemsize or arr.dtype != target_dtype:
+                return check_int_range(
+                    arr, target_dtype=target_dtype, out_of_range=out_of_range
+                )
+            return arr.astype(target_dtype)
+
+        # int→int with scalar_map — widen to int64, apply map, range check
+        case ("int", "int", True):
+            assert scalar_map_entries is not None
+            work = arr.astype(np.int64)
+            apply_scalar_map(work, scalar_map_entries)
+            return check_int_range(
+                work, target_dtype=target_dtype, out_of_range=out_of_range
+            )
+
+        # float→int (with or without scalar_map) — rounding + range check
+        case ("float", "int", _):
+            work = arr.astype(np.float64) if arr.dtype != np.float64 else arr.copy()
+
+            if scalar_map_entries:
+                apply_scalar_map(work, scalar_map_entries)
+
+            bad = np.isnan(work) | np.isinf(work)
+            if bad.any():
+                msg = "Cannot cast NaN or Infinity to integer type without scalar_map"
+                raise ValueError(msg)
+
+            work = round_inplace(work, rounding)
+            return check_int_range(
+                work, target_dtype=target_dtype, out_of_range=out_of_range
+            )
+
+    msg = f"Unhandled type combination: src={src_type}, tgt={tgt_type}"  # pragma: no cover
+    raise AssertionError(msg)  # pragma: no cover
+
+
+def extract_raw_map(
+    data: ScalarMapJSON | None, direction: str
+) -> dict[str, str] | None:
+    """Extract raw string mapping from scalar_map JSON for 'encode' or 'decode'."""
+    if data is None:
+        return None
+    raw: dict[str, str] = {}
+    pairs = data.get(direction, [])
+    for src, tgt in pairs:  # type: ignore[attr-defined]
+        raw[str(src)] = str(tgt)
+    return raw or None

cast_value/types.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Literal, NotRequired, TypeAlias, TypedDict
+
+import numpy as np
+
+NumericScalar: TypeAlias = np.integer | np.floating
+
+RoundingMode = Literal[
+    "nearest-even",
+    "towards-zero",
+    "towards-positive",
+    "towards-negative",
+    "nearest-away",
+]
+
+OutOfRangeMode = Literal["clamp", "wrap"]
+
+
+class ScalarMapJSON(TypedDict):
+    """JSON representation of the scalar_map codec configuration field."""
+
+    encode: NotRequired[list[tuple[object, object]]]
+    decode: NotRequired[list[tuple[object, object]]]
+
+
+# Pre-parsed scalar map entry: (source_scalar, target_scalar)
+MapEntry = tuple[NumericScalar, NumericScalar]

cast_value/zarr_compat/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+try:
+    import zarr  # noqa: F401
+except ImportError as e:
+    _MSG = (
+        "The 'zarr' package is required to use cast_value.zarr_compat. "
+        "Install it with: pip install 'cast-value[zarr]'"
+    )
+    raise ImportError(_MSG) from e
+
+from cast_value.zarr_compat.v1 import CastValue, CastValueNumpy, CastValueRust
+
+__all__ = ["CastValue", "CastValueNumpy", "CastValueRust"]

cast_value/zarr_compat/v1/__init__.py

@@ -0,0 +1,23 @@
+"""cast_value codec implementations for the current zarr-python codec API.
+
+Everything in this package depends on zarr-python's ``ArrayArrayCodec`` ABC
+and related types. When zarr-python ships a new codec interface, a ``v2``
+package can be added alongside this one.
+"""
+
+from __future__ import annotations
+
+from cast_value.zarr_compat.v1._base import CastValueBase, parse_map_entries
+from cast_value.zarr_compat.v1.numpy_codec import CastValueNumpy
+from cast_value.zarr_compat.v1.rust_codec import CastValueRust
+
+# Backwards-compatible alias
+CastValue = CastValueNumpy
+
+__all__ = [
+    "CastValue",
+    "CastValueBase",
+    "CastValueNumpy",
+    "CastValueRust",
+    "parse_map_entries",
+]

cast_value/zarr_compat/v1/_base.py

@@ -0,0 +1,234 @@
+"""Base class and helpers for the cast_value zarr codec (v1 API)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+from zarr.abc.codec import ArrayArrayCodec
+from zarr.core.common import JSON, parse_named_configuration
+from zarr.core.dtype import get_data_type_from_json
+
+from cast_value.core import extract_raw_map
+
+if TYPE_CHECKING:
+    from typing import Self
+
+    from zarr.core.array_spec import ArraySpec
+    from zarr.core.buffer import NDBuffer
+    from zarr.core.chunk_grids import ChunkGrid
+    from zarr.core.dtype.wrapper import TBaseDType, TBaseScalar, ZDType
+
+    from cast_value.types import (
+        MapEntry,
+        OutOfRangeMode,
+        RoundingMode,
+        ScalarMapJSON,
+    )
+
+
+def parse_map_entries(
+    mapping: dict[str, str],
+    src_dtype: ZDType[TBaseDType, TBaseScalar],
+    tgt_dtype: ZDType[TBaseDType, TBaseScalar],
+) -> list[MapEntry]:
+    """Pre-parse a scalar map dict into a list of (src, tgt) tuples.
+
+    Each entry's source value is deserialized using ``src_dtype`` and its target
+    value using ``tgt_dtype``, preserving full precision for both data types.
+    """
+    entries: list[MapEntry] = []
+    for src_str, tgt_str in mapping.items():
+        src = src_dtype.from_json_scalar(src_str, zarr_format=3)
+        tgt = tgt_dtype.from_json_scalar(tgt_str, zarr_format=3)
+        entries.append(cast("MapEntry", (src, tgt)))
+    return entries
+
+
+@dataclass(frozen=True)
+class CastValueBase(ArrayArrayCodec):
+    """Base class for cast-value array-to-array codecs.
+
+    Subclasses must implement ``_cast_array`` to provide the actual
+    array casting logic. Everything else — metadata handling, validation,
+    serialization — is shared.
+
+    Parameters
+    ----------
+    data_type : str
+        Target zarr v3 data type name (e.g. "uint8", "float32").
+    rounding : RoundingMode
+        How to round when exact representation is impossible. Default is "nearest-even".
+    out_of_range : OutOfRangeMode or None
+        What to do when a value is outside the target's range.
+        None means error. "clamp" clips to range. "wrap" uses modular arithmetic
+        (only valid for integer types).
+    scalar_map : dict or None
+        Explicit value overrides as JSON: {"encode": [[src, tgt], ...], "decode": [[src, tgt], ...]}.
+    """
+
+    is_fixed_size = True
+
+    dtype: ZDType[TBaseDType, TBaseScalar]
+    rounding: RoundingMode
+    out_of_range: OutOfRangeMode | None
+    scalar_map: ScalarMapJSON | None
+
+    def __init__(
+        self,
+        *,
+        data_type: str | ZDType[TBaseDType, TBaseScalar],
+        rounding: RoundingMode = "nearest-even",
+        out_of_range: OutOfRangeMode | None = None,
+        scalar_map: ScalarMapJSON | None = None,
+    ) -> None:
+        if isinstance(data_type, str):
+            dtype = get_data_type_from_json(data_type, zarr_format=3)
+        else:
+            dtype = data_type
+        object.__setattr__(self, "dtype", dtype)
+        object.__setattr__(self, "rounding", rounding)
+        object.__setattr__(self, "out_of_range", out_of_range)
+        object.__setattr__(self, "scalar_map", scalar_map)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, JSON]) -> Self:
+        _, configuration_parsed = parse_named_configuration(
+            data, "cast_value", require_configuration=True
+        )
+        return cls(**configuration_parsed)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
+
+    def to_dict(self) -> dict[str, JSON]:
+        config: dict[str, JSON] = {
+            "data_type": cast("JSON", self.dtype.to_json(zarr_format=3))
+        }
+        if self.rounding != "nearest-even":
+            config["rounding"] = self.rounding
+        if self.out_of_range is not None:
+            config["out_of_range"] = self.out_of_range
+        if self.scalar_map is not None:
+            config["scalar_map"] = cast("JSON", self.scalar_map)
+        return {"name": "cast_value", "configuration": config}
+
+    def validate(
+        self,
+        *,
+        shape: tuple[int, ...],  # noqa: ARG002
+        dtype: ZDType[TBaseDType, TBaseScalar],
+        chunk_grid: ChunkGrid,  # noqa: ARG002
+    ) -> None:
+        source_native = dtype.to_native_dtype()
+        target_native = self.dtype.to_native_dtype()
+        for label, dt in [("source", source_native), ("target", target_native)]:
+            if not np.issubdtype(dt, np.integer) and not np.issubdtype(dt, np.floating):
+                msg = (
+                    f"cast_value codec only supports integer and floating-point data types. "
+                    f"Got {label} dtype {dt}."
+                )
+                raise ValueError(msg)
+        if self.out_of_range == "wrap" and not np.issubdtype(target_native, np.integer):
+            msg = "out_of_range='wrap' is only valid for integer target types."
+            raise ValueError(msg)
+
+    def _cast_array(
+        self,
+        arr: np.ndarray,
+        *,
+        target_dtype: np.dtype,
+        scalar_map_entries: list[MapEntry] | None,
+    ) -> np.ndarray:
+        """Cast *arr* to *target_dtype*. Subclasses must override this."""
+        raise NotImplementedError
+
+    def resolve_metadata(self, chunk_spec: ArraySpec) -> ArraySpec:
+        target_zdtype = self.dtype
+        target_native = target_zdtype.to_native_dtype()
+        source_native = chunk_spec.dtype.to_native_dtype()
+
+        fill = chunk_spec.fill_value
+        fill_arr = np.array([fill], dtype=source_native)
+
+        encode_raw = extract_raw_map(self.scalar_map, "encode")
+        encode_entries = (
+            parse_map_entries(encode_raw, chunk_spec.dtype, self.dtype)
+            if encode_raw
+            else None
+        )
+
+        new_fill_arr = self._cast_array(
+            fill_arr,
+            target_dtype=target_native,
+            scalar_map_entries=encode_entries,
+        )
+        new_fill = target_native.type(new_fill_arr[0])
+
+        return replace(chunk_spec, dtype=target_zdtype, fill_value=new_fill)
+
+    def _encode_sync(
+        self,
+        chunk_array: NDBuffer,
+        _chunk_spec: ArraySpec,
+    ) -> NDBuffer | None:
+        arr = chunk_array.as_ndarray_like()
+        target_native = self.dtype.to_native_dtype()
+
+        encode_raw = extract_raw_map(self.scalar_map, "encode")
+        encode_entries = (
+            parse_map_entries(encode_raw, _chunk_spec.dtype, self.dtype)
+            if encode_raw
+            else None
+        )
+
+        result = self._cast_array(
+            np.asarray(arr),
+            target_dtype=target_native,
+            scalar_map_entries=encode_entries,
+        )
+        return chunk_array.__class__.from_ndarray_like(result)  # ty: ignore[invalid-argument-type]
+
+    async def _encode_single(
+        self,
+        chunk_data: NDBuffer,
+        chunk_spec: ArraySpec,
+    ) -> NDBuffer | None:
+        return self._encode_sync(chunk_data, chunk_spec)
+
+    def _decode_sync(
+        self,
+        chunk_array: NDBuffer,
+        chunk_spec: ArraySpec,
+    ) -> NDBuffer:
+        arr = chunk_array.as_ndarray_like()
+        target_native = chunk_spec.dtype.to_native_dtype()
+
+        decode_raw = extract_raw_map(self.scalar_map, "decode")
+        decode_entries = (
+            parse_map_entries(decode_raw, self.dtype, chunk_spec.dtype)
+            if decode_raw
+            else None
+        )
+
+        result = self._cast_array(
+            np.asarray(arr),
+            target_dtype=target_native,
+            scalar_map_entries=decode_entries,
+        )
+        return chunk_array.__class__.from_ndarray_like(result)  # ty: ignore[invalid-argument-type]
+
+    async def _decode_single(
+        self,
+        chunk_data: NDBuffer,
+        chunk_spec: ArraySpec,
+    ) -> NDBuffer:
+        return self._decode_sync(chunk_data, chunk_spec)
+
+    def compute_encoded_size(
+        self, input_byte_length: int, chunk_spec: ArraySpec
+    ) -> int:
+        source_itemsize = chunk_spec.dtype.to_native_dtype().itemsize
+        target_itemsize = self.dtype.to_native_dtype().itemsize
+        if source_itemsize == 0:  # pragma: no cover
+            return 0
+        num_elements = input_byte_length // source_itemsize
+        return num_elements * target_itemsize

cast_value/zarr_compat/v1/numpy_codec.py

@@ -0,0 +1,34 @@
+"""Cast-value codec backed by the pure-numpy implementation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from cast_value.core import cast_array
+from cast_value.zarr_compat.v1._base import CastValueBase
+
+if TYPE_CHECKING:
+    import numpy as np
+
+    from cast_value.types import MapEntry
+
+
+@dataclass(frozen=True, init=False)
+class CastValueNumpy(CastValueBase):
+    """Cast-value codec backed by the pure-numpy implementation."""
+
+    def _cast_array(
+        self,
+        arr: np.ndarray,
+        *,
+        target_dtype: np.dtype,
+        scalar_map_entries: list[MapEntry] | None,
+    ) -> np.ndarray:
+        return cast_array(
+            arr,
+            target_dtype=target_dtype,
+            rounding_mode=self.rounding,
+            out_of_range_mode=self.out_of_range,
+            scalar_map_entries=scalar_map_entries,
+        )

cast_value/zarr_compat/v1/rust_codec.py

@@ -0,0 +1,59 @@
+"""Cast-value codec backed by the cast-value-rs Rust implementation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from cast_value.zarr_compat.v1._base import CastValueBase
+
+if TYPE_CHECKING:
+    from cast_value.types import MapEntry
+
+
+def _dtype_to_str(dtype: np.dtype) -> str:
+    """Convert a numpy dtype to the string name expected by cast-value-rs."""
+    return dtype.name
+
+
+def _convert_scalar_map(
+    entries: list[MapEntry] | None,
+) -> list[tuple[int | float, int | float]] | None:
+    """Convert scalar map entries to plain Python types for cast-value-rs.
+
+    cast-value-rs accepts Python int/float but rejects np.floating scalars.
+    """
+    if entries is None:
+        return None
+    result: list[tuple[int | float, int | float]] = []
+    for src, tgt in entries:
+        src_py: int | float = int(src) if isinstance(src, np.integer) else float(src)
+        tgt_py: int | float = int(tgt) if isinstance(tgt, np.integer) else float(tgt)
+        result.append((src_py, tgt_py))
+    return result
+
+
+@dataclass(frozen=True, init=False)
+class CastValueRust(CastValueBase):
+    """Cast-value codec backed by the cast-value-rs Rust implementation."""
+
+    def _cast_array(
+        self,
+        arr: np.ndarray,
+        *,
+        target_dtype: np.dtype,
+        scalar_map_entries: list[MapEntry] | None,
+    ) -> np.ndarray:
+        from cast_value_rs import (  # noqa: PLC0415  # pylint: disable=import-outside-toplevel
+            cast_array as rs_cast_array,
+        )
+
+        return rs_cast_array(
+            arr=arr,
+            target_dtype=_dtype_to_str(target_dtype),  # ty: ignore[invalid-argument-type]
+            rounding_mode=self.rounding,
+            out_of_range_mode=self.out_of_range,
+            scalar_map_entries=_convert_scalar_map(scalar_map_entries),
+        )

cast_value-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: cast-value
+Version: 0.1.0
+Summary: Python implementation of the `cast_value` codec.
+Project-URL: Homepage, https://github.com/zarr-developers/cast-value
+Project-URL: Bug Tracker, https://github.com/zarr-developers/cast-value/issues
+Project-URL: Discussions, https://github.com/zarr-developers/cast-value/discussions
+Project-URL: Changelog, https://github.com/zarr-developers/cast-value/releases
+Author-email: Davis Bennett <davis.v.bennett@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: numpy>=2.4.3
+Requires-Dist: zarr>=3.1.6
+Provides-Extra: rs
+Requires-Dist: cast-value-rs; extra == 'rs'
+Description-Content-Type: text/markdown
+
+# cast-value
+
+[![Actions Status][actions-badge]][actions-link]
+[![Documentation Status][rtd-badge]][rtd-link]
+
+[![PyPI version][pypi-version]][pypi-link]
+[![Conda-Forge][conda-badge]][conda-link]
+[![PyPI platforms][pypi-platforms]][pypi-link]
+
+[![GitHub Discussion][github-discussions-badge]][github-discussions-link]
+
+[![Coverage][coverage-badge]][coverage-link]
+
+<!-- prettier-ignore-start -->
+[actions-badge]:            https://github.com/zarr-developers/cast-value/actions/workflows/ci.yml/badge.svg
+[actions-link]:             https://github.com/zarr-developers/cast-value/actions
+[conda-badge]:              https://img.shields.io/conda/vn/conda-forge/cast-value
+[conda-link]:               https://github.com/conda-forge/cast-value-feedstock
+[github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
+[github-discussions-link]:  https://github.com/zarr-developers/cast-value/discussions
+[pypi-link]:                https://pypi.org/project/cast-value/
+[pypi-platforms]:           https://img.shields.io/pypi/pyversions/cast-value
+[pypi-version]:             https://img.shields.io/pypi/v/cast-value
+[rtd-badge]:                https://readthedocs.org/projects/cast-value/badge/?version=latest
+[rtd-link]:                 https://cast-value.readthedocs.io/en/latest/?badge=latest
+[coverage-badge]:           https://codecov.io/github/zarr-developers/cast-value/branch/main/graph/badge.svg
+[coverage-link]:            https://codecov.io/github/zarr-developers/cast-value
+
+<!-- prettier-ignore-end -->
+
+# cast-value.py
+
+Python implementation of the `cast_value` codec for Zarr.
+
+## `cast_value` codec
+
+The `cast_value` codec defines an operation for safely converting an array from
+one numeric data type to another.

cast_value-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+cast_value/__init__.py,sha256=wOsAQnva6XpiepVMwm8gJ3ifXxytE1FgjJnDpp5bp7M,233
+cast_value/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+cast_value/_version.pyi,sha256=o7uNL6MhuJoiqpEnriU7rBT6TmkJZA-i2qMoNz9YcgQ,82
+cast_value/core.py,sha256=gjKClyuMhTvGao45HySphi9g7OjsVKdoBb8DOjqG5Gs,9039
+cast_value/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cast_value/types.py,sha256=jqTBgWv1LAD5JQb2saeU9qcXZSU9cVTig4zeuioam8k,676
+cast_value/zarr_compat/__init__.py,sha256=y6F55EMdekcuzKGka-6mWcu28nbJZj5adgMc7qGY64w,421
+cast_value/zarr_compat/v1/__init__.py,sha256=amFI9R0jO8NjZBsb6N0CRNyJghhcaatNRNEIGhMA9o0,691
+cast_value/zarr_compat/v1/_base.py,sha256=LGpKW1sVgQOD7dHCCgj_62xOmf7Qq0HhHSkRnwqKSxM,8242
+cast_value/zarr_compat/v1/numpy_codec.py,sha256=vCvfA1gj58mF7FL0Z4E4GFNw5wyGhtihTtmWveA5CtU,904
+cast_value/zarr_compat/v1/rust_codec.py,sha256=ZaAR8iRakIm9j8oDnmHnAGAp3G6xgdZwEU_MGORRaG4,1881
+cast_value-0.1.0.dist-info/METADATA,sha256=LqPLoMA1sPRy7yFUw5jIo_f5Dym_bKIrUgenssnRVGk,3095
+cast_value-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cast_value-0.1.0.dist-info/licenses/LICENSE,sha256=-ScGXcCIbt9h97OPndFxUZOn2Dkk9C-PQGAw4kH1Uf0,1053
+cast_value-0.1.0.dist-info/RECORD,,

cast_value-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cast_value-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2026 Davis Bennett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.