gpdatacached 0.1.0__py3-none-any.whl

gpdatacached/__init__.py

@@ -0,0 +1,79 @@
+# src/gpdatacached/__init__.py
+
+# Software library version (SemVer), tracks feature releases and bugfixes.
+# Independent of GPDC_PROTOCOL_VERSION in domain.py.
+__version__ = "0.1.0"
+
+from .codec import GPDCCodec, GPDCContainerCodec, GPDCScalarCodec
+from .config import GPDCDomainConfig, GPDCNamespaceConfig
+from .exceptions import (
+    CanonicalObjectReferencedError,
+    CyclicReferenceError,
+    GPDCLockConfigInconsistentError,
+    LockAcquisitionTimeout,
+    ObjectGoneError,
+)
+from .domain import GPDCDomain, reset_domain_config
+from .keys import make_uri, uri_to_redis_key, validate_object_name
+from .namespace import GPDCNamespace
+from .types import GPDCTypeRegistry
+from .object import GPDCDataObject
+from .scalar import GPDCScalarObject
+from .container import GPDCContainerObject
+from .builtins.bool_object import BoolObject
+from .builtins.datetime_object import DateObject, DateTimeObject, TimeObject
+from .builtins.dict_object import DictObject
+from .builtins.float_object import FloatObject
+from .builtins.int_object import IntObject
+from .builtins.list_object import ListObject
+from .builtins.none_object import NoneObject
+from .builtins.set_object import SetObject
+from .builtins.str_object import StrObject
+from .builtins.tuple_object import TupleObject
+
+from .builtins.bool_object import BoolCodec as BoolCodec  # noqa: F401
+from .builtins.datetime_object import DateCodec as DateCodec, DateTimeCodec as DateTimeCodec, TimeCodec as TimeCodec  # noqa: F401
+from .builtins.dict_object import DictCodec as DictCodec  # noqa: F401
+from .builtins.float_object import FloatCodec as FloatCodec  # noqa: F401
+from .builtins.int_object import IntCodec as IntCodec  # noqa: F401
+from .builtins.list_object import ListCodec as ListCodec  # noqa: F401
+from .builtins.none_object import NoneCodec as NoneCodec  # noqa: F401
+from .builtins.set_object import SetCodec as SetCodec  # noqa: F401
+from .builtins.str_object import StrCodec as StrCodec  # noqa: F401
+from .builtins.tuple_object import TupleCodec as TupleCodec  # noqa: F401
+
+__all__ = [
+    "__version__",
+    "CanonicalObjectReferencedError",
+    "CyclicReferenceError",
+    "ObjectGoneError",
+    "GPDCLockConfigInconsistentError",
+    "LockAcquisitionTimeout",
+    "GPDCDomain",
+    "GPDCNamespace",
+    "GPDCDomainConfig",
+    "GPDCNamespaceConfig",
+    "GPDCDataObject",
+    "GPDCScalarObject",
+    "IntObject",
+    "FloatObject",
+    "StrObject",
+    "BoolObject",
+    "DateTimeObject",
+    "DateObject",
+    "TimeObject",
+    "NoneObject",
+    "ListObject",
+    "DictObject",
+    "SetObject",
+    "TupleObject",
+    "GPDCContainerObject",
+    "GPDCCodec",
+    "GPDCContainerCodec",
+    "GPDCScalarCodec",
+    "GPDCTypeRegistry",
+    "validate_object_name",
+    "make_uri",
+    "uri_to_redis_key",
+    "reset_domain_config",
+]

gpdatacached/builtins/__init__.py

@@ -0,0 +1,3 @@
+from .registry import _register_builtin_types
+
+_register_builtin_types()

gpdatacached/builtins/bool_object.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from ..codec import GPDCScalarCodec
+from ..scalar import GPDCScalarObject
+
+
+class BoolCodec(GPDCScalarCodec):
+    @classmethod
+    def encode_value(cls, value: object) -> str:
+        if not isinstance(value, bool):
+            raise TypeError(f"BoolCodec cannot encode {type(value).__name__!r}")
+        return f"bool:{value}"
+
+    @classmethod
+    def decode_value(cls, encoded: str) -> object:
+        type_name, raw = cls._parse_encoded(encoded)
+        if type_name != "bool":
+            raise ValueError(f"BoolCodec cannot decode type {type_name!r}")
+        if raw not in ("True", "False"):
+            raise ValueError(f"Invalid scalar value for type 'bool': {raw!r}")
+        return raw == "True"
+
+
+class BoolObject(GPDCScalarObject):
+    TYPE = "scalar:bool"

gpdatacached/builtins/datetime_object.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import datetime
+
+from ..codec import GPDCScalarCodec
+from ..scalar import GPDCScalarObject
+
+
+class DateTimeCodec(GPDCScalarCodec):
+    @classmethod
+    def encode_value(cls, value: object) -> str:
+        if not isinstance(value, datetime.datetime):
+            raise TypeError(f"DateTimeCodec cannot encode {type(value).__name__!r}")
+        return f"datetime:{value.isoformat()}"
+
+    @classmethod
+    def decode_value(cls, encoded: str) -> object:
+        type_name, raw = cls._parse_encoded(encoded)
+        if type_name != "datetime":
+            raise ValueError(f"DateTimeCodec cannot decode type {type_name!r}")
+        try:
+            return datetime.datetime.fromisoformat(raw)
+        except (ValueError, TypeError):
+            raise ValueError(f"Invalid scalar value for type 'datetime': {raw!r}")
+
+
+class DateCodec(GPDCScalarCodec):
+    @classmethod
+    def encode_value(cls, value: object) -> str:
+        if isinstance(value, datetime.datetime) or not isinstance(value, datetime.date):
+            raise TypeError(f"DateCodec cannot encode {type(value).__name__!r}")
+        return f"date:{value.isoformat()}"
+
+    @classmethod
+    def decode_value(cls, encoded: str) -> object:
+        type_name, raw = cls._parse_encoded(encoded)
+        if type_name != "date":
+            raise ValueError(f"DateCodec cannot decode type {type_name!r}")
+        try:
+            return datetime.date.fromisoformat(raw)
+        except (ValueError, TypeError):
+            raise ValueError(f"Invalid scalar value for type 'date': {raw!r}")
+
+
+class TimeCodec(GPDCScalarCodec):
+    @classmethod
+    def encode_value(cls, value: object) -> str:
+        if not isinstance(value, datetime.time):
+            raise TypeError(f"TimeCodec cannot encode {type(value).__name__!r}")
+        return f"time:{value.isoformat()}"
+
+    @classmethod
+    def decode_value(cls, encoded: str) -> object:
+        type_name, raw = cls._parse_encoded(encoded)
+        if type_name != "time":
+            raise ValueError(f"TimeCodec cannot decode type {type_name!r}")
+        try:
+            return datetime.time.fromisoformat(raw)
+        except (ValueError, TypeError):
+            raise ValueError(f"Invalid scalar value for type 'time': {raw!r}")
+
+
+class DateTimeObject(GPDCScalarObject):
+    TYPE = "scalar:datetime"
+
+
+class DateObject(GPDCScalarObject):
+    TYPE = "scalar:date"
+
+
+class TimeObject(GPDCScalarObject):
+    TYPE = "scalar:time"

gpdatacached/builtins/dict_object.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import collections.abc
+
+from ..codec import GPDCContainerCodec
+from ..container import GPDCContainerObject
+from ..meta import ObjectMeta
+from ..lifecycle import policy_from_meta
+from ..types import decode_element, decode_key, encode_element, encode_key
+
+
+class DictCodec(GPDCContainerCodec):
+    """Codec for Python dict values stored as Redis Hashes."""
+
+    @classmethod
+    def create_raw(cls, namespace, raw_key: str, value: dict, owner_name: str, cache_mode: str, ttl: int) -> None:
+        from ..lifecycle import policy_from_defaults
+        from ..types import encode_element, encode_key
+
+        if not value:
+            return
+        policy = policy_from_defaults(cache_mode, ttl)
+        mapping = {}
+        for k, v in value.items():
+            encoded_key = encode_key(k)
+            mapping[encoded_key] = encode_element(v, namespace, owner_name, policy)
+        namespace._redis().hset(raw_key, mapping=mapping)
+
+    @classmethod
+    def read_raw(cls, namespace, raw_key: str) -> dict:
+        from ..types import decode_element, decode_key
+
+        data = namespace._redis().hgetall(raw_key)
+        if not data:
+            return {}
+        result = {}
+        for encoded_key, encoded_val in data.items():
+            key = decode_key(encoded_key)
+            result[key] = decode_element(encoded_val, namespace)
+        return result
+
+    @classmethod
+    def delete_raw(cls, namespace, raw_key: str) -> None:
+        namespace._redis().delete(raw_key)
+
+
+class DictObject(GPDCContainerObject, collections.abc.MutableMapping):
+    """Redis-backed dict object implementing MutableMapping."""
+
+    TYPE = "collection:dict"
+
+    @property
+    def type(self) -> str:
+        return self.TYPE
+
+    @property
+    def value(self) -> dict:
+        return DictCodec.read_raw(self._namespace, self.raw_key)
+
+    @value.setter
+    def value(self, new_value: dict) -> None:
+        self._reject_value_replacement()
+
+    def __len__(self) -> int:
+        return self._redis().hlen(self.raw_key)
+
+    def __getitem__(self, key: object) -> object:
+        encoded_key = encode_key(key)
+        encoded_val = self._redis().hget(self.raw_key, encoded_key)
+        if encoded_val is None:
+            raise KeyError(key)
+        return decode_element(encoded_val, self._namespace)
+
+    def __setitem__(self, key: object, value: object) -> None:
+        encoded_key = encode_key(key)
+        r = self._redis()
+        old_encoded = r.hget(self.raw_key, encoded_key)
+        meta = ObjectMeta.load(r, self._canonical_redis_key())
+        policy = policy_from_meta(meta) if meta else None
+        encoded_val = encode_element(value, self._namespace, self._data_owner_name(), policy)
+        r.hset(self.raw_key, encoded_key, encoded_val)
+        self._release_element_ref(old_encoded)
+        self._touch()
+
+    def __delitem__(self, key: object) -> None:
+        encoded_key = encode_key(key)
+        r = self._redis()
+        old_encoded = r.hget(self.raw_key, encoded_key)
+        if old_encoded is None:
+            raise KeyError(key)
+        r.hdel(self.raw_key, encoded_key)
+        self._release_element_ref(old_encoded)
+        self._touch()
+
+    def __contains__(self, key: object) -> bool:
+        encoded_key = encode_key(key)
+        return self._redis().hexists(self.raw_key, encoded_key)
+
+    def __iter__(self):
+        for encoded_key in self._redis().hkeys(self.raw_key):
+            yield decode_key(encoded_key)
+
+    def keys(self) -> collections.abc.KeysView:
+        """Return a frozen *KeysView* snapshot.
+
+        Only keys are fetched from Redis (``HKEYS``); values are not decoded.
+        The view is backed by a temporary ``dict`` so mutations to the
+        ``DictObject`` after this call are **not** reflected.
+        """
+        decoded = [decode_key(k) for k in self._redis().hkeys(self.raw_key)]
+        return dict.fromkeys(decoded).keys()
+
+    def values(self) -> collections.abc.ValuesView:
+        """Return a frozen *ValuesView* snapshot.
+
+        All key-value pairs are fetched from Redis (``HGETALL``) and decoded.
+        The view is backed by a temporary ``dict`` so mutations to the
+        ``DictObject`` after this call are **not** reflected.
+        """
+        return self.value.values()
+
+    def items(self) -> collections.abc.ItemsView:
+        """Return a frozen *ItemsView* snapshot.
+
+        All key-value pairs are fetched from Redis (``HGETALL``) and decoded.
+        The view is backed by a temporary ``dict`` so mutations to the
+        ``DictObject`` after this call are **not** reflected.
+        """
+        return self.value.items()
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    _SENTINEL = object()
+
+    def pop(self, key, default=_SENTINEL):
+        encoded_key = encode_key(key)
+        r = self._redis()
+        encoded_val = r.hget(self.raw_key, encoded_key)
+        if encoded_val is None:
+            if default is DictObject._SENTINEL:
+                raise KeyError(key)
+            return default
+        value = self._decode_and_copy_value(encoded_val)
+        del self[key]
+        return value
+
+    def setdefault(self, key, default=None):
+        if key in self:
+            return self[key]
+        self[key] = default
+        return self[key]
+
+    def update(self, other=None, **kwargs):
+        from ..types import encode_session
+
+        pairs = []
+        if other is not None:
+            if hasattr(other, "items"):
+                pairs = list(other.items())
+            else:
+                pairs = list(other)
+        pairs.extend(kwargs.items())
+        if not pairs:
+            return
+        r = self._redis()
+        owner_name = self._data_owner_name()
+        meta = ObjectMeta.load(r, self._canonical_redis_key())
+        policy = policy_from_meta(meta) if meta else None
+        dirty = False
+        try:
+            with encode_session(self._namespace):
+                for k, v in pairs:
+                    encoded_key = encode_key(k)
+                    old_encoded = r.hget(self.raw_key, encoded_key)
+                    encoded_val = encode_element(v, self._namespace, owner_name, policy)
+                    r.hset(self.raw_key, encoded_key, encoded_val)
+                    self._release_element_ref(old_encoded)
+                    dirty = True
+        finally:
+            if dirty:
+                self._touch()
+
+    def clear(self):
+        encoded_vals = self._redis().hvals(self.raw_key)
+        self._redis().delete(self.raw_key)
+        for encoded_val in encoded_vals:
+            self._release_element_ref(encoded_val)
+        self._touch()
+
+    def deepcopy(self):
+        return {k: v.deepcopy() if hasattr(v, "deepcopy") else v for k, v in self.value.items()}

gpdatacached/builtins/float_object.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from ..codec import GPDCScalarCodec
+from ..scalar import GPDCScalarObject
+
+
+class FloatCodec(GPDCScalarCodec):
+    @classmethod
+    def encode_value(cls, value: object) -> str:
+        if not isinstance(value, float):
+            raise TypeError(f"FloatCodec cannot encode {type(value).__name__!r}")
+        return f"float:{value}"
+
+    @classmethod
+    def decode_value(cls, encoded: str) -> object:
+        type_name, raw = cls._parse_encoded(encoded)
+        if type_name != "float":
+            raise ValueError(f"FloatCodec cannot decode type {type_name!r}")
+        try:
+            return float(raw)
+        except ValueError:
+            raise ValueError(f"Invalid scalar value for type 'float': {raw!r}")
+
+
+class FloatObject(GPDCScalarObject):
+    TYPE = "scalar:float"

gpdatacached/builtins/int_object.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from ..codec import GPDCScalarCodec
+from ..scalar import GPDCScalarObject
+
+
+class IntCodec(GPDCScalarCodec):
+    @classmethod
+    def encode_value(cls, value: object) -> str:
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise TypeError(f"IntCodec cannot encode {type(value).__name__!r}")
+        return f"int:{value}"
+
+    @classmethod
+    def decode_value(cls, encoded: str) -> object:
+        type_name, raw = cls._parse_encoded(encoded)
+        if type_name != "int":
+            raise ValueError(f"IntCodec cannot decode type {type_name!r}")
+        try:
+            return int(raw)
+        except (ValueError, OverflowError):
+            raise ValueError(f"Invalid scalar value for type 'int': {raw!r}")
+
+
+class IntObject(GPDCScalarObject):
+    TYPE = "scalar:int"

gpdatacached/builtins/list_object.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import collections.abc
+import uuid
+
+from ..codec import GPDCContainerCodec
+from ..container import GPDCContainerObject
+from ..meta import ObjectMeta
+from ..lifecycle import policy_from_meta
+from ..types import decode_element, encode_element
+
+
+class ListCodec(GPDCContainerCodec):
+    """Codec for Python list values stored as Redis lists."""
+
+    @classmethod
+    def create_raw(cls, namespace, raw_key: str, value: list, owner_name: str, cache_mode: str, ttl: int) -> None:
+        from ..lifecycle import policy_from_defaults
+        from ..types import encode_element
+
+        if not value:
+            return
+        policy = policy_from_defaults(cache_mode, ttl)
+        encoded = [encode_element(v, namespace, owner_name, policy) for v in value]
+        namespace._redis().rpush(raw_key, *encoded)
+
+    @classmethod
+    def read_raw(cls, namespace, raw_key: str) -> list:
+        from ..types import decode_element
+
+        items = namespace._redis().lrange(raw_key, 0, -1)
+        return [decode_element(item, namespace) for item in items]
+
+    @classmethod
+    def delete_raw(cls, namespace, raw_key: str) -> None:
+        namespace._redis().delete(raw_key)
+
+
+class ListObject(GPDCContainerObject, collections.abc.MutableSequence):
+    """Redis-backed list object implementing MutableSequence."""
+
+    TYPE = "collection:list"
+
+    @property
+    def type(self) -> str:
+        return self.TYPE
+
+    @property
+    def value(self) -> list:
+        return ListCodec.read_raw(self._namespace, self.raw_key)
+
+    @value.setter
+    def value(self, new_value: list) -> None:
+        self._reject_value_replacement()
+
+    def __len__(self) -> int:
+        return self._redis().llen(self.raw_key)
+
+    def _normalize_index(self, index: int, message: str = "list index out of range") -> int:
+        if isinstance(index, slice):
+            raise TypeError("ListObject does not support slice indexing; use list(obj)[start:stop] instead")
+        length = self._redis().llen(self.raw_key)
+        if index < 0:
+            index = length + index
+        if index < 0 or index >= length:
+            raise IndexError(message)
+        return index
+
+    def __getitem__(self, index: int | slice) -> object:
+        if isinstance(index, slice):
+            items = self._redis().lrange(self.raw_key, 0, -1)
+            sliced = items[index]
+            return [decode_element(enc, self._namespace) for enc in sliced]
+        index = self._normalize_index(index)
+        encoded = self._redis().lindex(self.raw_key, index)
+        if encoded is None:
+            raise IndexError("list index out of range")
+        return decode_element(encoded, self._namespace)
+
+    def __setitem__(self, index: int, value: object) -> None:
+        r = self._redis()
+        index = self._normalize_index(index, "list assignment index out of range")
+        old_encoded = r.lindex(self.raw_key, index)
+        meta = ObjectMeta.load(r, self._canonical_redis_key())
+        policy = policy_from_meta(meta) if meta else None
+        encoded = encode_element(value, self._namespace, self._data_owner_name(), policy)
+        r.lset(self.raw_key, index, encoded)
+        self._release_element_ref(old_encoded)
+        self._touch()
+
+    def _delete_index(self, index: int) -> str:
+        r = self._redis()
+        index = self._normalize_index(index, "list assignment index out of range")
+        old_encoded = r.lindex(self.raw_key, index)
+        if old_encoded is None:
+            raise IndexError("list assignment index out of range")
+        sentinel = f"__del_sentinel_{uuid.uuid4().hex}__"
+        r.lset(self.raw_key, index, sentinel)
+        r.lrem(self.raw_key, 1, sentinel)
+        self._release_element_ref(old_encoded)
+        self._touch()
+        return old_encoded
+
+    def __delitem__(self, index: int) -> None:
+        self._delete_index(index)
+
+    def insert(self, index: int, value: object) -> None:
+        r = self._redis()
+        items = r.lrange(self.raw_key, 0, -1)
+        meta = ObjectMeta.load(r, self._canonical_redis_key())
+        policy = policy_from_meta(meta) if meta else None
+        encoded = encode_element(value, self._namespace, self._data_owner_name(), policy)
+        items.insert(index, encoded)
+        pipe = r.pipeline()
+        pipe.delete(self.raw_key)
+        if items:
+            pipe.rpush(self.raw_key, *items)
+        pipe.execute()
+        self._touch()
+
+    def append(self, value: object) -> None:
+        meta = self.meta
+        policy = policy_from_meta(meta) if meta else None
+        encoded = encode_element(value, self._namespace, self._data_owner_name(), policy)
+        self._redis().rpush(self.raw_key, encoded)
+        self._touch()
+
+    def extend(self, values) -> None:
+        from ..types import encode_session
+
+        owner_name = self._data_owner_name()
+        meta = self.meta
+        policy = policy_from_meta(meta) if meta else None
+        with encode_session(self._namespace):
+            encoded = [encode_element(v, self._namespace, owner_name, policy) for v in values]
+        if encoded:
+            self._redis().rpush(self.raw_key, *encoded)
+        self._touch()
+
+    def clear(self) -> None:
+        items = self._redis().lrange(self.raw_key, 0, -1)
+        self._redis().delete(self.raw_key)
+        for item in items:
+            self._release_element_ref(item)
+        self._touch()
+
+    def pop(self, index: int = -1) -> object:
+        if index == -1:
+            r = self._redis()
+            encoded = r.lindex(self.raw_key, -1)
+            if encoded is None:
+                raise IndexError("pop from empty list")
+            value = self._decode_and_copy_value(encoded)
+            self._delete_index(-1)
+            return value
+        index = self._normalize_index(index, "pop index out of range")
+        encoded = self._redis().lindex(self.raw_key, index)
+        if encoded is None:
+            raise IndexError("pop index out of range")
+        value = self._decode_and_copy_value(encoded)
+        self._delete_index(index)
+        return value
+
+    def remove(self, value: object) -> None:
+        target_ref = None
+        if isinstance(value, GPDCContainerObject):
+            if value._namespace is not self._namespace:
+                raise ValueError("Cross-namespace container reference sharing is not supported")
+            target_ref = value._encode_as_ref_value()
+
+        for index, encoded in enumerate(self._redis().lrange(self.raw_key, 0, -1)):
+            if target_ref is not None and encoded == target_ref:
+                self._delete_index(index)
+                return
+            if target_ref is None and decode_element(encoded, self._namespace) == value:
+                self._delete_index(index)
+                return
+
+        raise ValueError(f"{value!r} is not in list")
+
+    def reverse(self) -> None:
+        r = self._redis()
+        items = r.lrange(self.raw_key, 0, -1)
+        items.reverse()
+        pipe = r.pipeline()
+        pipe.delete(self.raw_key)
+        if items:
+            pipe.rpush(self.raw_key, *items)
+        pipe.execute()
+        self._touch()
+
+    def sort(self, *, key=None, reverse=False) -> None:
+        r = self._redis()
+        raw_items = r.lrange(self.raw_key, 0, -1)
+        pairs = [(decode_element(enc, self._namespace), enc) for enc in raw_items]
+        pairs.sort(key=lambda p: key(p[0]) if key else p[0], reverse=reverse)
+        encoded = [enc for _, enc in pairs]
+        pipe = r.pipeline()
+        pipe.delete(self.raw_key)
+        if encoded:
+            pipe.rpush(self.raw_key, *encoded)
+        pipe.execute()
+        self._touch()
+
+    def count(self, value: object) -> int:
+        items = self.value
+        return items.count(value)
+
+    def index(self, value: object, start: int = 0, stop: int = None) -> int:  # type: ignore[override]
+        items = self.value
+        if stop is None:
+            return items.index(value, start)
+        return items.index(value, start, stop)
+
+    def deepcopy(self):
+        return [v.deepcopy() if hasattr(v, "deepcopy") else v for v in self.value]
+
+    def __add__(self, other):
+        """Not supported. Use ``list(obj) + other`` to concatenate."""
+        raise NotImplementedError("ListObject does not support +; use list(obj) + other instead.")
+
+    def __radd__(self, other):
+        """Not supported. Use ``other + list(obj)`` to concatenate."""
+        raise NotImplementedError("ListObject does not support +; use other + list(obj) instead.")
+
+    def __mul__(self, other):
+        """Not supported. Use ``list(obj) * n`` to repeat."""
+        raise NotImplementedError("ListObject does not support *; use list(obj) * n instead.")
+
+    def __rmul__(self, other):
+        """Not supported. Use ``n * list(obj)`` to repeat."""
+        raise NotImplementedError("ListObject does not support *; use n * list(obj) instead.")

gpdatacached/builtins/none_object.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from ..codec import GPDCScalarCodec
+from ..scalar import GPDCScalarObject
+
+
+class NoneCodec(GPDCScalarCodec):
+    @classmethod
+    def encode_value(cls, value: object) -> str:
+        if value is not None:
+            raise TypeError(f"NoneCodec cannot encode {type(value).__name__!r}")
+        return "none:None"
+
+    @classmethod
+    def decode_value(cls, encoded: str) -> object:
+        type_name, raw = cls._parse_encoded(encoded)
+        if type_name != "none":
+            raise ValueError(f"NoneCodec cannot decode type {type_name!r}")
+        if raw != "None":
+            raise ValueError(f"Invalid scalar value for type 'none': {raw!r}")
+        return None
+
+
+class NoneObject(GPDCScalarObject):
+    TYPE = "scalar:none"