moat-lib-proxy 0.1.0__tar.gz

moat_lib_proxy-0.1.0/LICENSE.txt

@@ -0,0 +1,14 @@
+The code in this repository, and all MoaT submodules it refers to,
+is part of the MoaT project.
+
+Unless a submodule's LICENSE.txt states otherwise, all included files are
+licensed under the LGPL V3, as published by the FSF at
+https://www.gnu.org/licenses/lgpl-3.0.html .
+
+In addition to the LGPL's terms, the author(s) respectfully ask all users of
+this code to contribute any bug fixes or enhancements. Also, please link back to
+https://M-o-a-T.org.
+
+Thank you.
+
+Copyright © 2021 ff.: the MoaT contributor(s), as per the git changelog(s).

moat_lib_proxy-0.1.0/Makefile

@@ -0,0 +1,14 @@
+#!/usr/bin/make -f
+
+PACKAGE = moat-lib-proxy
+MAKEINCL ?= $(shell python3 -mmoat src path)/make/py
+
+ifneq ($(wildcard $(MAKEINCL)),)
+include $(MAKEINCL)
+# availabe via http://github.com/smurfix/sourcemgr
+
+else
+%:
+	@echo "Please fix 'python3 -mmoat src path'."
+	@exit 1
+endif

moat_lib_proxy-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: moat-lib-proxy
+Version: 0.1.0
+Summary: Proxy helpers for serializing and deserializing objects
+Maintainer-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AnyIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.0
+Requires-Dist: moat-util~=0.6
+Requires-Dist: moat-lib-micro~=0.1.0
+Dynamic: license-file
+
+# Proxy helpers
+
+% start main
+% start synopsis
+
+This module provides proxy helpers for serializing and deserializing objects
+across process boundaries or network connections. It includes:
+
+- Transparent proxy objects that can be serialized and reconstructed
+- Object registration and name mapping for proxied objects
+- Data-carrying proxies (DProxy) for including object state
+- Integration with CBOR, msgpack, and other serialization formats
+
+% end synopsis
+
+## Usage
+
+### Basic proxy registration
+
+```python
+from moat.lib.proxy import name2obj, obj2name, Proxy
+
+# Register a class for proxying
+class MyService:
+    def do_something(self):
+        return "result"
+
+# Register the class with a name
+name2obj("myapp.MyService", MyService)
+
+# Get the proxy name for an object
+service = MyService()
+proxy_name = obj2name(service)  # Returns "myapp.MyService"
+```
+
+### Using proxies
+
+```python
+from moat.lib.proxy import as_proxy, get_proxy
+
+# Create a proxy reference to an object
+obj = MyService()
+proxy = as_proxy(obj)  # Returns a Proxy object
+
+# Later, retrieve the original object
+original = get_proxy(proxy)  # Returns the MyService instance
+```
+
+### Data-carrying proxies (DProxy)
+
+```python
+from moat.lib.proxy import DProxy
+
+class MyData(DProxy):
+    """A proxy that includes object state"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __reduce__(self):
+        # Define how to serialize the object
+        return (self.__class__, (self.value,))
+
+# The object can be serialized with its state
+data = MyData(42)
+# When serialized and deserialized, the value is preserved
+```
+
+### Working with serialization
+
+```python
+from moat.lib.proxy import wrap_obj, unwrap_obj
+
+# Serialize an object for transmission
+class MyObject:
+    pass
+
+name2obj("myapp.MyObject", MyObject)
+obj = MyObject()
+
+# Wrap for serialization
+wrapped = wrap_obj(obj)  # Creates a serializable representation
+
+# Later, unwrap to reconstruct
+reconstructed = unwrap_obj(wrapped)  # Returns a MyObject instance
+```
+
+## Integration with Serialization Formats
+
+This module integrates with MoaT's serialization libraries:
+
+- **CBOR**: `moat.lib.codec.cbor`
+- **Msgpack**: `moat.lib.codec.msgpack`
+- **YAML**: Supports proxy references in configuration files
+
+% end main

moat_lib_proxy-0.1.0/README.md

@@ -0,0 +1,96 @@
+# Proxy helpers
+
+% start main
+% start synopsis
+
+This module provides proxy helpers for serializing and deserializing objects
+across process boundaries or network connections. It includes:
+
+- Transparent proxy objects that can be serialized and reconstructed
+- Object registration and name mapping for proxied objects
+- Data-carrying proxies (DProxy) for including object state
+- Integration with CBOR, msgpack, and other serialization formats
+
+% end synopsis
+
+## Usage
+
+### Basic proxy registration
+
+```python
+from moat.lib.proxy import name2obj, obj2name, Proxy
+
+# Register a class for proxying
+class MyService:
+    def do_something(self):
+        return "result"
+
+# Register the class with a name
+name2obj("myapp.MyService", MyService)
+
+# Get the proxy name for an object
+service = MyService()
+proxy_name = obj2name(service)  # Returns "myapp.MyService"
+```
+
+### Using proxies
+
+```python
+from moat.lib.proxy import as_proxy, get_proxy
+
+# Create a proxy reference to an object
+obj = MyService()
+proxy = as_proxy(obj)  # Returns a Proxy object
+
+# Later, retrieve the original object
+original = get_proxy(proxy)  # Returns the MyService instance
+```
+
+### Data-carrying proxies (DProxy)
+
+```python
+from moat.lib.proxy import DProxy
+
+class MyData(DProxy):
+    """A proxy that includes object state"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __reduce__(self):
+        # Define how to serialize the object
+        return (self.__class__, (self.value,))
+
+# The object can be serialized with its state
+data = MyData(42)
+# When serialized and deserialized, the value is preserved
+```
+
+### Working with serialization
+
+```python
+from moat.lib.proxy import wrap_obj, unwrap_obj
+
+# Serialize an object for transmission
+class MyObject:
+    pass
+
+name2obj("myapp.MyObject", MyObject)
+obj = MyObject()
+
+# Wrap for serialization
+wrapped = wrap_obj(obj)  # Creates a serializable representation
+
+# Later, unwrap to reconstruct
+reconstructed = unwrap_obj(wrapped)  # Returns a MyObject instance
+```
+
+## Integration with Serialization Formats
+
+This module integrates with MoaT's serialization libraries:
+
+- **CBOR**: `moat.lib.codec.cbor`
+- **Msgpack**: `moat.lib.codec.msgpack`
+- **YAML**: Supports proxy references in configuration files
+
+% end main

moat_lib_proxy-0.1.0/debian/.gitignore

@@ -0,0 +1,7 @@
+/files
+/*.log
+/*.debhelper
+/*.debhelper-build-stamp
+/*.substvars
+/debhelper-build-stamp
+/python3-moat-lib-proxy

moat_lib_proxy-0.1.0/debian/changelog

@@ -0,0 +1,29 @@
+moat-lib-proxy (0.1.0-5) unstable; urgency=medium
+
+  * New release for 25.7.0
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 31 Dec 2025 13:41:19 +0100
+
+moat-lib-proxy (0.1.0-4) unstable; urgency=medium
+
+  * New release for 25.7.0
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 31 Dec 2025 09:42:20 +0100
+
+moat-lib-proxy (0.1.0-3) unstable; urgency=medium
+
+  * New release for 25.7.0
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 31 Dec 2025 09:30:06 +0100
+
+moat-lib-proxy (0.1.0-2) unstable; urgency=medium
+
+  * New release for 25.7.0
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 31 Dec 2025 08:57:53 +0100
+
+moat-lib-proxy (0.1.0-1) unstable; urgency=medium
+
+  * Initial release
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Fri, 27 Dec 2024 00:00:00 +0100

moat_lib_proxy-0.1.0/debian/control

@@ -0,0 +1,20 @@
+Source: moat-lib-proxy
+Maintainer: "Matthias Urlichs" <matthias@urlichs.de>
+Section: python
+Priority: optional
+Build-Depends: dh-python, python3-all, debhelper (>= 13),
+  python3-setuptools,
+  python3-wheel,
+Standards-Version: 3.9.6
+Homepage: https://m-o-a-t.org
+X-DH-Compat: 13
+
+Package: python3-moat-lib-proxy
+Architecture: all
+Depends: ${misc:Depends}, ${python3:Depends},
+  python3-anyio (>= 4.0),
+  python3-moat-util (>= 0.6),
+Description: Proxy helpers for serializing and deserializing objects
+  This module provides proxy helpers for transparently serializing and
+  deserializing objects across process boundaries or network connections,
+  with integration for CBOR, msgpack, and other serialization formats.

moat_lib_proxy-0.1.0/debian/rules

@@ -0,0 +1,5 @@
+#!/usr/bin/make -f
+
+export PYBUILD_NAME=moat-lib-proxy
+%:
+	dh $@ --with python3 --buildsystem=pybuild

moat_lib_proxy-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["wheel","setuptools"]
+
+[project]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: AnyIO",
+    "Framework :: Trio",
+    "Framework :: AsyncIO",
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Developers",
+]
+dependencies = [
+    "anyio ~= 4.0",
+    "moat-util ~= 0.6",
+    "moat-lib-micro ~= 0.1.0",
+]
+keywords = ["MoaT"]
+requires-python = ">=3.8"
+name = "moat-lib-proxy"
+maintainers = [{email = "matthias@urlichs.de",name = "Matthias Urlichs"}]
+description='Proxy helpers for serializing and deserializing objects'
+readme = "README.md"
+version = "0.1.0"
+
+[project.urls]
+homepage = "https://m-o-a-t.org"
+repository = "https://github.com/M-o-a-T/moat"
+
+[tool.setuptools]
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.yaml"]

moat_lib_proxy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moat_lib_proxy-0.1.0/src/moat/lib/proxy/__init__.py

@@ -0,0 +1,31 @@
+"""
+Proxy helpers for MoaT applications.
+"""
+
+from __future__ import annotations
+
+from ._impl import DProxy as DProxy
+from ._impl import NoProxyError as NoProxyError
+from ._impl import Proxy as Proxy
+from ._impl import _CProxy as _CProxy
+from ._impl import as_proxy as as_proxy
+from ._impl import drop_proxy as drop_proxy
+from ._impl import get_proxy as get_proxy
+from ._impl import name2obj as name2obj
+from ._impl import obj2name as obj2name
+from ._impl import unwrap_obj as unwrap_obj
+from ._impl import wrap_obj as wrap_obj
+
+__all__ = [
+    "DProxy",
+    "NoProxyError",
+    "Proxy",
+    "_CProxy",
+    "as_proxy",
+    "drop_proxy",
+    "get_proxy",
+    "name2obj",
+    "obj2name",
+    "unwrap_obj",
+    "wrap_obj",
+]

moat_lib_proxy-0.1.0/src/moat/lib/proxy/_impl.py

@@ -0,0 +1,155 @@
+"""
+This module contains proxy helpers.
+"""
+
+from __future__ import annotations
+
+from inspect import isfunction
+
+__all__ = [
+    "DProxy",
+    "NoProxyError",
+    "Proxy",
+    "_CProxy",
+    "as_proxy",
+    "drop_proxy",
+    "get_proxy",
+    "name2obj",
+    "obj2name",
+    "unwrap_obj",
+    "wrap_obj",
+]
+
+from anyio import Path as AioPath
+from pathlib import Path as FSPath
+
+from moat.lib.proxy._proxy import DProxy as _DProxy
+from moat.lib.proxy._proxy import (
+    NotGiven,
+    Proxy,
+    _CProxy,
+    as_proxy,
+    drop_proxy,
+    get_proxy,
+    name2obj,
+    obj2name,
+)
+from moat.util.pp import pop_kw, push_kw
+
+
+class NoProxyError(ValueError):
+    "Error for nonexistent proxy values"
+
+    # pylint:disable=unnecessary-pass
+
+
+class DProxy(_DProxy):
+    """
+    A proxy object with data. This is implemented as a type that's proxied,
+    thus the object can be reconstituted by the receiver (if it knows the
+    proxy class) or at least rebuilt when the original sender gets the
+    proxy structure back (if it doesn't). The object's state is included.
+    """
+
+    def __init__(self, name, a, k):
+        a = list(a) if a else []
+        super().__init__(name, a, k)
+
+    def append(self, val):
+        "Helper for deserializer"
+        self.a.append(val)
+
+    def __setitem__(self, key, val):
+        "Helper for deserializer"
+        self.k[key] = val
+
+    def __reduce__(self):
+        return (type(self), self.a, self.k)
+
+
+as_proxy("_", NotGiven)
+as_proxy("_p", Proxy)
+
+as_proxy("_fp", FSPath)
+as_proxy("_fpa", AioPath)
+
+
+def _next(it, dfl=None):
+    try:
+        return next(it)
+    except StopIteration:
+        return dfl
+
+
+def wrap_obj(obj, name=None):
+    "Serialize an object"
+    if name is None:
+        name = obj2name(type(obj))
+    try:
+        p = obj.__reduce__()
+        if not isinstance(p, (list, tuple)):
+            res = (name, (), p)
+        elif hasattr(p[0], "__name__"):  # grah
+            if p[0].__name__ == "_reconstructor":
+                _, _o, ak = p
+                if len(ak) == 1:
+                    k = ak
+                    a = []
+                else:
+                    a, k = ak
+                res = [name]
+                res.extend(a)
+                push_kw(res, k)
+            elif p[0].__name__ == "__newobj__":
+                raise NotImplementedError(p)
+                res = (p[1][0], p[1][1:]) + tuple(p[2:])
+            else:
+                res = (name,) + p[1]
+                if (len(p) == 3 and p[2]) or isinstance(p[-1], dict):
+                    res += (p[2],)
+                elif len(p) > 3:
+                    raise NotImplementedError(p)
+
+        elif p[0] is not type(obj):
+            raise ValueError(f"Reducer for {obj!r}")
+        else:
+            raise NotImplementedError(p)
+            res = (name,) + p[1]
+        return res
+
+    except (AttributeError, ValueError):
+        p = obj.__getstate__()
+        if isinstance(p, dict):
+            p = (p,)
+        return (name,) + p
+
+
+def unwrap_obj(s):
+    "Deserialize an object"
+    pk, *a = s
+    if not isinstance(pk, type):
+        # otherwise it was tagged and de-proxied already
+        if isinstance(pk, Proxy):
+            pk = pk.name
+        try:
+            pk = _CProxy[pk]
+        except KeyError:
+            kw = pop_kw(a)
+            return DProxy(pk, a, kw)
+    kw = pop_kw(a)
+
+    if isfunction(pk):
+        return pk(*a, **kw)
+
+    if (pkr := getattr(pk, "_moat__restore", None)) is not None:
+        pk = pkr(a, kw)
+    else:
+        try:
+            pk = pk(*a, **kw)
+        except (TypeError, ValueError):
+            if not issubclass(pk, Exception):
+                raise
+            pk = pk(*a)
+            for k, v in kw.items():
+                setattr(pk, k, v)
+    return pk

moat_lib_proxy-0.1.0/src/moat/lib/proxy/_proxy.py

@@ -0,0 +1,196 @@
+"""
+A hacked-up copy of some parts of `moat.util`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from typing import Any, TypeVar, overload
+
+__all__ = [
+    "DProxy",
+    "NoProxyError",
+    "Proxy",
+    "as_proxy",
+    "drop_proxy",
+    "get_proxy",
+    "name2obj",
+    "obj2name",
+]
+
+NotGiven = ...  # from moat.util import NotGiven
+
+
+_pkey = 1
+_CProxy = {}  # name > object
+_RProxy = {}  # object > name
+
+
+def name2obj(name, obj=NotGiven):
+    """
+    Given a proxy name, return the referred object.
+
+    If @obj is given, associate.
+    """
+    if obj is NotGiven and _CProxy:
+        return _CProxy[name]
+    _CProxy[name] = obj
+    _RProxy[id(obj)] = name
+    return None
+
+
+def obj2name(obj):
+    """
+    Given a proxied object, return the name referring to it.
+    """
+    return _RProxy[id(obj)]
+
+
+def get_proxy(obj):
+    """
+    Given a proxied object, return the name referring to it.
+
+    If unknown, create a new temporary name.
+    """
+    try:
+        return _RProxy[id(obj)]
+    except KeyError:
+        global _pkey
+        k = "p_" + str(_pkey)
+        _pkey += 1
+        _CProxy[k] = obj
+        _RProxy[id(obj)] = k
+        return k
+
+
+# def _getstate(self):
+#     return (type(self), (), self.__dict__)
+
+
+if TYPE_CHECKING:
+    T = TypeVar("T")
+
+    @overload
+    def as_proxy(name: str) -> Callable[[T], T]: ...
+
+    @overload
+    def as_proxy(name: str, obj: Any, replace: bool = False) -> None: ...
+
+
+def as_proxy(name: str, obj: Any = NotImplemented, replace: bool = False):
+    """
+    Export an object as a named proxy.
+    Usage:
+
+        @as_proxy("foo")
+        class Foo():
+            def __
+    """
+    # This uses NotImplemented instead of None or Ellipsis/NotGiven because
+    # those two are be legitimately proxied.
+
+    def _proxy(obj):
+        "Export @obj as a proxy."
+        if not replace and name in _CProxy and _CProxy[name] is not obj:
+            raise ValueError("Proxy: " + repr(name) + " already exists")
+        _CProxy[name] = obj
+        _RProxy[id(obj)] = name
+        #       if isinstance(obj,type) and not hasattr(obj,"__getstate__"):
+        #           obj.__getstate__ = _getstate
+        return obj
+
+    if obj is NotImplemented:
+        return _proxy
+    else:
+        _proxy(obj)
+        return obj
+
+
+def drop_proxy(p):
+    """
+    After sending a proxy we keep it in memory in case the remote returns
+    it, or an expression with it.
+
+    If that won't happen, the remote needs to tell us to clean it up.
+    """
+    if not isinstance(p, str):
+        p = _RProxy[id(p)]
+    if p == "" or p[0] == "_":
+        raise ValueError("Can't delete a system proxy")
+    r = _CProxy.pop(p)
+    del _RProxy[id(r)]
+
+
+class NoProxyError(ValueError):
+    "Error for nonexistent proxy values"
+
+    # pylint:disable=unnecessary-pass
+
+
+class Proxy:
+    """
+    A proxy object, i.e. a placeholder for things that cannot pass
+    through a codec. No object data are included.
+    """
+
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.name!r})"
+
+    def ref(self):
+        """Dereferences the proxy"""
+        return name2obj(self.name)
+
+
+class DProxy(Proxy):
+    """
+    A proxy object with data. This is implemented as a type that's proxied,
+    thus the object can be reconstituted by the receiver (if it knows the
+    proxy class) or at least rebuilt when the original sender gets the
+    proxy structure back (if it doesn't). The object's state is included.
+    """
+
+    def __init__(self, name, a, k):
+        super().__init__(name)
+        self.a = a
+        self.k = k
+
+    def __getitem__(self, i):
+        if i in self.k:
+            return self.k[i]
+        else:
+            try:
+                return self.a[i]
+            except TypeError:
+                from moat.lib.micro import log  # noqa: PLC0415
+
+                log("*ERR %r", self.k)
+                raise KeyError(i) from None
+
+    def __eq__(self, other):
+        if not isinstance(other, DProxy):
+            return NotImplemented
+
+        # Split into several lines so we can selectively set breakpoints
+        # when debugging
+        if self.name != other.name:
+            return False
+        if self.a != other.a or self.k != other.k:
+            return False
+        return True
+
+    def __repr__(self):
+        return (
+            f"{self.__class__.__name__}({self.name!r},"
+            + ",".join(repr(x) for x in (self.a, self.k))
+            + ")"
+        )
+
+    def ref(self):
+        """Dereferences the proxy"""
+        return name2obj(self.name)

moat_lib_proxy-0.1.0/src/moat_lib_proxy.egg-info/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: moat-lib-proxy
+Version: 0.1.0
+Summary: Proxy helpers for serializing and deserializing objects
+Maintainer-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AnyIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.0
+Requires-Dist: moat-util~=0.6
+Requires-Dist: moat-lib-micro~=0.1.0
+Dynamic: license-file
+
+# Proxy helpers
+
+% start main
+% start synopsis
+
+This module provides proxy helpers for serializing and deserializing objects
+across process boundaries or network connections. It includes:
+
+- Transparent proxy objects that can be serialized and reconstructed
+- Object registration and name mapping for proxied objects
+- Data-carrying proxies (DProxy) for including object state
+- Integration with CBOR, msgpack, and other serialization formats
+
+% end synopsis
+
+## Usage
+
+### Basic proxy registration
+
+```python
+from moat.lib.proxy import name2obj, obj2name, Proxy
+
+# Register a class for proxying
+class MyService:
+    def do_something(self):
+        return "result"
+
+# Register the class with a name
+name2obj("myapp.MyService", MyService)
+
+# Get the proxy name for an object
+service = MyService()
+proxy_name = obj2name(service)  # Returns "myapp.MyService"
+```
+
+### Using proxies
+
+```python
+from moat.lib.proxy import as_proxy, get_proxy
+
+# Create a proxy reference to an object
+obj = MyService()
+proxy = as_proxy(obj)  # Returns a Proxy object
+
+# Later, retrieve the original object
+original = get_proxy(proxy)  # Returns the MyService instance
+```
+
+### Data-carrying proxies (DProxy)
+
+```python
+from moat.lib.proxy import DProxy
+
+class MyData(DProxy):
+    """A proxy that includes object state"""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __reduce__(self):
+        # Define how to serialize the object
+        return (self.__class__, (self.value,))
+
+# The object can be serialized with its state
+data = MyData(42)
+# When serialized and deserialized, the value is preserved
+```
+
+### Working with serialization
+
+```python
+from moat.lib.proxy import wrap_obj, unwrap_obj
+
+# Serialize an object for transmission
+class MyObject:
+    pass
+
+name2obj("myapp.MyObject", MyObject)
+obj = MyObject()
+
+# Wrap for serialization
+wrapped = wrap_obj(obj)  # Creates a serializable representation
+
+# Later, unwrap to reconstruct
+reconstructed = unwrap_obj(wrapped)  # Returns a MyObject instance
+```
+
+## Integration with Serialization Formats
+
+This module integrates with MoaT's serialization libraries:
+
+- **CBOR**: `moat.lib.codec.cbor`
+- **Msgpack**: `moat.lib.codec.msgpack`
+- **YAML**: Supports proxy references in configuration files
+
+% end main

moat_lib_proxy-0.1.0/src/moat_lib_proxy.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE.txt
+Makefile
+README.md
+pyproject.toml
+debian/.gitignore
+debian/changelog
+debian/control
+debian/rules
+src/moat/lib/proxy/__init__.py
+src/moat/lib/proxy/_impl.py
+src/moat/lib/proxy/_proxy.py
+src/moat_lib_proxy.egg-info/PKG-INFO
+src/moat_lib_proxy.egg-info/SOURCES.txt
+src/moat_lib_proxy.egg-info/dependency_links.txt
+src/moat_lib_proxy.egg-info/requires.txt
+src/moat_lib_proxy.egg-info/top_level.txt

moat_lib_proxy-0.1.0/src/moat_lib_proxy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moat_lib_proxy-0.1.0/src/moat_lib_proxy.egg-info/requires.txt

@@ -0,0 +1,3 @@
+anyio~=4.0
+moat-lib-micro~=0.1.0
+moat-util~=0.6

moat_lib_proxy-0.1.0/src/moat_lib_proxy.egg-info/top_level.txt

@@ -0,0 +1 @@
+moat