moat-lib-codec 0.4.10__tar.gz → 0.4.14__tar.gz

{moat_lib_codec-0.4.10/src/moat_lib_codec.egg-info → moat_lib_codec-0.4.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moat-lib-codec
-Version: 0.4.10
+Version: 0.4.14
 Summary: A simple command/stream multiplexer
 Author-email: Matthias Urlichs <matthias@urlichs.de>
 Maintainer-email: Matthias Urlichs <matthias@urlichs.de>
@@ -17,8 +17,8 @@ Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: anyio~=4.2
-Requires-Dist: moat-lib-rpc~=0.4.6
-Requires-Dist: moat-lib-micro~=0.1.0
-Requires-Dist: moat-lib-proxy~=0.1.0
-Requires-Dist: moat-util~=0.61.1
+Requires-Dist: moat-lib-rpc~=0.6.1
+Requires-Dist: moat-lib-micro~=0.2.2
+Requires-Dist: moat-lib-proxy~=0.1.1
+Requires-Dist: moat-util~=0.62.6
 Dynamic: license-file

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/README.md

@@ -1,12 +1,24 @@
 # The MoaT-Codec library
 
 % start synopsis
+% start main
 
 This library packages various codecs used for MoaT protocols
 in a way that's reason- and stream-able.
 
 % end synopsis
 
+## Supplied codecs
+
+- CBOR
+- msgpack
+- no-op
+- UTF-8
+- JSON
+- YAML
+
+% end main
+
 ## Interface
 
 ### Codec

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/debian/changelog

@@ -1,3 +1,45 @@
+moat-lib-codec (0.4.14-1) unstable; urgency=medium
+
+  * New release for 26.0.1
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 18 Feb 2026 18:28:41 +0100
+
+moat-lib-codec (0.4.14-1) unstable; urgency=medium
+
+  * New release for 26.0.1
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 18 Feb 2026 18:06:02 +0100
+
+moat-lib-codec (0.4.11-2) unstable; urgency=medium
+
+  * New release for 26.0.0
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Sun, 08 Feb 2026 11:05:29 +0100
+
+moat-lib-codec (0.4.11-2) unstable; urgency=medium
+
+  * New release for 26.0.0
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Sun, 08 Feb 2026 11:00:01 +0100
+
+moat-lib-codec (0.4.11-2) unstable; urgency=medium
+
+  * New release for 26.0.0
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Sun, 08 Feb 2026 10:32:15 +0100
+
+moat-lib-codec (0.4.10-7) unstable; urgency=medium
+
+  * New release for 25.8.0
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Mon, 05 Jan 2026 15:32:38 +0100
+
+moat-lib-codec (0.4.10-6) unstable; urgency=medium
+
+  * New release for 25.7.7
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Mon, 05 Jan 2026 15:06:55 +0100
+
 moat-lib-codec (0.4.10-5) unstable; urgency=medium
 
   * New release for 25.7.0

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/pyproject.toml

@@ -13,10 +13,10 @@ classifiers = [
 ]
 dependencies = [
     "anyio ~= 4.2",
-    "moat-lib-rpc ~= 0.4.6",
-    "moat-lib-micro ~= 0.1.0",
-    "moat-lib-proxy ~= 0.1.0",
-    "moat-util ~= 0.61.1",
+    "moat-lib-rpc ~= 0.6.1",
+    "moat-lib-micro ~= 0.2.2",
+    "moat-lib-proxy ~= 0.1.1",
+    "moat-util ~= 0.62.6",
 ]
 keywords = ["MoaT"]
 requires-python = ">=3.8"
@@ -25,7 +25,7 @@ maintainers = [{email = "matthias@urlichs.de",name = "Matthias Urlichs"}]
 description='A simple command/stream multiplexer'
 readme = "README.rst"
 authors = [{email = "matthias@urlichs.de",name = "Matthias Urlichs"}]
-version = "0.4.10"
+version = "0.4.14"
 
 [project.urls]
 homepage = "https://m-o-a-t.org"

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/__init__.py

@@ -15,15 +15,19 @@ if TYPE_CHECKING:
 __all__ = ["Codec", "Extension", "NoCodecError", "get_codec"]
 
 
-def get_codec(codec: str, **kw) -> Codec:
+def get_codec(codec: str | Codec, **kw) -> Codec:
     """
     Loads and initializes the named codec.
     """
     from moat.util import import_  # noqa: PLC0415
 
+    if isinstance(codec, Codec):
+        return codec
+    if codec is None:
+        codec = "noop"
     if "." not in codec:
         if codec.startswith("std-"):
-            codec = "moat.util." + codec[4:]
+            codec = "moat.lib.codec.moat_" + codec[4:]
         else:
             codec = "moat.lib.codec." + codec
     return import_(codec).Codec(**kw)

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/_base.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, overload
 
 if TYPE_CHECKING:
     from collections.abc import Callable
     from typing import Any, Self
 
-    ByteType = bytes | bytearray | memoryview[bytes]
-    VarByteType = bytearray | memoryview[bytes]
+    ByteType = bytes | bytearray | memoryview
+    VarByteType = bytearray | memoryview
 
 
 class NoCodecError(ValueError):
@@ -34,12 +34,12 @@ class Codec:
     detected.
 
     After the header is consumed, the application must repeat calling
-    `__anext__` until an object is returned. (If the decoder
+    ``__anext__`` until an object is returned. (If the decoder
     raises `StopAsyncIteration`, feed more data to it and repeat.)
 
     The decoder must leave all incoming data extending past the object in
     its buffer. It must not attempt to decode them until the next call to
-    `__anext__`.
+    ``__anext__``.
     """
 
     def __init__(self, ext=None):
@@ -99,6 +99,11 @@ class Codec:
         raise NotImplementedError
 
 
+if TYPE_CHECKING:
+    EncoderFunc = Callable[[Codec, Any], ByteType | tuple[int, ByteType]]
+    DecoderFunc = Callable[[Codec, ByteType], Any]
+
+
 class Extension:
     def __init__(self):
         self.enc: dict[type, tuple[int | None, Callable]] = {}
@@ -110,25 +115,39 @@ class Extension:
         res.dec.update(self.dec)
         return res
 
-    def encoder(self, key: int | None, cls: type, fn=None) -> None | Callable:
-        def _enc(fn):
+    @overload
+    def encoder(self, key: int | None, cls: type) -> Callable[[EncoderFunc], EncoderFunc]: ...
+
+    @overload
+    def encoder(self, key: int | None, cls: type, fn: EncoderFunc) -> EncoderFunc: ...
+
+    def encoder(
+        self, key: int | None, cls: type, fn: EncoderFunc | None = None
+    ) -> EncoderFunc | Callable[[EncoderFunc], EncoderFunc]:
+        def _enc(fn: EncoderFunc) -> EncoderFunc:
             self.enc[cls] = (key, fn)
             return fn
 
         if fn is None:
             return _enc
-        else:
-            _enc(fn)
+        return _enc(fn)
+
+    @overload
+    def decoder(self, key: int | None) -> Callable[[DecoderFunc], DecoderFunc]: ...
+
+    @overload
+    def decoder(self, key: int | None, fn: DecoderFunc) -> DecoderFunc: ...
 
-    def decoder(self, key: int, fn=None) -> None | Callable:
-        def _dec(fn):
-            self.dec[key] = fn
+    def decoder(
+        self, key: int | None, fn: DecoderFunc | None = None
+    ) -> DecoderFunc | Callable[[DecoderFunc], DecoderFunc]:
+        def _dec(fn: DecoderFunc) -> DecoderFunc:
+            self.dec[key] = fn  # type: ignore[index]  # key can be None for catch-all
             return fn
 
         if fn is None:
             return _dec
-        else:
-            _dec(fn)
+        return _dec(fn)
 
     def encode(self, codec: Codec, obj) -> tuple[int, ByteType]:
         try:

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/_cbor.py

@@ -13,10 +13,10 @@ from ._base import Codec as _Codec
 from ._base import NoCodecError
 
 # Typing
-from typing import cast, TYPE_CHECKING  # isort:skip
+from typing import TYPE_CHECKING, cast  # isort:skip
 
 try:
-    from micropython import const  # pyright:ignore
+    from micropython import const  # type: ignore[import-not-found]  # MicroPython only
 except ImportError:
 
     def const(x: int) -> int:
@@ -29,7 +29,11 @@ if TYPE_CHECKING:
     from typing import Any
 
 
-__all__ = ["Codec", "ExtraData", "Tag"]
+__all__ = ["CBOR_TAG_CBOR_FILEHEADER", "CBOR_TAG_CBOR_LEADER", "Codec", "ExtraData", "Tag"]
+
+
+CBOR_TAG_CBOR_FILEHEADER = const(55799)  # single CBOR content
+CBOR_TAG_CBOR_LEADER = const(55800)  # header for multiple CBOR items
 
 
 class Tag:
@@ -142,7 +146,7 @@ class Codec(_Codec):
         if self._buffer:
             raise RuntimeError("Codec is busy")
 
-        self._buffer = data  # pyright:ignore  # type mismatch
+        self._buffer = cast(bytes, data)
         try:
             res = self._dec_any()
             # chop off the part we've read
@@ -157,12 +161,12 @@ class Codec(_Codec):
         "Add additional input"
         if self._buffer and self._buf_pos < len(self._buffer):
             if self._buf_pos == 0:
-                self._buffer += data
+                self._buffer = cast(bytes, self._buffer + data)
                 return
-            data = self._buffer[self._buf_pos :] + data
-        elif isinstance(data, memoryview):
+            data = cast(bytes, self._buffer[self._buf_pos :] + data)
+        if isinstance(data, memoryview):
             data = bytearray(data)
-        self._buffer = data
+        self._buffer = cast(bytes, data)
         self._buf_pos = 0
 
     def unfeed(self, buf: VarByteType) -> int:
@@ -276,7 +280,8 @@ class Codec(_Codec):
         self._enc_any(val)
 
     def _w(self, d):
-        self._buf_out.extend(d)  # pyright:ignore[reportOptionalMemberAccess]
+        assert self._buf_out is not None  # set by encode() before calling _enc_any()
+        self._buf_out.extend(d)
 
     def _enc_any(self, ob):
         w = self._w

moat_lib_codec-0.4.14/src/moat/lib/codec/_moat_cbor.py

@@ -0,0 +1,136 @@
+"""
+An overly-simple CBOR packer/unpacker.
+"""
+
+# Original Copyright 2014-2015 Brian Olson
+# Apache 2.0 license
+# http://docs.ros.org/en/noetic/api/rosbridge_library/html/cbor_8py_source.html
+# rather heavily modified
+
+from __future__ import annotations
+
+from moat.util import NotGiven
+
+# Typing
+from moat.lib.path import Path
+from moat.lib.proxy import DProxy, Proxy, get_proxy, name2obj, obj2name, unwrap_obj, wrap_obj
+
+from . import Extension
+from . import cbor as _cbor
+from .cbor import Tag
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.lib.codec import ByteType
+
+__all__ = ["Codec", "std_ext"]
+
+std_ext = Extension()
+
+
+class Codec(_cbor.Codec):
+    """
+    CBOR codec with MoaT's standard extensions.
+    """
+
+    def __init__(self):
+        super().__init__(ext=std_ext)
+
+    def decode(self, data: ByteType):  # noqa:D102,RUF100
+        if data == b"":
+            return NotGiven
+        return super().decode(data)
+
+
+@std_ext.encoder(27, DProxy)
+def _enc_dpr(codec, obj):
+    codec  # noqa:B018
+    res = [obj.name] + obj.a
+    if obj.k or (res and isinstance(res[-1], dict)):
+        res.append(obj.k)
+    return res
+
+
+@std_ext.encoder(32769, Proxy)
+def _enc_pr(codec, obj):
+    codec  # noqa:B018
+    return obj.name
+
+
+@std_ext.decoder(32769)
+def _dec_proxy(codec, val):
+    codec  # noqa:B018
+    try:
+        if isinstance(val, (str, int)):
+            return name2obj(val)
+        return unwrap_obj(val)
+    except KeyError:
+        return Proxy(val)
+
+
+@std_ext.decoder(27)
+def _dec_obj(codec, val):
+    codec  # noqa:B018
+    if isinstance(val[0], Tag):
+        if val[0].tag != 32769:
+            return Tag(27, val)  # not decodable
+        val[0] = val[0].value
+    return unwrap_obj(val)
+
+
+@std_ext.encoder(39, Path)
+def _enc_path(codec, val):
+    codec  # noqa:B018
+    return val.raw_rooted
+
+
+@std_ext.decoder(39)
+def _dec_path(codec, val):
+    codec  # noqa:B018
+    if not isinstance(val, (list, tuple)):
+        return Tag(39, val)  # not decodable
+    return Path.build(val, decoded=True)
+
+
+@std_ext.encoder(258, set)
+def _pack_set(codec, data):
+    codec  # noqa:B018
+    return list(data)
+
+
+@std_ext.decoder(258)
+def _dec_set(codec, val):
+    codec  # noqa:B018
+    return set(val)
+
+
+@std_ext.encoder(None, object)
+def enc_any(codec, obj):
+    codec  # noqa:B018
+
+    try:
+        name = obj2name(obj)
+    except KeyError:
+        pass
+    else:
+        return 32769, name
+
+    try:
+        name = obj2name(type(obj))
+    except KeyError:
+        pass
+    else:
+        p = wrap_obj(obj, name=name)
+        return 27, p
+
+    if isinstance(obj, Exception):
+        # RemoteError, cf. moat.lib.codec.errors
+        res = ["_rErr", obj.__class__.__name__]
+        try:
+            res.extend(obj.args)
+        except AttributeError:
+            pass
+        return 27, res
+
+    return 32769, get_proxy(obj)

moat_lib_codec-0.4.14/src/moat/lib/codec/_moat_msgpack.py

@@ -0,0 +1,132 @@
+"""
+This module contains extension handlers for msgpack.
+
+Extension types defined here:
+2: contains raw bytes, interpreted as unsigned bignum
+3: Path, as a msgpack object stream of its elements
+4: contains raw bytes, interpreted as UTF-8, returned as (named) Proxy object
+5: object constructor
+6: marked Path
+"""
+
+from __future__ import annotations
+
+from moat.lib.path import Path
+from moat.lib.proxy import DProxy, Proxy, _CProxy, get_proxy, obj2name, unwrap_obj, wrap_obj
+
+from . import Extension
+from . import msgpack as _msgpack
+
+__all__ = ["Codec", "std_ext"]
+
+
+std_ext = Extension()
+ExtType = _msgpack.ExtType
+
+
+class Codec(_msgpack.Codec):
+    "A MsgPack codec with our extensions"
+
+    def __init__(self):
+        super().__init__(ext=std_ext, use_attrdict=True)
+
+
+@std_ext.encoder(5, DProxy)
+def _enc_dproxy(codec, obj):
+    a = obj.a[:]
+    if obj.k or (a and isinstance(a[-1], dict)):
+        a.append(obj.k)
+    return codec.encode(obj.name) + b"".join(codec.encode(x) for x in a)
+
+
+# not actually used
+@std_ext.encoder(None, ExtType)
+def _enc_exttype(codec, obj):
+    codec  # noqa:B018
+    return obj.type, obj.data
+
+
+@std_ext.encoder(None, Path)
+def _enc_path(codec, obj):
+    if obj.mark:
+        return 6, codec.encode(obj.mark) + b"".join(codec.encode(x) for x in obj.raw)
+    return 3, b"".join(codec.encode(x) for x in obj.raw)
+
+
+@std_ext.encoder(4, Proxy)
+def _enc_proxy(codec, obj):
+    codec  # noqa:B018
+    return obj.name.encode("utf-8")
+
+
+@std_ext.encoder(None, object)
+def _enc_any(codec, obj):
+    try:
+        name = obj2name(obj)
+    except KeyError:
+        pass
+    else:
+        return 4, name.encode("utf-8")
+
+    try:
+        name = obj2name(type(obj))
+    except KeyError:
+        pass
+    else:
+        p = wrap_obj(obj, name=name)
+        return 5, b"".join(codec.encode(x) for x in p)
+
+    if isinstance(obj, Exception):
+        # RemoteError, cf. moat.lib.codec.errors
+        return 5, codec.encode("_rErr") + codec.encode(obj.__class__.__name__) + b"".join(
+            codec.encode(x) for x in obj.args
+        )
+
+    return 4, get_proxy(obj).encode("utf-8")
+
+
+@std_ext.decoder(3)
+def _dec_path(codec, data):
+    codec  # noqa:B018
+    s = Codec()
+    s.feed(data)
+    return Path.build(iter(s), decoded=True)
+
+
+@std_ext.decoder(4)
+def _dec_proxy(codec, data):
+    codec  # noqa:B018
+    if isinstance(data, memoryview):
+        data = bytearray(data)
+    try:
+        n = data.decode("utf-8")
+    except UnicodeError:
+        n = str(data)
+    try:
+        return _CProxy[n]
+    except KeyError:
+        return Proxy(n)
+
+
+@std_ext.decoder(5)
+def _dec_proxy_obj(codec, data):
+    codec = codec.copy()
+    codec.feed(data)
+    s = list(iter(codec))
+    return unwrap_obj(s)
+
+
+@std_ext.decoder(6)
+def _dec_marked_path(codec, data):
+    # A marked path. Deprecated.
+    codec = codec.copy()
+    codec.feed(data)
+    s = iter(codec)
+    mark = next(s)
+    p = Path(*s, mark=mark)
+    return p
+
+
+@std_ext.decoder(None)
+def _dec_blank(codec, data):
+    return ExtType(codec, data)

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/cbor.py

@@ -6,16 +6,14 @@ from __future__ import annotations
 
 import struct
 
-import ruyaml as yaml
+try:
+    from ruyaml import representer
+except ImportError:
+    from ruamel.yaml import representer  # fallback if ruyaml unavailable
 
-from moat.lib.micro import const
+from ._cbor import CBOR_TAG_CBOR_FILEHEADER, CBOR_TAG_CBOR_LEADER, Codec, Tag  # noqa:F401
 
-from ._cbor import Codec, Tag  # noqa:F401
-
-SafeRepresenter = yaml.representer.SafeRepresenter  # pyright:ignore
-
-CBOR_TAG_CBOR_FILEHEADER = const(55799)  # single CBOR content
-CBOR_TAG_CBOR_LEADER = const(55800)  # header for multiple CBOR items
+SafeRepresenter = representer.SafeRepresenter
 
 
 def _tag_repr(dumper, data):

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/errors.py

@@ -4,8 +4,8 @@ FUSE operations for MoaT-micro-FS
 
 from __future__ import annotations
 
+from moat.util import ExpAttrError, ExpKeyError
 from moat.lib.proxy import as_proxy
-from moat.util.exc import ExpAttrError, ExpKeyError
 
 try:
     from moat.lib.rpc import RemoteError
@@ -16,7 +16,7 @@ except ImportError:
 
 
 @as_proxy("_rErrS")
-class SilentRemoteError(RemoteError):
+class SilentRemoteError(RemoteError):  # type: ignore[misc]  # RemoteError may be from two different sources
     """
     Forwarded error from a remote system.
 
@@ -29,7 +29,7 @@ class NoPathError(KeyError):
     """An error that marks a nonexisting path"""
 
     def __str__(self):
-        from moat.util import Path  # noqa: PLC0415
+        from moat.lib.path import Path  # noqa: PLC0415
 
         return (
             f"‹NoPath {self.args[0]} {Path.build(self.args[1])}"
@@ -42,7 +42,7 @@ class NoPathError(KeyError):
 
 
 try:
-    FileNotFoundError  # noqa:B018  # pyright:ignore
+    FileNotFoundError = FileNotFoundError  # noqa:A001,PLW0127
 except NameError:
 
     class FileNotFoundError(SilentRemoteError):  # noqa:A001
@@ -55,7 +55,7 @@ except NameError:
 as_proxy("_FnErr", FileNotFoundError)
 
 try:
-    FileExistsError  # noqa:B018  # pyright:ignore
+    FileExistsError = FileExistsError  # noqa:A001,PLW0127
 except NameError:
 
     class FileExistsError(SilentRemoteError):  # noqa:A001
@@ -69,6 +69,7 @@ as_proxy("_FxErr", FileExistsError)
 
 as_proxy("_KyErr", KeyError)
 as_proxy("_EKyErr", ExpKeyError)
+as_proxy("_IdxErr", IndexError)
 as_proxy("_AtErr", AttributeError)
 as_proxy("_EAtErr", ExpAttrError)
 as_proxy("_NiErr", NotImplementedError)

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/json.py

@@ -9,7 +9,7 @@ from ._base import Codec as _Codec
 try:
     from json import dumps, loads
 except ImportError:
-    from simplejson import dumps, loads
+    from simplejson import dumps, loads  # type: ignore[import-not-found]  # optional fallback
 
 
 class Codec(_Codec):

moat_lib_codec-0.4.14/src/moat/lib/codec/moat_cbor.py

@@ -0,0 +1,257 @@
+"""
+An overly-simple CBOR packer/unpacker.
+"""
+
+# Original Copyright 2014-2015 Brian Olson
+# Apache 2.0 license
+# http://docs.ros.org/en/noetic/api/rosbridge_library/html/cbor_8py_source.html
+# rather heavily modified
+
+from __future__ import annotations
+
+import contextlib
+import datetime as dt
+import re
+from ipaddress import (
+    IPv4Address,
+    IPv4Interface,
+    IPv4Network,
+    IPv6Address,
+    IPv6Interface,
+    IPv6Network,
+)
+
+from ._moat_cbor import Codec, std_ext
+
+# Typing
+from .cbor import CBOR_TAG_CBOR_FILEHEADER, CBOR_TAG_CBOR_LEADER, Tag
+
+__all__ = [
+    "CBOR_TAG_MOAT_CHANGE",
+    "CBOR_TAG_MOAT_FILE_END",
+    "CBOR_TAG_MOAT_FILE_ID",
+    "Codec",
+    "gen_start",
+    "gen_stop",
+    "std_ext",
+]
+
+CBOR_TAG_MOAT_FILE_ID = 1299145044  # 'MoaT'
+CBOR_TAG_MOAT_FILE_END = 1298493254  # 'MeoF'
+CBOR_TAG_MOAT_CHANGE = 1298360423  # 'Mchg'
+
+
+def gen_start(text: str, /, **kw) -> Tag:
+    """
+    Generate a MoaT file start tag
+    """
+    if len(text) > 255:
+        raise ValueError("Description too long")
+    # add padding if too short
+    text += " " * (24 - len(text))
+
+    return Tag(CBOR_TAG_CBOR_LEADER, Tag(CBOR_TAG_MOAT_FILE_ID, (text, kw)))
+
+
+def gen_stop(**kw) -> Tag:
+    """
+    Generate a MoaT file stop tag
+    """
+    return Tag(CBOR_TAG_MOAT_FILE_END, kw)
+
+
+def gen_change(**kw) -> Tag:
+    """
+    Generate a MoaT file stop tag
+    """
+    return Tag(CBOR_TAG_MOAT_CHANGE, kw)
+
+
+@std_ext.encoder(1, dt.datetime)
+def _enc_datetime_ts(codec, value):
+    codec  # noqa:B018
+    if not value.tzinfo:
+        raise ValueError(f"naive datetime {value!r}")
+
+    return value.timestamp()
+
+
+# @std_ext.encoder(0, dt.datetime)
+def _enc_datetime_str(codec, value):
+    codec  # noqa:B018
+
+    if not value.tzinfo:
+        raise ValueError(f"naive datetime {value!r}")
+
+    return value.isoformat().replace("+00:00", "Z")
+
+
+_timestamp_re = re.compile(
+    r"^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(?:\.(\d{1,6})\d*)?(?:Z|([+-])(\d\d):(\d\d))$",
+)
+
+
+@std_ext.decoder(0)
+def _dec_datetime_string(codec, value) -> dt.datetime:
+    codec  # noqa:B018
+
+    match = _timestamp_re.match(value)
+    if match:
+        (
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            secfrac,
+            offset_sign,
+            offset_h,
+            offset_m,
+        ) = match.groups()
+        microsecond = 0 if secfrac is None else int(f"{secfrac:<06}")
+
+        if offset_h:
+            sign = -1 if offset_sign == "-" else 1
+            hours = int(offset_h) * sign
+            minutes = int(offset_m) * sign
+            tz = dt.timezone(dt.timedelta(hours=hours, minutes=minutes))
+        else:
+            tz = dt.UTC
+
+        return dt.datetime(
+            int(year),
+            int(month),
+            int(day),
+            int(hour),
+            int(minute),
+            int(second),
+            microsecond,
+            tz,
+        )
+    else:
+        raise ValueError(f"invalid datetime string: {value!r}")
+
+
+@std_ext.decoder(1)
+def _dec_ts(codec, val):
+    codec  # noqa:B018
+    return dt.datetime.fromtimestamp(val, dt.UTC)
+
+
+@std_ext.decoder(2)
+def _dec_bigp(codec, val):
+    codec  # noqa:B018
+    return int.from_bytes(val, "big")
+
+
+@std_ext.decoder(3)
+def _dec_bign(codec, val):
+    codec  # noqa:B018
+    return -1 - int.from_bytes(val, "big")
+
+
+def _pad(buf, n):
+    buf = bytes(buf)  # SIGH
+    if (lb := len(buf)) == n:
+        return buf
+    return buf + b"\x00" * (n - lb)
+
+
+@std_ext.decoder(52)
+def _dec_ip4address(codec, buf) -> IPv4Address | IPv4Network | IPv4Interface:
+    codec  # noqa:B018
+    from ipaddress import IPv4Address, IPv4Interface, IPv4Network  # noqa: PLC0415
+
+    if isinstance(buf, (bytes, bytearray, memoryview)):
+        return IPv4Address(_pad(buf, 4))
+    elif len(buf) != 2:
+        pass
+    elif isinstance(buf[1], int):
+        return IPv4Interface((_pad(buf[0], 4), buf[1]))
+    else:
+        return IPv4Network((_pad(buf[1], 4), buf[0]))
+
+    raise ValueError(f"invalid ipaddress value {buf!r}")
+
+
+@std_ext.decoder(54)
+def _dec_ip6address(codec, buf) -> IPv6Address | IPv6Network | IPv6Interface:
+    codec  # noqa:B018
+    from ipaddress import IPv6Address, IPv6Interface, IPv6Network  # noqa: PLC0415
+
+    if isinstance(buf, (bytes, bytearray, memoryview)):
+        return IPv6Address(_pad(buf, 16))
+    elif len(buf) != 2:
+        pass
+    elif isinstance(buf[1], int):
+        return IPv6Interface((_pad(buf[0], 16), buf[1]))
+    else:
+        return IPv6Network((_pad(buf[1], 16), buf[0]))
+
+    raise ValueError(f"invalid ipaddress value {buf!r}")
+
+
+@std_ext.encoder(52, IPv4Address)
+@std_ext.encoder(54, IPv6Address)
+def _pack_ip(codec, adr):
+    codec  # noqa:B018
+    return adr.packed.rstrip(b"\x00")
+
+
+@std_ext.encoder(52, IPv4Network)
+@std_ext.encoder(54, IPv6Network)
+def _pack_ipnet(codec, adr):
+    codec  # noqa:B018
+    return (adr.prefixlen, _pack_ip(codec, adr.network_address))
+
+
+@std_ext.encoder(52, IPv4Interface)
+@std_ext.encoder(54, IPv6Interface)
+def _pack_ipintf(codec, adr):
+    codec  # noqa:B018
+    return (_pack_ip(codec, adr), adr.network.prefixlen)
+
+
+@std_ext.decoder(260)
+def _dec_old_ipaddress(codec, buf) -> IPv4Address | IPv6Address | Tag:
+    codec  # noqa:B018
+    if isinstance(buf, (bytes, bytearray, memoryview)) or len(buf) not in (4, 6, 16):
+        if len(buf) == 4:
+            return IPv4Address(bytes(buf))
+        elif len(buf) == 16:
+            return IPv6Address(bytes(buf))
+        elif len(buf) == 6:
+            # MAC address
+            return Tag(260, buf)
+
+    raise ValueError(f"invalid ipaddress value {buf!r}")
+
+
+@std_ext.decoder(261)
+def _dec_old_ipnetwork(codec, buf) -> IPv4Network | IPv6Network:
+    codec  # noqa:B018
+    if isinstance(buf, dict) and len(buf) == 1:
+        mask, buf = next(iter(buf.items()))
+        if len(buf) == 4:
+            return IPv4Network((bytes(buf), mask))
+        elif len(buf) == 16:
+            return IPv6Network((bytes(buf), mask))
+
+    raise ValueError(f"invalid ipnetwork value {buf!r}")
+
+
+@std_ext.decoder(CBOR_TAG_CBOR_FILEHEADER)
+def _dec_file_cbor(codec, val):
+    codec  # noqa:B018
+    with contextlib.suppress(AttributeError):
+        val._cbor_tag = CBOR_TAG_CBOR_FILEHEADER  # noqa: SLF001
+    return val
+
+
+@std_ext.decoder(CBOR_TAG_CBOR_LEADER)
+def _dec_file_cbor(codec, val):
+    codec  # noqa:B018
+    with contextlib.suppress(AttributeError):
+        val._cbor_tag = CBOR_TAG_CBOR_LEADER  # noqa: SLF001
+    return val

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/moat_kv.py

@@ -4,4 +4,4 @@ Alias for moat-kv legacy
 
 from __future__ import annotations
 
-from moat.util.msgpack import Codec  # noqa:F401
+from moat.lib.codec.moat_msgpack import Codec  # noqa:F401

moat_lib_codec-0.4.14/src/moat/lib/codec/moat_msgpack.py

@@ -0,0 +1,29 @@
+"""
+This module contains helper functions for packing+unpacking of single messages,
+plus an unpacker factory for streams.
+
+Extension types defined here:
+2: contains raw bytes, interpreted as unsigned bignum
+3: Path, as a msgpack object stream of its elements
+4: contains raw bytes, interpreted as UTF-8, returned as (named) Proxy object
+5: object constructor
+6: marked Path
+"""
+
+from __future__ import annotations
+
+from ._moat_msgpack import Codec, std_ext
+
+__all__ = ["Codec", "std_ext"]
+
+
+@std_ext.encoder(2, int)
+def _enc_int(codec, n):
+    codec  # noqa:B018
+    return n.to_bytes((n.bit_length() + 7) // 8, "big")
+
+
+@std_ext.decoder(2)
+def _dec_bignum(codec, data):
+    codec  # noqa:B018
+    return int.from_bytes(data, "big")

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/msgpack.py

@@ -137,7 +137,7 @@ _TYPE_EXT = const(5)
 DEFAULT_RECURSE_LIMIT = 20
 
 
-_MSGPACK_HEADERS = {
+_MSGPACK_HEADERS: dict[int, tuple[int, str] | tuple[int, str, int]] = {
     0xC4: (1, "", _TYPE_BIN),
     0xC5: (2, ">H", _TYPE_BIN),
     0xC6: (4, ">I", _TYPE_BIN),
@@ -273,7 +273,7 @@ class Unpacker:
         elif b == 0xC3:
             obj = True
         elif b <= 0xC6:
-            size, fmt, typ = _MSGPACK_HEADERS[b]
+            size, fmt, typ = _MSGPACK_HEADERS[b]  # type: ignore[misc]  # always 3-tuple for these keys
             self._reserve(size)
             if len(fmt) > 0:
                 n = struct.unpack_from(fmt, self._buffer, self._buf_pos)[0]
@@ -282,13 +282,13 @@ class Unpacker:
             self._buf_pos += size
             obj = self._read(n)
         elif b <= 0xC9:
-            size, fmt, typ = _MSGPACK_HEADERS[b]
+            size, fmt, typ = _MSGPACK_HEADERS[b]  # type: ignore[misc]  # always 3-tuple for these keys
             self._reserve(size)
             L, n = struct.unpack_from(fmt, self._buffer, self._buf_pos)
             self._buf_pos += size
             obj = self._read(L)
         elif b <= 0xD3:
-            size, fmt = _MSGPACK_HEADERS[b]
+            size, fmt = _MSGPACK_HEADERS[b]  # type: ignore[misc]  # always 2-tuple for these keys
             self._reserve(size)
             if len(fmt) > 0:
                 obj = struct.unpack_from(fmt, self._buffer, self._buf_pos)[0]
@@ -296,12 +296,12 @@ class Unpacker:
                 obj = self._buffer[self._buf_pos]
             self._buf_pos += size
         elif b <= 0xD8:
-            size, fmt, typ = _MSGPACK_HEADERS[b]
+            size, fmt, typ = _MSGPACK_HEADERS[b]  # type: ignore[misc]  # always 3-tuple for these keys
             self._reserve(size + 1)
             n, obj = struct.unpack_from(fmt, self._buffer, self._buf_pos)
             self._buf_pos += size + 1
         elif b <= 0xDB:
-            size, fmt, typ = _MSGPACK_HEADERS[b]
+            size, fmt, typ = _MSGPACK_HEADERS[b]  # type: ignore[misc]  # always 3-tuple for these keys
             self._reserve(size)
             if len(fmt) > 0:
                 (n,) = struct.unpack_from(fmt, self._buffer, self._buf_pos)
@@ -310,12 +310,12 @@ class Unpacker:
             self._buf_pos += size
             obj = self._read(n)
         elif b <= 0xDD:
-            size, fmt, typ = _MSGPACK_HEADERS[b]
+            size, fmt, typ = _MSGPACK_HEADERS[b]  # type: ignore[misc]  # always 3-tuple for these keys
             self._reserve(size)
             (n,) = struct.unpack_from(fmt, self._buffer, self._buf_pos)
             self._buf_pos += size
         else:  # if b <= 0xDF:  # can't be anything else
-            size, fmt, typ = _MSGPACK_HEADERS[b]
+            size, fmt, typ = _MSGPACK_HEADERS[b]  # type: ignore[misc]  # always 3-tuple for these keys
             self._reserve(size)
             (n,) = struct.unpack_from(fmt, self._buffer, self._buf_pos)
             self._buf_pos += size

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat/lib/codec/yaml.py

@@ -6,6 +6,11 @@ from moat.util import yload, yprint
 
 from ._base import Codec as _Codec
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._base import ByteType
+
 
 class Codec(_Codec):
     "basic JSON codec"
@@ -24,8 +29,8 @@ class Codec(_Codec):
         "basic decoder"
         return yload(data.decode("utf-8"))
 
-    def feed(self, buffer):  # noqa: D102
-        self._buf.extend(buffer)
+    def feed(self, data: ByteType) -> None:  # noqa: D102
+        self._buf.extend(data)
 
     def __next__(self):
         i = self._buf.find(b"\n---\n")

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14/src/moat_lib_codec.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moat-lib-codec
-Version: 0.4.10
+Version: 0.4.14
 Summary: A simple command/stream multiplexer
 Author-email: Matthias Urlichs <matthias@urlichs.de>
 Maintainer-email: Matthias Urlichs <matthias@urlichs.de>
@@ -17,8 +17,8 @@ Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: anyio~=4.2
-Requires-Dist: moat-lib-rpc~=0.4.6
-Requires-Dist: moat-lib-micro~=0.1.0
-Requires-Dist: moat-lib-proxy~=0.1.0
-Requires-Dist: moat-util~=0.61.1
+Requires-Dist: moat-lib-rpc~=0.6.1
+Requires-Dist: moat-lib-micro~=0.2.2
+Requires-Dist: moat-lib-proxy~=0.1.1
+Requires-Dist: moat-util~=0.62.6
 Dynamic: license-file

{moat_lib_codec-0.4.10 → moat_lib_codec-0.4.14}/src/moat_lib_codec.egg-info/SOURCES.txt

@@ -10,12 +10,16 @@ debian/rules
 src/moat/lib/codec/__init__.py
 src/moat/lib/codec/_base.py
 src/moat/lib/codec/_cbor.py
+src/moat/lib/codec/_moat_cbor.py
+src/moat/lib/codec/_moat_msgpack.py
 src/moat/lib/codec/binary.py
 src/moat/lib/codec/bool.py
 src/moat/lib/codec/cbor.py
 src/moat/lib/codec/errors.py
 src/moat/lib/codec/json.py
+src/moat/lib/codec/moat_cbor.py
 src/moat/lib/codec/moat_kv.py
+src/moat/lib/codec/moat_msgpack.py
 src/moat/lib/codec/msgpack.py
 src/moat/lib/codec/noop.py
 src/moat/lib/codec/utf8.py

moat_lib_codec-0.4.14/src/moat_lib_codec.egg-info/requires.txt

@@ -0,0 +1,5 @@
+anyio~=4.2
+moat-lib-micro~=0.2.2
+moat-lib-proxy~=0.1.1
+moat-lib-rpc~=0.6.1
+moat-util~=0.62.6

moat_lib_codec-0.4.10/src/moat_lib_codec.egg-info/requires.txt

@@ -1,5 +0,0 @@
-anyio~=4.2
-moat-lib-micro~=0.1.0
-moat-lib-proxy~=0.1.0
-moat-lib-rpc~=0.4.6
-moat-util~=0.61.1