scorequant 0.1.0__py3-none-any.whl

scorequant/__init__.py

@@ -0,0 +1,139 @@
+"""Information-preserving hard quantization for statistical inference."""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _distribution_version
+
+from .api import fit_quantizer, optimize_partition
+from .artifact import Quantizer
+from .certify import CertificationConfig, certify_partition
+from .components import (
+    LinearComponents,
+    LinearProblem,
+    scores_from_components,
+)
+from .config import (
+    DExchangeConfig,
+    ExecutionConfig,
+    KMeansConfig,
+    MahalanobisLloydConfig,
+    ScalarDPConfig,
+    SoftVoronoiConfig,
+)
+from .criteria import DOptimality, NormalizedTrace, ProfiledDOptimality
+from .information import (
+    binned_fisher_information,
+    efficient_score_bound,
+    efficient_scores,
+    fisher_information,
+    fractional_fisher_information,
+    information_report,
+    profiled_information_report,
+)
+from .partition import exchange_stability_report
+from .providers import (
+    CentralLogRatioScore,
+    DensityRatioScore,
+    LinearComponentScore,
+    ScoreFunction,
+    ScoreProvider,
+)
+from .ratios import (
+    IntensityParameterization,
+    MixtureParameterization,
+    mixture_scores_from_ratios,
+    ratio_closure_report,
+    ratios_from_posteriors,
+)
+from .reports import RatioClosureReport
+from .result import (
+    EfficientScoreBound,
+    GeometryReport,
+    InformationReport,
+    OptimizationTrace,
+    PartitionCertificate,
+    PartitionResult,
+    ProfiledGeometryReport,
+    ProfiledInformationReport,
+    QuantizerResult,
+    StabilityReport,
+)
+from .sources import (
+    GaussLegendreConfig,
+    IntegrationSource,
+    ObservationSample,
+    RatioProvenance,
+    ScoreProvenance,
+    ScoreSample,
+    ScoreSchema,
+)
+from .transforms import FisherTransform
+from .visualization import plot_information, plot_optimization, plot_partition, plot_summary
+
+#: Installed distribution version. Resolved from package metadata so
+#: ``pyproject.toml`` stays the single source of truth; a source tree that was
+#: never installed reports ``"0.0.0.dev0"`` rather than failing to import.
+try:
+    __version__ = _distribution_version("scorequant")
+except PackageNotFoundError:  # pragma: no cover - only hit in an uninstalled tree
+    __version__ = "0.0.0.dev0"
+
+__all__ = [
+    "CentralLogRatioScore",
+    "CertificationConfig",
+    "DExchangeConfig",
+    "ExecutionConfig",
+    "DOptimality",
+    "DensityRatioScore",
+    "EfficientScoreBound",
+    "FisherTransform",
+    "GaussLegendreConfig",
+    "GeometryReport",
+    "InformationReport",
+    "IntegrationSource",
+    "IntensityParameterization",
+    "KMeansConfig",
+    "LinearComponentScore",
+    "LinearComponents",
+    "LinearProblem",
+    "MahalanobisLloydConfig",
+    "MixtureParameterization",
+    "NormalizedTrace",
+    "ObservationSample",
+    "OptimizationTrace",
+    "PartitionCertificate",
+    "PartitionResult",
+    "ProfiledDOptimality",
+    "ProfiledGeometryReport",
+    "ProfiledInformationReport",
+    "Quantizer",
+    "QuantizerResult",
+    "RatioClosureReport",
+    "RatioProvenance",
+    "ScalarDPConfig",
+    "ScoreFunction",
+    "ScoreProvenance",
+    "ScoreProvider",
+    "ScoreSample",
+    "ScoreSchema",
+    "SoftVoronoiConfig",
+    "StabilityReport",
+    "binned_fisher_information",
+    "certify_partition",
+    "efficient_score_bound",
+    "efficient_scores",
+    "exchange_stability_report",
+    "fisher_information",
+    "fit_quantizer",
+    "fractional_fisher_information",
+    "information_report",
+    "mixture_scores_from_ratios",
+    "optimize_partition",
+    "plot_information",
+    "plot_optimization",
+    "plot_partition",
+    "plot_summary",
+    "profiled_information_report",
+    "ratio_closure_report",
+    "ratios_from_posteriors",
+    "scores_from_components",
+]

scorequant/_binstats.py

@@ -0,0 +1,88 @@
+"""Shared weighted per-bin scatter-add statistics.
+
+Every hard-label solver and diagnostic in ScoreQuant repeats the same three
+steps on a fresh set of integer bin labels: scatter-add the row weights into
+per-bin occupancy, scatter-add the weighted rows into per-bin sums, and divide
+to get per-bin means. :func:`scatter_bin_statistics` is that one
+implementation.
+
+Empty-bin policy
+-----------------
+A bin with zero total weight divides its (also zero) sum by one instead of by
+its own zero weight, so its reported mean is exactly ``0.0`` rather than
+``NaN``: ``jnp.where(bin_weights > 0, bin_weights, 1)``. This is the
+``where``-guard used everywhere in ScoreQuant that a hard-label mean can
+legitimately be evaluated on a labeling with an empty declared cell (for
+example, an externally supplied labeling passed to
+:func:`scorequant.information.information_report`).
+
+Callers for whom an empty cell must instead be a caller error (the exact
+exchange engine, which must never propose a state with an unoccupied
+requested cell) raise using the returned ``weights`` array themselves; the
+guard still keeps the arithmetic that produces ``means`` well-defined before
+that check runs, so the two concerns stay independent.
+
+This is deliberately not used for the differentiable soft-responsibility path
+in ``quantizers.soft_voronoi`` (``_soft_fisher``), which floors its occupancy
+with ``jnp.maximum(occupancy, tiny)`` instead. That path's occupancy is a sum
+of continuous softmax responsibilities that is never exactly zero but can be
+arbitrarily small, and it is differentiated through by ``jax.grad``: flooring
+keeps the gradient of the mean finite and well-scaled as the occupancy
+shrinks, while the ``where``-guard's discontinuous branch does not have a
+useful gradient at the switch point. The two guards solve different problems
+and are not interchangeable.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ._execution import scatter_add
+from ._execution import xp as jnp
+
+
+@dataclass(frozen=True, slots=True)
+class BinStatistics:
+    """Per-bin weighted occupancy, value sums, and empty-bin-safe means."""
+
+    weights: jnp.ndarray
+    sums: jnp.ndarray
+    means: jnp.ndarray
+
+
+def scatter_bin_statistics(
+    labels: jnp.ndarray,
+    weights: jnp.ndarray,
+    values: jnp.ndarray,
+    n_bins: int,
+) -> BinStatistics:
+    """Accumulate weighted occupancy, value sums, and safe per-bin means.
+
+    Parameters
+    ----------
+    labels
+        Integer bin label for every row, with shape ``[N]`` and values in
+        ``[0, n_bins)``.
+    weights
+        Nonnegative row weights with shape ``[N]``.
+    values
+        Row values to accumulate, with shape ``[N, D]``.
+    n_bins
+        Total number of bins, including bins no label selects.
+
+    Returns
+    -------
+    BinStatistics
+        ``weights`` and ``sums`` with shape ``[n_bins]`` and ``[n_bins, D]``,
+        and ``means = sums / weights`` with the empty-bin policy documented on
+        this module.
+    """
+    bin_weights = scatter_add(jnp.zeros(n_bins, dtype=weights.dtype), labels, weights)
+    bin_sums = scatter_add(
+        jnp.zeros((n_bins, values.shape[1]), dtype=values.dtype),
+        labels,
+        weights[:, None] * values,
+    )
+    safe_weights = jnp.where(bin_weights > 0, bin_weights, 1)
+    means = bin_sums / safe_weights[:, None]
+    return BinStatistics(weights=bin_weights, sums=bin_sums, means=means)

scorequant/_chunking.py

@@ -0,0 +1,34 @@
+"""Shared memory-bounded row-chunking budget for dense distance kernels.
+
+Several private kernels evaluate one ``[chunk_rows, n_bins]`` (or the
+Mahalanobis ``[chunk_rows, n_bins, rank]`` residual behind it) distance table
+per row chunk instead of materializing the full ``[n_rows, n_bins, rank]``
+tensor at once. ``assignment_chunk_rows`` is the one place that budget is
+computed, so ``partition.py``, ``quantizers.py``, and ``result.py`` size their
+chunks identically instead of drifting apart under independent edits.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+
+# One chunk's dense temporaries (the base distance table plus its
+# per-dimension residual and einsum working set) are held inside this many
+# bytes, independent of total row count.
+WORKING_SET_BYTES = 64 * 1024 * 1024
+
+
+def assignment_chunk_rows(dtype: npt.DTypeLike, n_rows: int, n_bins: int, rank: int) -> int:
+    """Return how many rows one memory-bounded assignment chunk holds.
+
+    ``n_bins * (rank + 4) + 4 * rank`` accounts for the ``[chunk, n_bins]``
+    distance table, the ``[chunk, n_bins, rank]`` residual and einsum
+    temporaries a Mahalanobis assignment needs, and a fixed allowance for the
+    Euclidean case's smaller working set; it is a deliberately generous
+    single formula shared by every chunked assignment kernel rather than a
+    per-kernel estimate.
+    """
+    item_size = np.dtype(dtype).itemsize
+    values_per_row = n_bins * (rank + 4) + 4 * rank
+    return max(1, min(n_rows, WORKING_SET_BYTES // max(item_size * values_per_row, 1)))

scorequant/_execution.py

@@ -0,0 +1,414 @@
+"""Private execution resolution and backend primitive adapters.
+
+Backend selection is scoped with :mod:`contextvars`, so nested public calls
+inherit one resolved runtime without process-global mutable state. Numerical
+modules import ``xp`` instead of a concrete array namespace; backend-name
+conditionals stay in this module.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager, nullcontext
+from contextvars import ContextVar
+from dataclasses import dataclass, fields, is_dataclass, replace
+from functools import cache, wraps
+from types import ModuleType
+from typing import TYPE_CHECKING, Protocol, cast, overload
+
+import numpy as np
+
+from ._typing import ArrayLike
+from .config import DeviceKind, ExecutionConfig
+
+
+@dataclass(frozen=True, slots=True)
+class _Runtime:
+    config: ExecutionConfig
+    namespace: ModuleType
+    device: object | None
+
+
+_ACTIVE_RUNTIME: ContextVar[_Runtime | None] = ContextVar("scorequant_active_runtime", default=None)
+
+
+def _resolve_runtime(config: ExecutionConfig) -> _Runtime:
+    if config.backend == "numpy":
+        return _Runtime(
+            config=replace(config, device="cpu"),
+            namespace=np,
+            device=None,
+        )
+
+    try:
+        import jax
+        import jax.numpy as jax_numpy
+    except ImportError as error:  # pragma: no cover - exercised in isolated import smoke test
+        raise RuntimeError(
+            "the JAX backend is unavailable; install ScoreQuant on CPython with its default "
+            "dependencies or select ExecutionConfig(backend='numpy')"
+        ) from error
+
+    if config.precision == "float64" and not bool(jax.config.x64_enabled):
+        raise RuntimeError(
+            "float64 was requested for the JAX backend, but JAX_ENABLE_X64 is disabled; "
+            "enable X64 before importing JAX or choose precision='float32'"
+        )
+    requested_platform = None if config.device == "default" else config.device
+    devices = jax.devices(requested_platform)
+    if not devices:
+        raise RuntimeError(f"no JAX {config.device!r} device is available")
+    device = devices[0]
+    resolved = replace(config, device=cast(DeviceKind, device.platform))
+    return _Runtime(config=resolved, namespace=jax_numpy, device=device)
+
+
+@contextmanager
+def use_execution(execution: ExecutionConfig | None) -> Iterator[ExecutionConfig]:
+    """Enter a validated execution scope, inheriting an existing scope if omitted."""
+    active = _ACTIVE_RUNTIME.get()
+    if execution is None and active is not None:
+        yield active.config
+        return
+
+    runtime = _resolve_runtime(execution or ExecutionConfig())
+    token = _ACTIVE_RUNTIME.set(runtime)
+    device_scope = nullcontext()
+    if runtime.config.backend == "jax":
+        import jax
+
+        device_scope = jax.default_device(runtime.device)
+    try:
+        with device_scope:
+            yield runtime.config
+    finally:
+        _ACTIVE_RUNTIME.reset(token)
+
+
+def current_execution() -> ExecutionConfig:
+    """Return the active resolved execution, defaulting lazily to JAX."""
+    runtime = _ACTIVE_RUNTIME.get()
+    if runtime is None:
+        return _resolve_runtime(ExecutionConfig()).config
+    return runtime.config
+
+
+def _current_runtime() -> _Runtime:
+    runtime = _ACTIVE_RUNTIME.get()
+    return _resolve_runtime(ExecutionConfig()) if runtime is None else runtime
+
+
+class _NamespaceProxy:
+    """Resolve NumPy-compatible namespace attributes from the active runtime."""
+
+    def __getattr__(self, name: str) -> object:
+        return getattr(_current_runtime().namespace, name)
+
+
+if TYPE_CHECKING:
+    # Shared kernels use NumPy's typed API. At runtime the proxy resolves the
+    # equivalent primitive from the active NumPy or JAX namespace.
+    import numpy as xp
+else:
+    xp = _NamespaceProxy()
+
+
+def apply_precision(array: ArrayLike) -> np.ndarray:
+    """Convert a numerical input according to the active precision policy."""
+    runtime = _current_runtime()
+    values = runtime.namespace.asarray(array)
+    dtype = values.dtype
+    if runtime.config.precision == "float32":
+        return cast(np.ndarray, values.astype(runtime.namespace.float32))
+    if runtime.config.precision == "float64":
+        return cast(np.ndarray, values.astype(runtime.namespace.float64))
+    if not runtime.namespace.issubdtype(dtype, runtime.namespace.inexact):
+        return cast(np.ndarray, values.astype(runtime.namespace.float32))
+    if dtype in (runtime.namespace.float16, getattr(runtime.namespace, "bfloat16", object())):
+        return cast(np.ndarray, values.astype(runtime.namespace.float32))
+    return cast(np.ndarray, values)
+
+
+class _FunctionalUpdate(Protocol):
+    def add(self, values: object) -> object: ...
+
+    def set(self, values: object) -> object: ...
+
+
+class _ArrayAtIndexer(Protocol):
+    def __getitem__(self, indices: object) -> _FunctionalUpdate: ...
+
+
+class _FunctionalArray(Protocol):
+    @property
+    def at(self) -> _ArrayAtIndexer: ...
+
+
+def scatter_add(base: np.ndarray, indices: object, values: object) -> np.ndarray:
+    """Return ``base`` with repeated-index additions applied functionally."""
+    if _current_runtime().config.backend == "jax":
+        return cast(np.ndarray, cast(_FunctionalArray, base).at[indices].add(values))
+    result = np.array(base, copy=True)
+    np.add.at(result, np.asarray(indices), np.asarray(values))
+    return result
+
+
+def scatter_set(base: np.ndarray, indices: object, values: object) -> np.ndarray:
+    """Return ``base`` with selected entries replaced functionally."""
+    if _current_runtime().config.backend == "jax":
+        return cast(np.ndarray, cast(_FunctionalArray, base).at[indices].set(values))
+    result = np.array(base, copy=True)
+    result[np.asarray(indices)] = np.asarray(values)
+    return result
+
+
+def scatter_block_add(base: np.ndarray, row_indices: object, values: object) -> np.ndarray:
+    """Add a square block selected by one index vector."""
+    if _current_runtime().config.backend == "jax":
+        namespace = _current_runtime().namespace
+        selection = namespace.ix_(row_indices, row_indices)
+        return cast(np.ndarray, cast(_FunctionalArray, base).at[selection].add(values))
+    result = np.array(base, copy=True)
+    selection = np.ix_(np.asarray(row_indices), np.asarray(row_indices))
+    result[selection] += np.asarray(values)
+    return result
+
+
+type RandomSeed = int | tuple[int, int]
+
+
+def _key_seed(key: object) -> tuple[int, int]:
+    values = np.asarray(key, dtype=np.uint32)
+    return int(values[0]), int(values[1])
+
+
+def split_seeds(seed: RandomSeed, count: int) -> tuple[RandomSeed, ...]:
+    """Return deterministic independent seeds for the active backend."""
+    if _current_runtime().config.backend == "jax":
+        import jax
+
+        key = (
+            jax.random.PRNGKey(seed) if isinstance(seed, int) else xp.asarray(seed, dtype=xp.uint32)
+        )
+        keys = jax.random.split(key, count)
+        return tuple(_key_seed(key) for key in keys)
+    sequence = np.random.SeedSequence(seed)
+    return tuple(
+        int(child.generate_state(1, dtype=np.uint32)[0]) for child in sequence.spawn(count)
+    )
+
+
+def weighted_choice(seed: RandomSeed, probabilities: object) -> int:
+    """Draw one categorical index with a backend-local deterministic seed."""
+    values = np.asarray(probabilities, dtype=np.float64)
+    values = values / np.sum(values)
+    if _current_runtime().config.backend == "jax":
+        import jax
+
+        key = (
+            jax.random.PRNGKey(seed) if isinstance(seed, int) else xp.asarray(seed, dtype=xp.uint32)
+        )
+        return int(np.asarray(jax.random.choice(key, values.shape[0], p=xp.asarray(values))))
+    return int(np.random.default_rng(seed).choice(values.shape[0], p=values))
+
+
+def random_permutation(seed: int, size: int) -> np.ndarray:
+    """Return one backend-local deterministic permutation."""
+    if _current_runtime().config.backend == "jax":
+        import jax
+
+        return cast(np.ndarray, jax.random.permutation(jax.random.PRNGKey(seed), size))
+    return np.random.default_rng(seed).permutation(size).astype(np.int32)
+
+
+class _OptimizerTransformation(Protocol):
+    def init(self, parameters: np.ndarray) -> object: ...
+
+    def update(
+        self,
+        gradients: np.ndarray,
+        state: object,
+        parameters: np.ndarray,
+    ) -> tuple[np.ndarray, object]: ...
+
+
+@dataclass(slots=True)
+class AdamState:
+    """Opaque backend-owned Adam state shared by the solver orchestration."""
+
+    learning_rate: float
+    gradient_clip: float
+    step: int = 0
+    first_moment: np.ndarray | None = None
+    second_moment: np.ndarray | None = None
+    transformation: _OptimizerTransformation | None = None
+    backend_state: object | None = None
+
+
+def create_adam(
+    parameters: np.ndarray,
+    *,
+    learning_rate: float,
+    gradient_clip: float,
+) -> AdamState:
+    """Create the active backend's private Adam state."""
+    if _current_runtime().config.backend == "jax":
+        import optax
+
+        transformation = cast(
+            _OptimizerTransformation,
+            optax.chain(
+                optax.clip_by_global_norm(gradient_clip),
+                optax.adam(learning_rate, b1=0.9, b2=0.999, eps=1e-8),
+            ),
+        )
+        return AdamState(
+            learning_rate=learning_rate,
+            gradient_clip=gradient_clip,
+            transformation=transformation,
+            backend_state=transformation.init(parameters),
+        )
+    values = np.asarray(parameters)
+    return AdamState(
+        learning_rate=learning_rate,
+        gradient_clip=gradient_clip,
+        first_moment=np.zeros_like(values),
+        second_moment=np.zeros_like(values),
+    )
+
+
+def adam_update(
+    parameters: np.ndarray,
+    gradients: np.ndarray,
+    state: AdamState,
+) -> tuple[np.ndarray, AdamState, float]:
+    """Apply clipping and one bias-corrected Adam update."""
+    gradient_norm = float(np.linalg.norm(np.asarray(gradients)))
+    if _current_runtime().config.backend == "jax":
+        import optax
+
+        transformation = state.transformation
+        if transformation is None:
+            raise RuntimeError("JAX Adam state is missing its transformation")
+        updates, backend_state = transformation.update(
+            gradients,
+            state.backend_state,
+            parameters,
+        )
+        state.backend_state = backend_state
+        state.step += 1
+        return cast(np.ndarray, optax.apply_updates(parameters, updates)), state, gradient_norm
+
+    gradient = np.asarray(gradients)
+    if gradient_norm > state.gradient_clip:
+        gradient = gradient * (state.gradient_clip / gradient_norm)
+    if state.first_moment is None or state.second_moment is None:
+        raise RuntimeError("NumPy Adam state is uninitialized")
+    first = 0.9 * np.asarray(state.first_moment) + 0.1 * gradient
+    second = 0.999 * np.asarray(state.second_moment) + 0.001 * gradient**2
+    state.step += 1
+    first_hat = first / (1 - 0.9**state.step)
+    second_hat = second / (1 - 0.999**state.step)
+    updated = np.asarray(parameters) - state.learning_rate * first_hat / (
+        np.sqrt(second_hat) + 1e-8
+    )
+    state.first_moment = first
+    state.second_moment = second
+    return updated, state, gradient_norm
+
+
+@cache
+def _compiled[**P, R](function: Callable[P, R], static_argnames: tuple[str, ...]) -> Callable[P, R]:
+    import jax
+
+    return jax.jit(function, static_argnames=static_argnames)
+
+
+@overload
+def backend_jit[**P, R](function: Callable[P, R], /) -> Callable[P, R]: ...
+
+
+@overload
+def backend_jit[**P, R](
+    function: None = None, /, *, static_argnames: tuple[str, ...]
+) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
+
+
+def backend_jit[**P, R](
+    function: Callable[P, R] | None = None,
+    /,
+    *,
+    static_argnames: tuple[str, ...] = (),
+) -> Callable[P, R] | Callable[[Callable[P, R]], Callable[P, R]]:
+    """Compile one shared kernel under JAX and call it directly under NumPy."""
+
+    def decorate(target: Callable[P, R]) -> Callable[P, R]:
+        @wraps(target)
+        def dispatched(*args: P.args, **kwargs: P.kwargs) -> R:
+            if _current_runtime().config.backend == "jax":
+                return _compiled(target, static_argnames)(*args, **kwargs)
+            return target(*args, **kwargs)
+
+        return dispatched
+
+    return decorate(function) if function is not None else decorate
+
+
+def execution_scope[**P, R](function: Callable[P, R]) -> Callable[P, R]:
+    """Resolve the ``execution`` keyword for one public numerical operation."""
+
+    @wraps(function)
+    def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
+        execution = kwargs.get("execution")
+        if execution is not None and not isinstance(execution, ExecutionConfig):
+            raise TypeError("execution must be an ExecutionConfig or None")
+        with use_execution(execution):
+            return function(*args, **kwargs)
+
+    return wrapped
+
+
+def canonical_array(value: object) -> np.ndarray:
+    """Copy one backend array into the stable NumPy API representation."""
+    return np.asarray(value).copy()
+
+
+def backend_array(value: np.ndarray) -> np.ndarray:
+    """Place one canonical NumPy array on the active backend.
+
+    The inverse of :func:`canonical_array`, for kernels re-entered from the
+    NumPy arrays a public result stores. ``jax.device_put`` is a transfer
+    rather than a staged primitive, so unlike ``jnp.asarray`` it costs no XLA
+    compilation on the first call for a given shape. The device is left
+    implicit: :func:`use_execution` is already inside
+    ``jax.default_device(runtime.device)``, and naming the device here commits
+    the array through a resharding path two orders of magnitude slower.
+    """
+    runtime = _current_runtime()
+    if runtime.config.backend == "jax":
+        import jax
+
+        return cast(np.ndarray, jax.device_put(value))
+    return np.asarray(value)
+
+
+def canonicalize_public[T](value: T) -> T:
+    """Recursively replace arrays in a public dataclass tree with NumPy arrays."""
+    if isinstance(value, np.ndarray):
+        return value.copy()  # type: ignore[return-value]
+    value_type = type(value)
+    if value_type.__module__.startswith("jax") or value_type.__module__.startswith("numpy"):
+        if hasattr(value, "shape") and hasattr(value, "dtype"):
+            return cast(T, np.asarray(value).copy())
+    if is_dataclass(value) and not isinstance(value, type):
+        for record_field in fields(value):
+            current = getattr(value, record_field.name)
+            canonical = canonicalize_public(current)
+            if canonical is not current:
+                object.__setattr__(value, record_field.name, canonical)
+        return value
+    if isinstance(value, tuple):
+        return cast(T, tuple(canonicalize_public(item) for item in value))
+    if isinstance(value, list):
+        return cast(T, [canonicalize_public(item) for item in value])
+    return value