omlish 0.0.0.dev226__py3-none-any.whl → 0.0.0.dev228__py3-none-any.whl

omlish/marshal/objects/metadata.py

@@ -0,0 +1,124 @@
+import typing as ta
+
+from ... import cached
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from ..naming import Naming
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FieldOptions:
+    omit_if: ta.Callable[[ta.Any], bool] | None = None
+
+    default: lang.Maybe[ta.Any] = dc.xfield(default=lang.empty(), check_type=lang.Maybe)
+
+    embed: bool = False
+
+    no_marshal: bool = False
+    no_unmarshal: bool = False
+
+
+DEFAULT_FIELD_OPTIONS = FieldOptions()
+FIELD_OPTIONS_KWARGS: frozenset[str] = frozenset(dc.fields_dict(FieldOptions).keys())
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FieldMetadata:
+    name: str | None = None
+    alts: ta.Iterable[str] | None = None
+
+    options: FieldOptions = DEFAULT_FIELD_OPTIONS
+
+    marshaler: Marshaler | None = dc.xfield(None, check_type=(Marshaler, None))
+    marshaler_factory: MarshalerFactory | None = None
+
+    unmarshaler: Unmarshaler | None = dc.xfield(None, check_type=(Unmarshaler, None))
+    unmarshaler_factory: UnmarshalerFactory | None = None
+
+    def update(self, **kwargs: ta.Any) -> 'FieldMetadata':
+        okw = {k: v for k, v in kwargs.items() if k in FIELD_OPTIONS_KWARGS}
+        mkw = {k: v for k, v in kwargs.items() if k not in FIELD_OPTIONS_KWARGS}
+        return dc.replace(
+            self,
+            **(dict(options=dc.replace(self.options, **okw)) if okw else {}),
+            **mkw,
+        )
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ObjectMetadata:
+    field_naming: Naming | None = None
+
+    unknown_field: str | None = None
+    source_field: str | None = None
+
+    @cached.property
+    def specials(self) -> 'ObjectSpecials':
+        return ObjectSpecials(
+            unknown=self.unknown_field,
+            source=self.source_field,
+        )
+
+    field_defaults: FieldMetadata = FieldMetadata()
+
+    ignore_unknown: bool = False
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ObjectSpecials:
+    unknown: str | None = None
+    source: str | None = None
+
+    @cached.property
+    def set(self) -> frozenset[str]:
+        return frozenset(v for v in dc.asdict(self).values() if v is not None)
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FieldInfo:
+    name: str
+    type: ta.Any
+
+    marshal_name: str | None
+    unmarshal_names: ta.Sequence[str]
+
+    metadata: FieldMetadata = FieldMetadata()
+
+    options: FieldOptions = FieldOptions()
+
+
+@dc.dataclass(frozen=True)
+class FieldInfos:
+    lst: ta.Sequence[FieldInfo]
+
+    def __iter__(self) -> ta.Iterator[FieldInfo]:
+        return iter(self.lst)
+
+    def __len__(self) -> int:
+        return len(self.lst)
+
+    @cached.property
+    @dc.init
+    def by_name(self) -> ta.Mapping[str, FieldInfo]:
+        return col.make_map(((fi.name, fi) for fi in self), strict=True)
+
+    @cached.property
+    @dc.init
+    def by_marshal_name(self) -> ta.Mapping[str, FieldInfo]:
+        return col.make_map(((fi.marshal_name, fi) for fi in self if fi.marshal_name is not None), strict=True)
+
+    @cached.property
+    @dc.init
+    def by_unmarshal_name(self) -> ta.Mapping[str, FieldInfo]:
+        return col.make_map(((n, fi) for fi in self for n in fi.unmarshal_names), strict=True)

omlish/marshal/{namedtuples.py → objects/namedtuples.py}

@@ -1,22 +1,22 @@
 import inspect
 import typing as ta
 
-from .. import check
-from .. import collections as col
-from .. import lang
-from .. import reflect as rfl
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactory
-from .base import Option
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .objects import FieldInfo
-from .objects import FieldInfos
-from .objects import FieldMetadata
-from .objects import ObjectMarshaler
-from .objects import ObjectUnmarshaler
+from ... import check
+from ... import collections as col
+from ... import lang
+from ... import reflect as rfl
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..base import Option
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from .marshal import ObjectMarshaler
+from .metadata import FieldInfo
+from .metadata import FieldInfos
+from .metadata import FieldMetadata
+from .unmarshal import ObjectUnmarshaler
 
 
 ##

omlish/marshal/objects/unmarshal.py

@@ -0,0 +1,141 @@
+import collections.abc
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ... import reflect as rfl
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from ..values import Value
+from .metadata import FieldInfo
+from .metadata import FieldInfos
+from .metadata import ObjectSpecials
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ObjectUnmarshaler(Unmarshaler):
+    factory: ta.Callable
+    fields_by_unmarshal_name: ta.Mapping[str, tuple[FieldInfo, Unmarshaler]]
+
+    _: dc.KW_ONLY
+
+    specials: ObjectSpecials = ObjectSpecials()
+
+    defaults: ta.Mapping[str, ta.Any] | None = None
+
+    embeds: ta.Mapping[str, type] | None = None
+    embeds_by_unmarshal_name: ta.Mapping[str, tuple[str, str]] | None = None
+
+    ignore_unknown: bool = False
+
+    @classmethod
+    def make(
+            cls,
+            ctx: UnmarshalContext,
+            factory: ta.Callable,
+            fis: FieldInfos,
+            **kwargs: ta.Any,
+    ) -> Unmarshaler:
+        fields_by_unmarshal_name = {
+            n: (fi, ctx.make(fi.type))
+            for fi in fis
+            for n in fi.unmarshal_names
+        }
+
+        defaults = {
+            fi.name: fi.options.default.must()
+            for fi in fis
+            if fi.options.default.present
+        }
+
+        return cls(
+            factory,
+            fields_by_unmarshal_name,
+            defaults=defaults,
+            **kwargs,
+        )
+
+    #
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        ma = check.isinstance(v, collections.abc.Mapping)
+
+        u: ta.Any
+        kw: dict[str, ta.Any] = {}
+        ukf: dict[str, ta.Any] | None = None
+
+        ekws: dict[str, dict[str, ta.Any]] = {en: {} for en in self.embeds or ()}
+
+        if self.specials.source is not None:
+            kw[self.specials.source] = v
+
+        if self.specials.unknown is not None:
+            kw[self.specials.unknown] = ukf = {}
+
+        for k, mv in ma.items():
+            ks = check.isinstance(k, str)
+
+            try:
+                fi, u = self.fields_by_unmarshal_name[ks]
+
+            except KeyError:
+                if ukf is not None:
+                    ukf[ks] = mv  # FIXME: unmarshal?
+                    continue
+
+                if self.ignore_unknown:
+                    continue
+
+                raise
+
+            if self.embeds_by_unmarshal_name and (en := self.embeds_by_unmarshal_name.get(ks)):
+                tkw, tk = ekws[en[0]], en[1]
+            else:
+                tkw, tk = kw, fi.name
+
+            if tk in tkw:
+                raise KeyError(f'Duplicate keys for field {tk!r}: {ks!r}')
+
+            tkw[tk] = u.unmarshal(ctx, mv)
+
+        for em, ecls in self.embeds.items() if self.embeds else ():
+            ekw = ekws[em]
+            ev = ecls(**ekw)
+            kw[em] = ev
+
+        if self.defaults:
+            for dk, dv in self.defaults.items():
+                kw.setdefault(dk, dv)
+
+        return self.factory(**kw)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SimpleObjectUnmarshalerFactory(UnmarshalerFactory):
+    dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
+
+    _: dc.KW_ONLY
+
+    specials: ObjectSpecials = ObjectSpecials()
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and rty in self.dct
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        ty = check.isinstance(rty, type)
+
+        fis = FieldInfos(self.dct[ty])
+
+        return ObjectUnmarshaler.make(
+            ctx,
+            ty,
+            fis,
+            specials=self.specials,
+        )

omlish/marshal/polymorphism/__init__.py

@@ -0,0 +1,7 @@
+"""
+TODO:
+ - auto-gen from __subclasses__ if abstract
+  - cfg: unless prefixed with _ or abstract
+  - iff Sealed
+ - auto-name
+"""

omlish/marshal/polymorphism/marshal.py

@@ -0,0 +1,66 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ... import reflect as rfl
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..values import Value
+from .metadata import FieldTypeTagging
+from .metadata import Impls
+from .metadata import Polymorphism
+from .metadata import TypeTagging
+from .metadata import WrapperTypeTagging
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class WrapperPolymorphismMarshaler(Marshaler):
+    m: ta.Mapping[type, tuple[str, Marshaler]]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        tag, m = self.m[type(o)]
+        return {tag: m.marshal(ctx, o)}
+
+
+@dc.dataclass(frozen=True)
+class FieldPolymorphismMarshaler(Marshaler):
+    m: ta.Mapping[type, tuple[str, Marshaler]]
+    tf: str
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any | None) -> Value:
+        tag, m = self.m[type(o)]
+        return {self.tf: tag, **m.marshal(ctx, o)}  # type: ignore
+
+
+def make_polymorphism_marshaler(
+        impls: Impls,
+        tt: TypeTagging,
+        ctx: MarshalContext,
+) -> Marshaler:
+    m = {
+        i.ty: (i.tag, ctx.make(i.ty))
+        for i in impls
+    }
+    if isinstance(tt, WrapperTypeTagging):
+        return WrapperPolymorphismMarshaler(m)
+    elif isinstance(tt, FieldTypeTagging):
+        return FieldPolymorphismMarshaler(m, tt.field)
+    else:
+        raise TypeError(tt)
+
+
+@dc.dataclass(frozen=True)
+class PolymorphismMarshalerFactory(MarshalerFactory):
+    p: Polymorphism
+    tt: TypeTagging = WrapperTypeTagging()
+
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return rty is self.p.ty
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        check.is_(rty, self.p.ty)
+        return make_polymorphism_marshaler(self.p.impls, self.tt, ctx)

omlish/marshal/polymorphism/metadata.py

@@ -0,0 +1,140 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from ..naming import Naming
+from ..naming import translate_name
+from ..registries import RegistryItem
+
+
+##
+
+
+class TypeTagging(RegistryItem, lang.Abstract, lang.Sealed):
+    pass
+
+
+class WrapperTypeTagging(TypeTagging, lang.Final):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class FieldTypeTagging(TypeTagging, lang.Final):
+    field: str
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Impl:
+    ty: type
+    tag: str
+    alts: ta.AbstractSet[str] = frozenset()
+
+
+class Impls(ta.Sequence[Impl]):
+    def __init__(
+            self,
+            lst: ta.Iterable[Impl],
+    ) -> None:
+        super().__init__()
+        self._lst = list(lst)
+
+        by_ty: dict[type, Impl] = {}
+        by_tag: dict[str, Impl] = {}
+        for i in self._lst:
+            if i.ty in by_ty:
+                raise TypeError(i.ty)
+            if i.tag in by_tag:
+                raise NameError(i.tag)
+            for a in i.alts:
+                if a in by_tag:
+                    raise NameError(a)
+            by_ty[i.ty] = i
+            by_tag[i.tag] = i
+            for a in i.alts:
+                by_tag[a] = i
+        self._by_ty = by_ty
+        self._by_tag = by_tag
+
+    def __iter__(self) -> ta.Iterator[Impl]:
+        return iter(self._lst)
+
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    @ta.overload
+    def __getitem__(self, index: int) -> Impl: ...
+
+    @ta.overload
+    def __getitem__(self, index: slice) -> ta.Sequence[Impl]: ...
+
+    def __getitem__(self, index):
+        return self._lst[index]
+
+    @property
+    def by_ty(self) -> ta.Mapping[type, Impl]:
+        return self._by_ty
+
+    @property
+    def by_tag(self) -> ta.Mapping[str, Impl]:
+        return self._by_tag
+
+
+class Polymorphism:
+    def __init__(
+            self,
+            ty: type,
+            impls: ta.Iterable[Impl],
+    ) -> None:
+        super().__init__()
+        self._ty = ty
+        self._impls = Impls(impls)
+
+        for i in self._impls:
+            if not issubclass(i.ty, ty):
+                raise TypeError(i.ty, ty)
+
+    @property
+    def ty(self) -> type:
+        return self._ty
+
+    @property
+    def impls(self) -> Impls:
+        return self._impls
+
+
+def polymorphism_from_subclasses(
+        ty: type,
+        *,
+        naming: Naming | None = None,
+        strip_suffix: bool = False,
+) -> Polymorphism:
+    dct: dict[str, Impl] = {}
+
+    seen: set[type] = set()
+    todo: list[type] = [ty]
+    while todo:
+        cur = todo.pop()
+        seen.add(cur)
+
+        todo.extend(nxt for nxt in cur.__subclasses__() if nxt not in seen)
+
+        if lang.is_abstract_class(cur):
+            continue
+
+        name = cur.__name__
+        if strip_suffix:
+            name = lang.strip_suffix(name, ty.__name__)
+        if naming is not None:
+            name = translate_name(name, naming)
+        if name in dct:
+            raise KeyError(f'Duplicate name: {name}')
+
+        dct[name] = Impl(
+            cur,
+            name,
+        )
+
+    return Polymorphism(ty, dct.values())

omlish/marshal/{unions.py → polymorphism/unions.py}

@@ -1,23 +1,23 @@
 import typing as ta
 
-from .. import cached
-from .. import check
-from .. import dataclasses as dc
-from .. import lang
-from .. import reflect as rfl
-from ..funcs import match as mfs
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactory
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .polymorphism import Impls
-from .polymorphism import TypeTagging
-from .polymorphism import WrapperTypeTagging
-from .polymorphism import make_polymorphism_marshaler
-from .polymorphism import make_polymorphism_unmarshaler
-from .values import Value
+from ... import cached
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from ..values import Value
+from .marshal import make_polymorphism_marshaler
+from .metadata import Impls
+from .metadata import TypeTagging
+from .metadata import WrapperTypeTagging
+from .unmarshal import make_polymorphism_unmarshaler
 
 
 ##

omlish/marshal/polymorphism/unmarshal.py

@@ -0,0 +1,73 @@
+import collections.abc
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ... import reflect as rfl
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from ..values import Value
+from .metadata import FieldTypeTagging
+from .metadata import Impls
+from .metadata import Polymorphism
+from .metadata import TypeTagging
+from .metadata import WrapperTypeTagging
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class WrapperPolymorphismUnmarshaler(Unmarshaler):
+    m: ta.Mapping[str, Unmarshaler]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        ma = check.isinstance(v, collections.abc.Mapping)
+        [(tag, iv)] = ma.items()
+        u = self.m[tag]
+        return u.unmarshal(ctx, iv)
+
+
+@dc.dataclass(frozen=True)
+class FieldPolymorphismUnmarshaler(Unmarshaler):
+    m: ta.Mapping[str, Unmarshaler]
+    tf: str
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
+        ma = dict(check.isinstance(v, collections.abc.Mapping))
+        tag = ma.pop(self.tf)
+        u = self.m[tag]
+        return u.unmarshal(ctx, ma)
+
+
+def make_polymorphism_unmarshaler(
+        impls: Impls,
+        tt: TypeTagging,
+        ctx: UnmarshalContext,
+) -> Unmarshaler:
+    m = {
+        t: u
+        for i in impls
+        for u in [ctx.make(i.ty)]
+        for t in [i.tag, *i.alts]
+    }
+    if isinstance(tt, WrapperTypeTagging):
+        return WrapperPolymorphismUnmarshaler(m)
+    elif isinstance(tt, FieldTypeTagging):
+        return FieldPolymorphismUnmarshaler(m, tt.field)
+    else:
+        raise TypeError(tt)
+
+
+@dc.dataclass(frozen=True)
+class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
+    p: Polymorphism
+    tt: TypeTagging = WrapperTypeTagging()
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return rty is self.p.ty
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        check.is_(rty, self.p.ty)
+        return make_polymorphism_unmarshaler(self.p.impls, self.tt, ctx)

omlish/marshal/{any.py → singular/any.py}

@@ -1,13 +1,13 @@
 import typing as ta
 
-from .. import reflect as rfl
-from .base import MarshalContext
-from .base import Marshaler
-from .base import TypeMapMarshalerFactory
-from .base import TypeMapUnmarshalerFactory
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .values import Value
+from ... import reflect as rfl
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import TypeMapMarshalerFactory
+from ..base import TypeMapUnmarshalerFactory
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..values import Value
 
 
 class AnyMarshalerUnmarshaler(Marshaler, Unmarshaler):

omlish/marshal/{base64.py → singular/base64.py}

@@ -5,15 +5,15 @@ FIXME:
 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 TypeMapMarshalerFactory
-from .base import TypeMapUnmarshalerFactory
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .values import Value
+from ... import check
+from ... import dataclasses as dc
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import TypeMapMarshalerFactory
+from ..base import TypeMapUnmarshalerFactory
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..values import Value
 
 
 T = ta.TypeVar('T')