omlish 0.0.0.dev6__py3-none-any.whl → 0.0.0.dev7__py3-none-any.whl

omlish/lite/subprocesses.py

@@ -0,0 +1,112 @@
+# ruff: noqa: UP006 UP007
+import logging
+import os
+import shlex
+import subprocess
+import sys
+import typing as ta
+
+from .logs import log
+from .runtime import is_debugger_attached
+
+
+##
+
+
+_SUBPROCESS_SHELL_WRAP_EXECS = False
+
+
+def subprocess_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
+    return ('sh', '-c', ' '.join(map(shlex.quote, args)))
+
+
+def subprocess_maybe_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
+    if _SUBPROCESS_SHELL_WRAP_EXECS or is_debugger_attached():
+        return subprocess_shell_wrap_exec(*args)
+    else:
+        return args
+
+
+def _prepare_subprocess_invocation(
+        *args: str,
+        env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+        extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
+        quiet: bool = False,
+        shell: bool = False,
+        **kwargs: ta.Any,
+) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
+    log.debug(args)
+    if extra_env:
+        log.debug(extra_env)
+
+    if extra_env:
+        env = {**(env if env is not None else os.environ), **extra_env}
+
+    if quiet and 'stderr' not in kwargs:
+        if not log.isEnabledFor(logging.DEBUG):
+            kwargs['stderr'] = subprocess.DEVNULL
+
+    if not shell:
+        args = subprocess_maybe_shell_wrap_exec(*args)
+
+    return args, dict(
+        env=env,
+        shell=shell,
+        **kwargs,
+    )
+
+
+def subprocess_check_call(*args: str, stdout=sys.stderr, **kwargs: ta.Any) -> None:
+    args, kwargs = _prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
+    return subprocess.check_call(args, **kwargs)  # type: ignore
+
+
+def subprocess_check_output(*args: str, **kwargs: ta.Any) -> bytes:
+    args, kwargs = _prepare_subprocess_invocation(*args, **kwargs)
+    return subprocess.check_output(args, **kwargs)
+
+
+def subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
+    return subprocess_check_output(*args, **kwargs).decode().strip()
+
+
+##
+
+
+DEFAULT_SUBPROCESS_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
+    FileNotFoundError,
+    subprocess.CalledProcessError,
+)
+
+
+def subprocess_try_call(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> bool:
+    try:
+        subprocess_check_call(*args, **kwargs)
+    except try_exceptions as e:  # noqa
+        if log.isEnabledFor(logging.DEBUG):
+            log.exception('command failed')
+        return False
+    else:
+        return True
+
+
+def subprocess_try_output(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> ta.Optional[bytes]:
+    try:
+        return subprocess_check_output(*args, **kwargs)
+    except try_exceptions as e:  # noqa
+        if log.isEnabledFor(logging.DEBUG):
+            log.exception('command failed')
+        return None
+
+
+def subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
+    out = subprocess_try_output(*args, **kwargs)
+    return out.decode().strip() if out is not None else None

omlish/logs/configs.py

@@ -3,6 +3,7 @@ import logging
 import typing as ta
 
 from .filters import TidFilter
+from .formatters import JsonLogFormatter
 from .formatters import StandardLogFormatter
 
 
@@ -47,10 +48,22 @@ def build_log_format(parts: ta.Iterable[tuple[str, str]]) -> str:
     return ' '.join(v for k, v in parts)
 
 
-def configure_standard_logging(level: ta.Any = None) -> logging.Handler:
+def configure_standard_logging(
+        level: ta.Any = None,
+        *,
+        json: bool = False,
+) -> logging.Handler:
     handler = logging.StreamHandler()
-    handler.setFormatter(StandardLogFormatter(build_log_format(STANDARD_LOG_FORMAT_PARTS)))
+
+    formatter: logging.Formatter
+    if json:
+        formatter = JsonLogFormatter()
+    else:
+        formatter = StandardLogFormatter(build_log_format(STANDARD_LOG_FORMAT_PARTS))
+    handler.setFormatter(formatter)
+
     handler.addFilter(TidFilter())
+
     logging.root.addHandler(handler)
 
     if level is not None:

omlish/logs/formatters.py

@@ -6,7 +6,7 @@ import logging
 import typing as ta
 
 from .. import term
-from ..serde import json
+from ..formats import json
 
 
 class StandardLogFormatter(logging.Formatter):
@@ -67,5 +67,10 @@ class JsonLogFormatter(logging.Formatter):
     }
 
     def format(self, record: logging.LogRecord) -> str:
-        dct = {k: v for k, o in self.KEYS.items() for v in [getattr(record, k)] if not (o and v is None)}
+        dct = {
+            k: v
+            for k, o in self.KEYS.items()
+            for v in [getattr(record, k)]
+            if not (o and v is None)
+        }
         return json.dumps_compact(dct)

omlish/marshal/__init__.py

@@ -5,6 +5,15 @@ from .base import (  # noqa
     MarshalerFactory,
     UnmarshalerFactory,
 
+    MarshalerFactoryMatchClass,
+    UnmarshalerFactoryMatchClass,
+
+    TypeMapMarshalerFactory,
+    TypeMapUnmarshalerFactory,
+
+    TypeCacheMarshalerFactory,
+    TypeCacheUnmarshalerFactory,
+
     FuncMarshaler,
     FuncUnmarshaler,
 
@@ -18,6 +27,17 @@ from .base import (  # noqa
     SetType,
 )
 
+from .exceptions import (  # noqa
+    ForbiddenTypeError,
+    MarshalError,
+    UnhandledTypeError,
+)
+
+from .forbidden import (  # noqa
+    ForbiddenTypeMarshalerFactory,
+    ForbiddenTypeUnmarshalerFactory,
+)
+
 from .naming import (  # noqa
     Naming,
     translate_name,
@@ -54,3 +74,11 @@ from .standard import (  # noqa
 from .values import (  # noqa
     Value,
 )
+
+
+##
+
+
+from ..lang.imports import _trigger_conditional_imports  # noqa
+
+_trigger_conditional_imports(__package__)

omlish/marshal/any.py

@@ -1,12 +1,12 @@
 import typing as ta
 
+from .. import reflect as rfl
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .factories import TypeMapFactory
 from .values import Value
 
 
@@ -21,5 +21,5 @@ class AnyMarshalerUnmarshaler(Marshaler, Unmarshaler):
 
 ANY_MARSHALER_UNMARSHALER = AnyMarshalerUnmarshaler()
 
-ANY_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({ta.Any: ANY_MARSHALER_UNMARSHALER})  # type: ignore
-ANY_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({ta.Any: ANY_MARSHALER_UNMARSHALER})  # type: ignore
+ANY_MARSHALER_FACTORY = TypeMapMarshalerFactory({rfl.ANY: ANY_MARSHALER_UNMARSHALER})
+ANY_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({rfl.ANY: ANY_MARSHALER_UNMARSHALER})

omlish/marshal/base.py

@@ -2,6 +2,7 @@
 TODO:
  - mappings
  - redacted
+ - strongly typed MarshalerFactory base class?
  - strongly typed Composite/Cached Marshaler/Unmarshaler factories - footgun
  - streaming? Start/EndObject, etc..
 
@@ -80,10 +81,12 @@ import typing as ta
 from .. import check
 from .. import collections as col
 from .. import lang
+from .. import matchfns as mfs
 from .. import reflect as rfl
 from .exceptions import UnhandledTypeError
-from .factories import Factory
 from .factories import RecursiveTypeFactory
+from .factories import TypeCacheFactory
+from .factories import TypeMapFactory
 from .registries import Registry
 from .registries import RegistryItem
 from .utils import _Proxy
@@ -105,8 +108,19 @@ class Unmarshaler(lang.Abstract):
         raise NotImplementedError
 
 
-MarshalerFactory = Factory[Marshaler, 'MarshalContext', rfl.Type]
-UnmarshalerFactory = Factory[Unmarshaler, 'UnmarshalContext', rfl.Type]
+MarshalerFactory: ta.TypeAlias = mfs.MatchFn[['MarshalContext', rfl.Type], Marshaler]
+UnmarshalerFactory: ta.TypeAlias = mfs.MatchFn[['UnmarshalContext', rfl.Type], Unmarshaler]
+
+MarshalerFactoryMatchClass: ta.TypeAlias = mfs.MatchFnClass[['MarshalContext', rfl.Type], Marshaler]
+UnmarshalerFactoryMatchClass: ta.TypeAlias = mfs.MatchFnClass[['UnmarshalContext', rfl.Type], Unmarshaler]
+
+#
+
+TypeMapMarshalerFactory: ta.TypeAlias = TypeMapFactory['MarshalContext', Marshaler]
+TypeMapUnmarshalerFactory: ta.TypeAlias = TypeMapFactory['UnmarshalContext', Unmarshaler]
+
+TypeCacheMarshalerFactory: ta.TypeAlias = TypeCacheFactory['MarshalContext', Marshaler]
+TypeCacheUnmarshalerFactory: ta.TypeAlias = TypeCacheFactory['UnmarshalContext', Unmarshaler]
 
 
 ##
@@ -150,9 +164,10 @@ class MarshalContext(BaseContext, lang.Final):
 
     def make(self, o: ta.Any) -> Marshaler:
         rty = rfl.type_(o)
-        if (m := check.not_none(self.factory)(self, rty)) is not None:  # noqa
-            return m
-        raise UnhandledTypeError(rty)
+        try:
+            return check.not_none(self.factory)(self, rty)  # type: ignore
+        except mfs.MatchGuardError:
+            raise UnhandledTypeError(rty)  # noqa
 
 
 @dc.dataclass(frozen=True)
@@ -161,9 +176,10 @@ class UnmarshalContext(BaseContext, lang.Final):
 
     def make(self, o: ta.Any) -> Unmarshaler:
         rty = rfl.type_(o)
-        if (m := check.not_none(self.factory)(self, rty)) is not None:  # noqa
-            return m
-        raise UnhandledTypeError(rty)
+        try:
+            return check.not_none(self.factory)(self, rty)  # type: ignore
+        except mfs.MatchGuardError:
+            raise UnhandledTypeError(rty)  # noqa
 
 
 ##
@@ -174,7 +190,7 @@ class _ProxyMarshaler(_Proxy[Marshaler], Marshaler):
         return self._obj.marshal(ctx, o)
 
 
-class RecursiveMarshalerFactory(RecursiveTypeFactory[Marshaler, MarshalContext], lang.Final):
+class RecursiveMarshalerFactory(RecursiveTypeFactory[MarshalContext, Marshaler], lang.Final):
     def __init__(self, f: MarshalerFactory) -> None:
         super().__init__(f, _ProxyMarshaler._new)  # noqa
 
@@ -184,7 +200,7 @@ class _ProxyUnmarshaler(_Proxy[Unmarshaler], Unmarshaler):
         return self._obj.unmarshal(ctx, v)
 
 
-class RecursiveUnmarshalerFactory(RecursiveTypeFactory[Unmarshaler, UnmarshalContext], lang.Final):
+class RecursiveUnmarshalerFactory(RecursiveTypeFactory[UnmarshalContext, Unmarshaler], lang.Final):
     def __init__(self, f: UnmarshalerFactory) -> None:
         super().__init__(f, _ProxyUnmarshaler._new)  # noqa
 

omlish/marshal/base64.py

@@ -1,25 +1,40 @@
 import base64
+import typing as ta
 
 from .. import check
+from .. import dataclasses as dc
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .factories import TypeMapFactory
 from .values import Value
 
 
-class Base64MarshalerUnmarshaler(Marshaler, Unmarshaler):
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True)
+class Base64MarshalerUnmarshaler(Marshaler, Unmarshaler, ta.Generic[T]):
+    ty: type[T]
+
     def marshal(self, ctx: MarshalContext, o: bytes) -> str:
         return base64.b64encode(o).decode()
 
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> bytes:
-        return base64.b64decode(check.isinstance(v, str).encode())
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> T:
+        return self.ty(base64.b64decode(check.isinstance(v, str).encode()))  # type: ignore
+
 
+BASE64_TYPES = (
+    bytes,
+    bytearray,
+)
 
-BASE64_MARSHALER_UNMARSHALER = Base64MarshalerUnmarshaler()
+BASE64_MARSHALER_FACTORY = TypeMapMarshalerFactory({
+    ty: Base64MarshalerUnmarshaler(ty) for ty in BASE64_TYPES
+})
 
-BASE64_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({bytes: BASE64_MARSHALER_UNMARSHALER})
-BASE64_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({bytes: BASE64_MARSHALER_UNMARSHALER})
+BASE64_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({
+    ty: Base64MarshalerUnmarshaler(ty) for ty in BASE64_TYPES
+})

omlish/marshal/dataclasses.py

@@ -79,37 +79,43 @@ def _make_field_obj(ctx, ty, obj, fac):
 
 
 class DataclassMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, type) and dc.is_dataclass(rty):
-            dc_md = get_dataclass_metadata(rty)
-            fields = [
-                (fi, _make_field_obj(ctx, fi.type, fi.metadata.marshaler, fi.metadata.marshaler_factory))
-                for fi in get_field_infos(rty, ctx.options)
-            ]
-            return ObjectMarshaler(
-                fields,
-                unknown_field=dc_md.unknown_field,
-            )
-        return None
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and dc.is_dataclass(rty)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        ty = check.isinstance(rty, type)
+        check.state(dc.is_dataclass(ty))
+        dc_md = get_dataclass_metadata(ty)
+        fields = [
+            (fi, _make_field_obj(ctx, fi.type, fi.metadata.marshaler, fi.metadata.marshaler_factory))
+            for fi in get_field_infos(ty, ctx.options)
+        ]
+        return ObjectMarshaler(
+            fields,
+            unknown_field=dc_md.unknown_field,
+        )
 
 
 ##
 
 
 class DataclassUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, type) and dc.is_dataclass(rty):
-            dc_md = get_dataclass_metadata(rty)
-            d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
-            for fi in get_field_infos(rty, ctx.options):
-                tup = (fi, _make_field_obj(ctx, fi.type, fi.metadata.unmarshaler, fi.metadata.unmarshaler_factory))
-                for un in fi.unmarshal_names:
-                    if un in d:
-                        raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
-                    d[un] = tup
-            return ObjectUnmarshaler(
-                rty,
-                d,
-                unknown_field=dc_md.unknown_field,
-            )
-        return None
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and dc.is_dataclass(rty)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        ty = check.isinstance(rty, type)
+        check.state(dc.is_dataclass(ty))
+        dc_md = get_dataclass_metadata(ty)
+        d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
+        for fi in get_field_infos(ty, ctx.options):
+            tup = (fi, _make_field_obj(ctx, fi.type, fi.metadata.unmarshaler, fi.metadata.unmarshaler_factory))
+            for un in fi.unmarshal_names:
+                if un in d:
+                    raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
+                d[un] = tup
+        return ObjectUnmarshaler(
+            ty,
+            d,
+            unknown_field=dc_md.unknown_field,
+        )

omlish/marshal/datetimes.py

@@ -3,16 +3,28 @@ import datetime
 import typing as ta
 
 from .. import check
+from .. import datetimes as dts
 from .base import MarshalContext
 from .base import Marshaler
-from .base import MarshalerFactory
+from .base import TypeMapMarshalerFactory
+from .base import TypeMapUnmarshalerFactory
 from .base import UnmarshalContext
 from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .factories import TypeMapFactory
 from .values import Value
 
 
+DatetimeLikeT = ta.TypeVar('DatetimeLikeT', bound=datetime.datetime | datetime.date | datetime.time)
+
+_DATETIME_LIKES = (
+    datetime.datetime,
+    datetime.date,
+    datetime.time,
+)
+
+
+##
+
+
 DATE_FORMATS: ta.Sequence[str] = [
     '%Y-%m-%d',
 ]
@@ -43,48 +55,92 @@ DATETIME_FORMATS: ta.Sequence[str] = [
 ]
 
 
+##
+
+
 @dc.dataclass(frozen=True)
-class DatetimeMarshaler(Marshaler):
+class DatetimeMarshaler(Marshaler, ta.Generic[DatetimeLikeT]):
+    cls: type[DatetimeLikeT]
     fmt: str
 
-    def marshal(self, ctx: MarshalContext, o: datetime.datetime) -> Value:
+    def marshal(self, ctx: MarshalContext, o: DatetimeLikeT) -> Value:
         return o.strftime(self.fmt)
 
 
+_ZERO_DATE = datetime.datetime.now().strptime('', '').date()  # noqa
+_ZERO_TIME = datetime.time(0)
+
+
 @dc.dataclass(frozen=True)
-class DatetimeUnmarshaler(Unmarshaler):
+class DatetimeUnmarshaler(Unmarshaler, ta.Generic[DatetimeLikeT]):
+    cls: type[DatetimeLikeT]
     fmts: ta.Sequence[str]
     try_iso: bool = False
 
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> datetime.datetime:
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> DatetimeLikeT:
         v = check.isinstance(v, str)
 
         if self.try_iso:
             try:
-                return datetime.datetime.fromisoformat(v)
+                return self.cls.fromisoformat(v)  # type: ignore
             except ValueError:
                 pass
 
         for fmt in self.fmts:
             try:
-                return datetime.datetime.strptime(v, fmt)  # FIXME: timezone  # noqa
+                dt = datetime.datetime.strptime(v, fmt)  # FIXME: timezone  # noqa
             except ValueError:
                 pass
+            else:
+                if self.cls is datetime.datetime:
+                    return dt  # type: ignore
+                elif self.cls is datetime.date:
+                    if dt.time() != _ZERO_TIME:
+                        raise ValueError(dt)
+                    return dt.date()  # type: ignore
+                elif self.cls is datetime.time:
+                    if dt.date() != _ZERO_DATE:
+                        raise ValueError(dt)
+                    return dt.time()  # type: ignore
+                else:
+                    raise TypeError(self.cls)
 
         raise ValueError(v)
 
 
-DATETIME_MARSHALER = DatetimeMarshaler(DATETIME_FORMATS[0])
-DATETIME_UNMARSHALER = DatetimeUnmarshaler(DATETIME_FORMATS, try_iso=True)
-
-DATETIME_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({datetime.datetime: DATETIME_MARSHALER})
-DATETIME_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({datetime.datetime: DATETIME_UNMARSHALER})
+##
 
 
-class IsoDatetimeMarshalerUnmarshaler(Marshaler, Unmarshaler):
+class IsoDatetimeMarshalerUnmarshaler(Marshaler, Unmarshaler, ta.Generic[DatetimeLikeT]):
+    cls: type[DatetimeLikeT]
 
-    def marshal(self, ctx: MarshalContext, o: datetime.datetime) -> Value:
+    def marshal(self, ctx: MarshalContext, o: DatetimeLikeT) -> Value:
         return o.isoformat()
 
-    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> datetime.datetime:
-        return datetime.datetime.fromisoformat(v)  # type: ignore
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> DatetimeLikeT:
+        return self.cls.fromisoformat(v)  # type: ignore
+
+
+##
+
+
+class TimedeltaMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: datetime.timedelta) -> Value:
+        return str(o)
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return dts.parse_timedelta(check.isinstance(v, str))
+
+
+##
+
+
+DATETIME_MARSHALER_FACTORY = TypeMapMarshalerFactory({
+    **{cls: DatetimeMarshaler(cls, DATETIME_FORMATS[0]) for cls in _DATETIME_LIKES},
+    datetime.timedelta: TimedeltaMarshalerUnmarshaler(),
+})
+
+DATETIME_UNMARSHALER_FACTORY = TypeMapUnmarshalerFactory({
+    **{cls: DatetimeUnmarshaler(cls, DATETIME_FORMATS, try_iso=True) for cls in _DATETIME_LIKES},
+    datetime.timedelta: TimedeltaMarshalerUnmarshaler(),
+})

omlish/marshal/enums.py

@@ -22,10 +22,13 @@ class EnumMarshaler(Marshaler):
 
 
 class EnumMarshalerFactory(MarshalerFactory):
-    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler | None:
-        if isinstance(rty, type) and issubclass(rty, enum.Enum):
-            return EnumMarshaler(rty)
-        return None
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and issubclass(rty, enum.Enum)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        ty = check.isinstance(rty, type)
+        check.state(issubclass(ty, enum.Enum))
+        return EnumMarshaler(ty)
 
 
 @dc.dataclass(frozen=True)
@@ -37,7 +40,10 @@ class EnumUnmarshaler(Unmarshaler):
 
 
 class EnumUnmarshalerFactory(UnmarshalerFactory):
-    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler | None:
-        if isinstance(rty, type) and issubclass(rty, enum.Enum):
-            return EnumUnmarshaler(rty)
-        return None
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and issubclass(rty, enum.Enum)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        ty = check.isinstance(rty, type)
+        check.state(issubclass(ty, enum.Enum))
+        return EnumUnmarshaler(ty)

omlish/marshal/exceptions.py

@@ -1,7 +1,17 @@
 from .. import reflect as rfl
 
 
-class UnhandledTypeError(Exception):
+class MarshalError(Exception):
+    pass
+
+
+class UnhandledTypeError(MarshalError):
+    @property
+    def rty(self) -> rfl.Type:
+        return self.args[0]
+
+
+class ForbiddenTypeError(MarshalError):
     @property
     def rty(self) -> rfl.Type:
         return self.args[0]