omlish 0.0.0.dev40__py3-none-any.whl → 0.0.0.dev42__py3-none-any.whl

omlish/marshal/dataclasses.py

@@ -13,8 +13,11 @@ from .base import Unmarshaler
 from .base import UnmarshalerFactory
 from .naming import Naming
 from .naming import translate_name
+from .objects import DEFAULT_FIELD_OPTIONS
+from .objects import FIELD_OPTIONS_KWARGS
 from .objects import FieldInfo
 from .objects import FieldMetadata
+from .objects import FieldOptions
 from .objects import ObjectMarshaler
 from .objects import ObjectMetadata
 from .objects import ObjectUnmarshaler
@@ -43,6 +46,11 @@ def get_field_infos(
         for k, v in dc.asdict(dc_md.field_defaults).items()
         if v is not None
     }
+    fo_defaults = {
+        k: v
+        for k, v in fi_defaults.pop('options').items()
+        if v != getattr(DEFAULT_FIELD_OPTIONS, k)
+    }
 
     type_hints = ta.get_type_hints(ty)
 
@@ -53,8 +61,10 @@ def get_field_infos(
         else:
             um_name = field.name
 
-        kw = dict(fi_defaults)
-        kw.update(
+        fi_kw = dict(fi_defaults)
+        fo_kw = dict(fo_defaults)
+
+        fi_kw.update(
             name=field.name,
             type=type_hints[field.name],
             metadata=FieldMetadata(),
@@ -63,20 +73,35 @@ def get_field_infos(
             unmarshal_names=[um_name],
         )
 
+        has_set_name = False
         if (fmd := field.metadata.get(FieldMetadata)) is not None:
-            kw.update(
+            fi_kw.update(
                 metadata=fmd,
-                omit_if=fmd.omit_if,
-                default=fmd.default,
             )
 
+            for fo_k in FIELD_OPTIONS_KWARGS:
+                if (fo_v := getattr(fmd.options, fo_k)) != getattr(DEFAULT_FIELD_OPTIONS, fo_k):
+                    fo_kw[fo_k] = fo_v
+
             if fmd.name is not None:
-                kw.update(
+                has_set_name = True
+                fi_kw.update(
                     marshal_name=fmd.name,
                     unmarshal_names=col.unique([fmd.name, *(fmd.alts or ())]),
                 )
 
-        ret.append(FieldInfo(**kw))
+        if fo_kw.get('embed') and not has_set_name:
+            fi_kw.update(
+                marshal_name=fi_kw['marshal_name'] + '_',
+                unmarshal_names=[n + '_' for n in fi_kw['unmarshal_names']],
+            )
+
+        ret.append(
+            FieldInfo(
+                options=FieldOptions(**fo_kw),
+                **fi_kw,
+            ),
+        )
 
     return ret
 
@@ -123,23 +148,51 @@ class DataclassUnmarshalerFactory(UnmarshalerFactory):
     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]] = {}
         defaults: dict[str, ta.Any] = {}
+        embeds: dict[str, type] = {}
+        embeds_by_unmarshal_name: dict[str, tuple[str, str]] = {}
+
+        def add_field(fi: FieldInfo, *, prefixes: ta.Iterable[str] = ('',)) -> ta.Iterable[str]:
+            ret: list[str] = []
+
+            if fi.options.embed:
+                e_ty = check.isinstance(fi.type, type)
+                check.state(dc.is_dataclass(e_ty))
+                # e_dc_md = get_dataclass_metadata(e_ty)
+
+                embeds[fi.name] = e_ty
+                for e_fi in get_field_infos(e_ty, ctx.options):
+                    e_ns = add_field(e_fi, prefixes=[p + ep for p in prefixes for ep in fi.unmarshal_names])
+                    embeds_by_unmarshal_name.update({e_f: (fi.name, e_fi.name) for e_f in e_ns})
+                    ret.extend(e_ns)
+
+            else:
+                tup = (fi, _make_field_obj(ctx, fi.type, fi.metadata.unmarshaler, fi.metadata.unmarshaler_factory))
+
+                for pfx in prefixes:
+                    for un in fi.unmarshal_names:
+                        un = pfx + un
+                        if un in d:
+                            raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
+                        d[un] = tup
+                        ret.append(un)
+
+                if fi.options.default.present:
+                    defaults[fi.name] = fi.options.default.must()
+
+            return ret
+
         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
-            if fi.default.present:
-                defaults[fi.name] = fi.default.must()
+            add_field(fi)
 
         return ObjectUnmarshaler(
             ty,
             d,
             unknown_field=dc_md.unknown_field,
             defaults=defaults,
+            embeds=embeds,
+            embeds_by_unmarshal_name=embeds_by_unmarshal_name,
         )

omlish/marshal/helpers.py

@@ -12,10 +12,7 @@ def update_field_metadata(**kwargs: ta.Any) -> dc.field_modifier:
     @dc.field_modifier
     def inner(f: dc.Field) -> dc.Field:
         return dc.update_field_metadata(f, {
-            FieldMetadata: dc.replace(
-                f.metadata.get(FieldMetadata, FieldMetadata()),
-                **kwargs,
-            ),
+            FieldMetadata: f.metadata.get(FieldMetadata, FieldMetadata()).update(**kwargs),
         })
     return inner
 
@@ -26,10 +23,7 @@ def update_fields_metadata(
 ) -> ta.Callable[[type[T]], type[T]]:
     def inner(a: str, f: dc.Field) -> dc.Field:
         return dc.update_field_metadata(f, {
-            FieldMetadata: dc.replace(
-                f.metadata.get(FieldMetadata, FieldMetadata()),
-                **kwargs,
-            ),
+            FieldMetadata: f.metadata.get(FieldMetadata, FieldMetadata()).update(**kwargs),
         })
 
     return dc.update_fields(inner, fields)

omlish/marshal/objects.py

@@ -1,11 +1,9 @@
 """
 TODO:
  - cfg naming
- - adapters for dataclasses / namedtuples / user objects (as confitured)
+ - adapters for dataclasses / namedtuples / user objects (as configured)
  - mro-merge ObjectMetadata
  - key ordering override - like slice, -1 means last
- - dedupe omit_if/default fields on Metadata/Info - FieldOptions prob
-  - impl merge, update helpers:update_fields_metadata
 """
 import collections.abc
 import typing as ta
@@ -27,13 +25,25 @@ from .values import Value
 ##
 
 
+@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
+
+
+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
 
-    omit_if: ta.Callable[[ta.Any], bool] | None = None
-    default: lang.Maybe[ta.Any] = dc.xfield(lang.empty(), check_type=lang.Maybe)
+    options: FieldOptions = DEFAULT_FIELD_OPTIONS
 
     marshaler: Marshaler | None = None
     marshaler_factory: MarshalerFactory | None = None
@@ -41,6 +51,15 @@ class FieldMetadata:
     unmarshaler: Unmarshaler | None = 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:
@@ -64,8 +83,7 @@ class FieldInfo:
 
     metadata: FieldMetadata = FieldMetadata()
 
-    omit_if: ta.Callable[[ta.Any], bool] | None = None
-    default: lang.Maybe[ta.Any] = lang.empty()
+    options: FieldOptions = FieldOptions()
 
 
 ##
@@ -80,12 +98,21 @@ class ObjectMarshaler(Marshaler):
     unknown_field: str | None = None
 
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        ret = {}
+        ret: dict[str, ta.Any] = {}
         for fi, m in self.fields:
             v = getattr(o, fi.name)
-            if fi.omit_if is not None and fi.omit_if(v):
+
+            if fi.options.omit_if is not None and fi.options.omit_if(v):
                 continue
-            ret[fi.marshal_name] = m.marshal(ctx, v)
+
+            mv = m.marshal(ctx, v)
+
+            if fi.options.embed:
+                for ek, ev in check.isinstance(mv, collections.abc.Mapping).items():
+                    ret[fi.marshal_name + check.non_empty_str(ek)] = ev  # type: ignore
+
+            else:
+                ret[fi.marshal_name] = mv
 
         if self.unknown_field is not None:
             if (ukf := getattr(o, self.unknown_field)):
@@ -135,8 +162,12 @@ class ObjectUnmarshaler(Unmarshaler):
     _: dc.KW_ONLY
 
     unknown_field: str | None = None
+
     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
+
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
         ma = check.isinstance(v, collections.abc.Mapping)
 
@@ -144,6 +175,8 @@ class ObjectUnmarshaler(Unmarshaler):
         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.unknown_field is not None:
             kw[self.unknown_field] = ukf = {}
 
@@ -159,10 +192,20 @@ class ObjectUnmarshaler(Unmarshaler):
                     continue
                 raise
 
-            if fi.name in kw:
-                raise KeyError(f'Duplicate keys for field {fi.name!r}: {ks!r}')
+            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)
 
-            kw[fi.name] = 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():
@@ -194,9 +237,9 @@ class SimpleObjectUnmarshalerFactory(UnmarshalerFactory):
         }
 
         defaults = {
-            fi.name: fi.default.must()
+            fi.name: fi.options.default.must()
             for fi in flds
-            if fi.default.present
+            if fi.options.default.present
         }
 
         return ObjectUnmarshaler(

omlish/specs/openapi/__init__.py

@@ -0,0 +1,5 @@
+from . import marshal  # noqa
+
+from .openapi import (  # noqa
+    Openapi,
+)

omlish/specs/openapi/marshal.py

@@ -0,0 +1,63 @@
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from ... import marshal as msh
+from ... import matchfns as mfs
+from ... import reflect as rfl
+from .openapi import Reference
+
+
+#
+
+
+def _reference_union_arg(rty: rfl.Type) -> rfl.Type | None:
+    if isinstance(rty, rfl.Union) and len(rty.args) == 2 and Reference in rty.args:
+        return check.single(a for a in rty.args if a is not Reference)
+    else:
+        return None
+
+
+@dc.dataclass(frozen=True)
+class _ReferenceUnionMarshaler(msh.Marshaler):
+    m: msh.Marshaler
+    r: msh.Marshaler
+
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        if isinstance(o, Reference):
+            return self.r.marshal(ctx, o)
+        else:
+            return self.m.marshal(ctx, o)
+
+
+class _ReferenceUnionMarshalerFactory(msh.MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: _reference_union_arg(rty) is not None)
+    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
+        return _ReferenceUnionMarshaler(ctx.make(check.not_none(_reference_union_arg(rty))), ctx.make(Reference))
+
+
+@dc.dataclass(frozen=True)
+class _ReferenceUnionUnmarshaler(msh.Unmarshaler):
+    u: msh.Unmarshaler
+    r: msh.Unmarshaler
+
+    def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
+        if not isinstance(v, ta.Mapping):
+            raise TypeError(v)
+        elif '$ref' in v:
+            return self.r.unmarshal(ctx, v)
+        else:
+            return self.u.unmarshal(ctx, v)  # noqa
+
+
+class _ReferenceUnionUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: _reference_union_arg(rty) is not None)
+    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
+        return _ReferenceUnionUnmarshaler(ctx.make(check.not_none(_reference_union_arg(rty))), ctx.make(Reference))
+
+
+@lang.static_init
+def _install_standard_marshalling() -> None:
+    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [_ReferenceUnionMarshalerFactory()]
+    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [_ReferenceUnionUnmarshalerFactory()]