omlish 0.0.0.dev144__tar.gz → 0.0.0.dev145__tar.gz

{omlish-0.0.0.dev144/omlish.egg-info → omlish-0.0.0.dev145}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev144
+Version: 0.0.0.dev145
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev144'
-__revision__ = '4d901652b9972fb965683ca3ac965147536a9dd4'
+__version__ = '0.0.0.dev145'
+__revision__ = 'b64cfe7ef2ab0194ba9daa42bfb47a6d51f4f42a'
 
 
 #

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/collections/cache/impl.py

@@ -51,63 +51,56 @@ class CacheImpl(Cache[K, V]):
     https://google.github.io/guava/releases/16.0/api/docs/com/google/common/cache/CacheBuilder.html
     """
 
-    try:
-        if not ta.TYPE_CHECKING:
-            from ..._ext.cy.collections.cache import CacheLink as Link
-        else:
-            raise ImportError  # noqa
-
-    except ImportError:
-        class Link:
-            __slots__ = [
-                'seq',
-                'ins_prev',
-                'ins_next',
-                'lru_prev',
-                'lru_next',
-                'lfu_prev',
-                'lfu_next',
-                'key',
-                'value',
-                'weight',
-                'written',
-                'accessed',
-                'hits',
-                'unlinked',
-            ]
-
-            seq: int
-            ins_prev: 'CacheImpl.Link'
-            ins_next: 'CacheImpl.Link'
-            lru_prev: 'CacheImpl.Link'
-            lru_next: 'CacheImpl.Link'
-            lfu_prev: 'CacheImpl.Link'
-            lfu_next: 'CacheImpl.Link'
-            key: ta.Any | weakref.ref
-            value: ta.Any | weakref.ref
-            weight: float
-            written: float
-            accessed: float
-            hits: int
-            unlinked: bool
-
-            def __repr__(self) -> str:
-                return (
-                    f'Link@{self.seq!s}('
-                    f'ins_prev={("@" + str(self.ins_prev.seq)) if self.ins_prev is not None else None}, '
-                    f'ins_next={("@" + str(self.ins_next.seq)) if self.ins_next is not None else None}, '
-                    f'lru_prev={("@" + str(self.lru_prev.seq)) if self.lru_prev is not None else None}, '
-                    f'lru_next={("@" + str(self.lru_next.seq)) if self.lru_next is not None else None}, '
-                    f'lfu_prev={("@" + str(self.lfu_prev.seq)) if self.lfu_prev is not None else None}, '
-                    f'lfu_next={("@" + str(self.lfu_next.seq)) if self.lfu_next is not None else None}, '
-                    f'key={self.key!r}, '
-                    f'value={self.value!r}, '
-                    f'weight={self.weight}, '
-                    f'written={self.written}, '
-                    f'accessed={self.accessed}, '
-                    f'hits={self.hits}, '
-                    f'unlinked={self.unlinked})'
-                )
+    class Link:
+        __slots__ = [
+            'seq',
+            'ins_prev',
+            'ins_next',
+            'lru_prev',
+            'lru_next',
+            'lfu_prev',
+            'lfu_next',
+            'key',
+            'value',
+            'weight',
+            'written',
+            'accessed',
+            'hits',
+            'unlinked',
+        ]
+
+        seq: int
+        ins_prev: 'CacheImpl.Link'
+        ins_next: 'CacheImpl.Link'
+        lru_prev: 'CacheImpl.Link'
+        lru_next: 'CacheImpl.Link'
+        lfu_prev: 'CacheImpl.Link'
+        lfu_next: 'CacheImpl.Link'
+        key: ta.Any | weakref.ref
+        value: ta.Any | weakref.ref
+        weight: float
+        written: float
+        accessed: float
+        hits: int
+        unlinked: bool
+
+        def __repr__(self) -> str:
+            return (
+                f'Link@{self.seq!s}('
+                f'ins_prev={("@" + str(self.ins_prev.seq)) if self.ins_prev is not None else None}, '
+                f'ins_next={("@" + str(self.ins_next.seq)) if self.ins_next is not None else None}, '
+                f'lru_prev={("@" + str(self.lru_prev.seq)) if self.lru_prev is not None else None}, '
+                f'lru_next={("@" + str(self.lru_next.seq)) if self.lru_next is not None else None}, '
+                f'lfu_prev={("@" + str(self.lfu_prev.seq)) if self.lfu_prev is not None else None}, '
+                f'lfu_next={("@" + str(self.lfu_next.seq)) if self.lfu_next is not None else None}, '
+                f'key={self.key!r}, '
+                f'value={self.value!r}, '
+                f'weight={self.weight}, '
+                f'written={self.written}, '
+                f'accessed={self.accessed}, '
+                f'hits={self.hits}, '
+                f'unlinked={self.unlinked})'
+            )
 
     _cache: ta.MutableMapping[ta.Any, Link]
 

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/defs.py

@@ -199,7 +199,7 @@ def abstract_method(cls_dct, *names):
 
 @lang.cls_dct_fn()
 def abstract_property(cls_dct, *names):
-    return not_implemented(cls_dct, *names, wrapper=abc.abstractmethod)
+    return not_implemented(cls_dct, *names, wrapper=lambda o: property(abc.abstractmethod(o)))
 
 
 @lang.cls_dct_fn()

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/lite/fdio/corohttp.py

@@ -11,10 +11,10 @@ from ..http.handlers import HttpHandler
 from ..io import IncrementalWriteBuffer
 from ..io import ReadableListBuffer
 from ..socket import SocketAddress
-from .handlers import SocketFdIoHandler
+from .handlers import SocketFdioHandler
 
 
-class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
+class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
     def __init__(
             self,
             addr: SocketAddress,

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/lite/fdio/handlers.py

@@ -7,7 +7,7 @@ from ..check import check_not_none
 from ..socket import SocketAddress
 
 
-class FdIoHandler(abc.ABC):
+class FdioHandler(abc.ABC):
     @abc.abstractmethod
     def fd(self) -> int:
         raise NotImplementedError
@@ -43,7 +43,7 @@ class FdIoHandler(abc.ABC):
         pass
 
 
-class SocketFdIoHandler(FdIoHandler, abc.ABC):
+class SocketFdioHandler(FdioHandler, abc.ABC):
     def __init__(
             self,
             addr: SocketAddress,

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/lite/fdio/kqueue.py

@@ -4,13 +4,13 @@ import select
 import sys
 import typing as ta
 
-from .pollers import FdIoPoller
+from .pollers import FdioPoller
 
 
-KqueueFdIoPoller: ta.Optional[ta.Type[FdIoPoller]]
+KqueueFdioPoller: ta.Optional[ta.Type[FdioPoller]]
 if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
 
-    class _KqueueFdIoPoller(FdIoPoller):
+    class _KqueueFdioPoller(FdioPoller):
         DEFAULT_MAX_EVENTS = 1000
 
         def __init__(
@@ -98,14 +98,14 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
 
         #
 
-        def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+        def poll(self, timeout: ta.Optional[float]) -> FdioPoller.PollResult:
             kq = self._get_kqueue()
             try:
                 kes = kq.control(None, self._max_events, timeout)
 
             except OSError as exc:
                 if exc.errno == errno.EINTR:
-                    return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                    return FdioPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
                 else:
                     raise
 
@@ -117,8 +117,8 @@ if sys.platform == 'darwin' or sys.platform.startswith('freebsd'):
                 if ke.filter == select.KQ_FILTER_WRITE:
                     w.append(ke.ident)
 
-            return FdIoPoller.PollResult(r, w)
+            return FdioPoller.PollResult(r, w)
 
-    KqueueFdIoPoller = _KqueueFdIoPoller
+    KqueueFdioPoller = _KqueueFdioPoller
 else:
-    KqueueFdIoPoller = None
+    KqueueFdioPoller = None

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/lite/fdio/manager.py

@@ -1,27 +1,27 @@
 # ruff: noqa: UP006 UP007
 import typing as ta
 
-from .handlers import FdIoHandler
-from .pollers import FdIoPoller
+from .handlers import FdioHandler
+from .pollers import FdioPoller
 
 
-class FdIoManager:
+class FdioManager:
     def __init__(
             self,
-            poller: FdIoPoller,
+            poller: FdioPoller,
     ) -> None:
         super().__init__()
 
         self._poller = poller
 
-        self._handlers: ta.Dict[int, FdIoHandler] = {}  # Preserves insertion order
+        self._handlers: ta.Dict[int, FdioHandler] = {}  # Preserves insertion order
 
-    def register(self, h: FdIoHandler) -> None:
+    def register(self, h: FdioHandler) -> None:
         if (hid := id(h)) in self._handlers:
             raise KeyError(h)
         self._handlers[hid] = h
 
-    def unregister(self, h: FdIoHandler) -> None:
+    def unregister(self, h: FdioHandler) -> None:
         del self._handlers[id(h)]
 
     def poll(self, *, timeout: float = 1.) -> None:

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/lite/fdio/pollers.py

@@ -9,7 +9,7 @@ import typing as ta
 ##
 
 
-class FdIoPoller(abc.ABC):
+class FdioPoller(abc.ABC):
     def __init__(self) -> None:
         super().__init__()
 
@@ -120,8 +120,8 @@ class FdIoPoller(abc.ABC):
 ##
 
 
-class SelectFdIoPoller(FdIoPoller):
-    def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+class SelectFdioPoller(FdioPoller):
+    def poll(self, timeout: ta.Optional[float]) -> FdioPoller.PollResult:
         try:
             r, w, x = select.select(
                 self._readable,
@@ -132,22 +132,22 @@ class SelectFdIoPoller(FdIoPoller):
 
         except OSError as exc:
             if exc.errno == errno.EINTR:
-                return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                return FdioPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
             elif exc.errno == errno.EBADF:
-                return FdIoPoller.PollResult(msg='EBADF encountered in poll', exc=exc)
+                return FdioPoller.PollResult(msg='EBADF encountered in poll', exc=exc)
             else:
                 raise
 
-        return FdIoPoller.PollResult(r, w)
+        return FdioPoller.PollResult(r, w)
 
 
 ##
 
 
-PollFdIoPoller: ta.Optional[ta.Type[FdIoPoller]]
+PollFdioPoller: ta.Optional[ta.Type[FdioPoller]]
 if hasattr(select, 'poll'):
 
-    class _PollFdIoPoller(FdIoPoller):
+    class _PollFdioPoller(FdioPoller):
         def __init__(self) -> None:
             super().__init__()
 
@@ -180,14 +180,14 @@ if hasattr(select, 'poll'):
 
         #
 
-        def poll(self, timeout: ta.Optional[float]) -> FdIoPoller.PollResult:
+        def poll(self, timeout: ta.Optional[float]) -> FdioPoller.PollResult:
             polled: ta.List[ta.Tuple[int, int]]
             try:
                 polled = self._poller.poll(timeout * 1000 if timeout is not None else None)
 
             except OSError as exc:
                 if exc.errno == errno.EINTR:
-                    return FdIoPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
+                    return FdioPoller.PollResult(msg='EINTR encountered in poll', exc=exc)
                 else:
                     raise
 
@@ -205,8 +205,8 @@ if hasattr(select, 'poll'):
                     r.append(fd)
                 if mask & self._WRITE:
                     w.append(fd)
-            return FdIoPoller.PollResult(r, w, inv=inv)
+            return FdioPoller.PollResult(r, w, inv=inv)
 
-    PollFdIoPoller = _PollFdIoPoller
+    PollFdioPoller = _PollFdioPoller
 else:
-    PollFdIoPoller = None
+    PollFdioPoller = None

{omlish-0.0.0.dev144 → omlish-0.0.0.dev145}/omlish/lite/marshal.py

@@ -35,23 +35,24 @@ T = ta.TypeVar('T')
 @dc.dataclass(frozen=True)
 class ObjMarshalOptions:
     raw_bytes: bool = False
+    nonstrict_dataclasses: bool = False
 
 
 class ObjMarshaler(abc.ABC):
     @abc.abstractmethod
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         raise NotImplementedError
 
 
 class NopObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
 
@@ -59,29 +60,29 @@ class NopObjMarshaler(ObjMarshaler):
 class ProxyObjMarshaler(ObjMarshaler):
     m: ta.Optional[ObjMarshaler] = None
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return check_not_none(self.m).marshal(o, opts)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check_not_none(self.m).marshal(o, ctx)
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return check_not_none(self.m).unmarshal(o, opts)
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return check_not_none(self.m).unmarshal(o, ctx)
 
 
 @dc.dataclass(frozen=True)
 class CastObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return self.ty(o)
 
 
 class DynamicObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return marshal_obj(o)
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return ctx.manager.marshal_obj(o, opts=ctx.options)
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o
 
 
@@ -89,10 +90,10 @@ class DynamicObjMarshaler(ObjMarshaler):
 class Base64ObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return base64.b64encode(o).decode('ascii')
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return self.ty(base64.b64decode(o))
 
 
@@ -100,25 +101,25 @@ class Base64ObjMarshaler(ObjMarshaler):
 class BytesSwitchedObjMarshaler(ObjMarshaler):
     m: ObjMarshaler
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        if opts.raw_bytes:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if ctx.options.raw_bytes:
             return o
-        return self.m.marshal(o, opts)
+        return self.m.marshal(o, ctx)
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        if opts.raw_bytes:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        if ctx.options.raw_bytes:
             return o
-        return self.m.unmarshal(o, opts)
+        return self.m.unmarshal(o, ctx)
 
 
 @dc.dataclass(frozen=True)
 class EnumObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o.name
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return self.ty.__members__[o]  # type: ignore
 
 
@@ -126,15 +127,15 @@ class EnumObjMarshaler(ObjMarshaler):
 class OptionalObjMarshaler(ObjMarshaler):
     item: ObjMarshaler
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         if o is None:
             return None
-        return self.item.marshal(o, opts)
+        return self.item.marshal(o, ctx)
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         if o is None:
             return None
-        return self.item.unmarshal(o, opts)
+        return self.item.unmarshal(o, ctx)
 
 
 @dc.dataclass(frozen=True)
@@ -143,11 +144,11 @@ class MappingObjMarshaler(ObjMarshaler):
     km: ObjMarshaler
     vm: ObjMarshaler
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return {self.km.marshal(k, opts): self.vm.marshal(v, opts) for k, v in o.items()}
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return {self.km.marshal(k, ctx): self.vm.marshal(v, ctx) for k, v in o.items()}
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return self.ty((self.km.unmarshal(k, opts), self.vm.unmarshal(v, opts)) for k, v in o.items())
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty((self.km.unmarshal(k, ctx), self.vm.unmarshal(v, ctx)) for k, v in o.items())
 
 
 @dc.dataclass(frozen=True)
@@ -155,11 +156,11 @@ class IterableObjMarshaler(ObjMarshaler):
     ty: type
     item: ObjMarshaler
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return [self.item.marshal(e, opts) for e in o]
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return [self.item.marshal(e, ctx) for e in o]
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return self.ty(self.item.unmarshal(e, opts) for e in o)
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(self.item.unmarshal(e, ctx) for e in o)
 
 
 @dc.dataclass(frozen=True)
@@ -168,11 +169,18 @@ class DataclassObjMarshaler(ObjMarshaler):
     fs: ta.Mapping[str, ObjMarshaler]
     nonstrict: bool = False
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return {k: m.marshal(getattr(o, k), opts) for k, m in self.fs.items()}
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return {
+            k: m.marshal(getattr(o, k), ctx)
+            for k, m in self.fs.items()
+        }
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
-        return self.ty(**{k: self.fs[k].unmarshal(v, opts) for k, v in o.items() if not self.nonstrict or k in self.fs})
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
+        return self.ty(**{
+            k: self.fs[k].unmarshal(v, ctx)
+            for k, v in o.items()
+            if not (self.nonstrict or ctx.options.nonstrict_dataclasses) or k in self.fs
+        })
 
 
 @dc.dataclass(frozen=True)
@@ -192,50 +200,50 @@ class PolymorphicObjMarshaler(ObjMarshaler):
             {i.tag: i for i in impls},
         )
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         impl = self.impls_by_ty[type(o)]
-        return {impl.tag: impl.m.marshal(o, opts)}
+        return {impl.tag: impl.m.marshal(o, ctx)}
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         [(t, v)] = o.items()
         impl = self.impls_by_tag[t]
-        return impl.m.unmarshal(v, opts)
+        return impl.m.unmarshal(v, ctx)
 
 
 @dc.dataclass(frozen=True)
 class DatetimeObjMarshaler(ObjMarshaler):
     ty: type
 
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return o.isoformat()
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return self.ty.fromisoformat(o)  # type: ignore
 
 
 class DecimalObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return str(check_isinstance(o, decimal.Decimal))
 
-    def unmarshal(self, v: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return decimal.Decimal(check_isinstance(v, str))
 
 
 class FractionObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         fr = check_isinstance(o, fractions.Fraction)
         return [fr.numerator, fr.denominator]
 
-    def unmarshal(self, v: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, v: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         num, denom = check_isinstance(v, list)
         return fractions.Fraction(num, denom)
 
 
 class UuidObjMarshaler(ObjMarshaler):
-    def marshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def marshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return str(o)
 
-    def unmarshal(self, o: ta.Any, opts: ObjMarshalOptions) -> ta.Any:
+    def unmarshal(self, o: ta.Any, ctx: 'ObjMarshalContext') -> ta.Any:
         return uuid.UUID(o)
 
 
@@ -396,6 +404,12 @@ class ObjMarshalerManager:
 
     #
 
+    def _make_context(self, opts: ta.Optional[ObjMarshalOptions]) -> 'ObjMarshalContext':
+        return ObjMarshalContext(
+            options=opts or self._default_options,
+            manager=self,
+        )
+
     def marshal_obj(
             self,
             o: ta.Any,
@@ -403,7 +417,7 @@ class ObjMarshalerManager:
             opts: ta.Optional[ObjMarshalOptions] = None,
     ) -> ta.Any:
         m = self.get_obj_marshaler(ty if ty is not None else type(o))
-        return m.marshal(o, opts or self._default_options)
+        return m.marshal(o, self._make_context(opts))
 
     def unmarshal_obj(
             self,
@@ -412,7 +426,7 @@ class ObjMarshalerManager:
             opts: ta.Optional[ObjMarshalOptions] = None,
     ) -> T:
         m = self.get_obj_marshaler(ty)
-        return m.unmarshal(o, opts or self._default_options)
+        return m.unmarshal(o, self._make_context(opts))
 
     def roundtrip_obj(
             self,
@@ -427,6 +441,12 @@ class ObjMarshalerManager:
         return u
 
 
+@dc.dataclass(frozen=True)
+class ObjMarshalContext:
+    options: ObjMarshalOptions
+    manager: ObjMarshalerManager
+
+
 ##
 
 

omlish-0.0.0.dev145/omlish/manifests/__init__.py

@@ -0,0 +1,2 @@
+# @omlish-lite
+from .types import Manifest  # noqa