omlish 0.0.0.dev1__py3-none-any.whl

omlish/marshal/dataclasses.py

@@ -0,0 +1,115 @@
+import typing as ta
+
+from .. import check
+from .. import collections as col
+from .. import dataclasses as dc
+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 .naming import Naming
+from .naming import translate_name
+from .objects import FieldInfo
+from .objects import FieldMetadata
+from .objects import ObjectMarshaler
+from .objects import ObjectMetadata
+from .objects import ObjectUnmarshaler
+
+
+##
+
+
+def get_dataclass_metadata(ty: type) -> ObjectMetadata:
+    return check.optional_single(
+        e
+        for e in dc.get_merged_metadata(ty).get(dc.UserMetadata, [])
+        if isinstance(e, ObjectMetadata)
+    ) or ObjectMetadata()
+
+
+def get_field_infos(ty: type, opts: col.TypeMap[Option] = col.TypeMap()) -> ta.Sequence[FieldInfo]:
+    dc_md = get_dataclass_metadata(ty)
+    dc_naming = dc_md.field_naming or opts.get(Naming)
+
+    type_hints = ta.get_type_hints(ty)
+
+    ret: list[FieldInfo] = []
+    for field in dc.fields(ty):
+        if (f_naming := field.metadata.get(Naming, dc_naming)) is not None:
+            um_name = translate_name(field.name, f_naming)
+        else:
+            um_name = field.name
+
+        kw = dict(
+            name=field.name,
+            type=type_hints[field.name],
+            metadata=FieldMetadata(),
+
+            marshal_name=um_name,
+            unmarshal_names=[um_name],
+        )
+
+        if (fmd := field.metadata.get(FieldMetadata)) is not None:
+            kw.update(metadata=fmd)
+
+            if fmd.name is not None:
+                kw.update(
+                    marshal_name=fmd.name,
+                    unmarshal_names=col.unique([fmd.name, *(fmd.alts or ())]),
+                )
+
+        ret.append(FieldInfo(**kw))
+
+    return ret
+
+
+def _make_field_obj(ctx, ty, obj, fac):
+    if obj is not None:
+        return obj
+    if fac is not None:
+        return fac(ctx, ty)
+    return ctx.make(ty)
+
+
+##
+
+
+class DataclassMarshalerFactory(MarshalerFactory):
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+        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
+
+
+##
+
+
+class DataclassUnmarshalerFactory(UnmarshalerFactory):
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+        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

omlish/marshal/datetimes.py

@@ -0,0 +1,90 @@
+import dataclasses as dc
+import datetime
+import typing as ta
+
+from .. import check
+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 .factories import TypeMapFactory
+from .values import Value
+
+
+DATE_FORMATS: ta.Sequence[str] = [
+    '%Y-%m-%d',
+]
+
+TIME_FORMATS: ta.Sequence[str] = [
+    ' '.join([tp, *tz])
+    for tp in [
+        '%H:%M:%S.%f',
+        '%H:%M:%S',
+        '%H:%M',
+    ]
+    for tz in ta.cast(list[list[str]], [
+        [],
+        ['%z'],
+        ['%Z'],
+        ['%z', '%Z'],
+        ['%Z', '%z'],
+    ])
+]
+
+SEPS: ta.Sequence[str] = ['T', ' ']
+
+DATETIME_FORMATS: ta.Sequence[str] = [
+    s.join([df, tf])
+    for s in SEPS
+    for df in DATE_FORMATS
+    for tf in TIME_FORMATS
+]
+
+
+@dc.dataclass(frozen=True)
+class DatetimeMarshaler(Marshaler):
+    fmt: str
+
+    def marshal(self, ctx: MarshalContext, o: datetime.datetime) -> Value:
+        return o.strftime(self.fmt)
+
+
+@dc.dataclass(frozen=True)
+class DatetimeUnmarshaler(Unmarshaler):
+    fmts: ta.Sequence[str]
+    try_iso: bool = False
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> datetime.datetime:
+        v = check.isinstance(v, str)
+
+        if self.try_iso:
+            try:
+                return datetime.datetime.fromisoformat(v)
+            except ValueError:
+                pass
+
+        for fmt in self.fmts:
+            try:
+                return datetime.datetime.strptime(v, fmt)
+            except ValueError:
+                pass
+
+        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):
+
+    def marshal(self, ctx: MarshalContext, o: datetime.datetime) -> Value:
+        return o.isoformat()
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> datetime.datetime:
+        return datetime.datetime.fromisoformat(v)  # type: ignore

omlish/marshal/enums.py

@@ -0,0 +1,43 @@
+import dataclasses as dc
+import enum
+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 .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .values import Value
+
+
+@dc.dataclass(frozen=True)
+class EnumMarshaler(Marshaler):
+    ty: type[enum.Enum]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        return o.name
+
+
+class EnumMarshalerFactory(MarshalerFactory):
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+        if isinstance(rty, type) and issubclass(rty, enum.Enum):
+            return EnumMarshaler(rty)
+        return None
+
+
+@dc.dataclass(frozen=True)
+class EnumUnmarshaler(Unmarshaler):
+    ty: type[enum.Enum]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return self.ty[check.isinstance(v, str)]
+
+
+class EnumUnmarshalerFactory(UnmarshalerFactory):
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+        if isinstance(rty, type) and issubclass(rty, enum.Enum):
+            return EnumUnmarshaler(rty)
+        return None

omlish/marshal/exceptions.py

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

omlish/marshal/factories.py

@@ -0,0 +1,129 @@
+import abc
+import dataclasses as dc
+import enum
+import threading
+import typing as ta
+
+from .. import reflect as rfl
+
+
+R = ta.TypeVar('R')
+C = ta.TypeVar('C')
+A = ta.TypeVar('A')
+
+
+##
+
+
+class Factory(abc.ABC, ta.Generic[R, C, A]):
+    @abc.abstractmethod
+    def __call__(self, ctx: C, arg: A) -> ta.Optional[R]:
+        raise NotImplementedError
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FuncFactory(ta.Generic[R, C, A]):
+    fn: ta.Callable[[C, A], ta.Optional[R]]
+
+    def __call__(self, ctx: C, arg: A) -> ta.Optional[R]:
+        return self.fn(ctx, arg)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class TypeMapFactory(Factory[R, C, rfl.Type]):
+    m: ta.Mapping[rfl.Type, R] = dc.field(default_factory=dict)
+
+    def __call__(self, ctx: C, rty: rfl.Type) -> ta.Optional[R]:
+        return self.m.get(rty)
+
+
+##
+
+
+class TypeCacheFactory(Factory[R, C, rfl.Type]):
+    def __init__(self, f: Factory[R, C, rfl.Type]) -> None:
+        super().__init__()
+        self._f = f
+        self._dct: dict[rfl.Type, ta.Optional[R]] = {}
+        self._mtx = threading.RLock()
+
+    def __call__(self, ctx: C, rty: rfl.Type) -> ta.Optional[R]:
+        try:
+            return self._dct[rty]
+        except KeyError:
+            pass
+        with self._mtx:
+            try:
+                return self._dct[rty]
+            except KeyError:
+                ret = self._dct[rty] = self._f(ctx, rty)
+                return ret
+
+
+##
+
+
+class RecursiveTypeFactory(Factory[R, C, rfl.Type]):
+    def __init__(
+            self,
+            f: Factory[R, C, rfl.Type],
+            prx: ta.Callable[[], tuple[ta.Optional[R], ta.Callable[[ta.Optional[R]], None]]],
+    ) -> None:
+        super().__init__()
+        self._f = f
+        self._prx = prx
+        self._dct: dict[rfl.Type, ta.Optional[R]] = {}
+
+    def __call__(self, ctx: C, rty: rfl.Type) -> ta.Optional[R]:
+        try:
+            return self._dct[rty]
+        except KeyError:
+            pass
+        p, sp = self._prx()
+        self._dct[rty] = p
+        try:
+            r = self._f(ctx, rty)
+            sp(r)
+            return r
+        finally:
+            del self._dct[rty]
+
+
+##
+
+
+class CompositeFactory(Factory[R, C, A]):
+    class Strategy(enum.Enum):
+        FIRST = enum.auto()
+        ONE = enum.auto()
+
+    def __init__(self, *fs: Factory[R, C, A], strategy: Strategy = Strategy.FIRST) -> None:
+        super().__init__()
+        self._fs = fs
+        self._st = strategy
+
+    def __call__(self, ctx: C, arg: A) -> ta.Optional[R]:
+        w: list[R] = []
+        for c in self._fs:
+            if (r := c(ctx, arg)) is None:
+                continue
+            if self._st is CompositeFactory.Strategy.FIRST:
+                return r
+            w.append(r)
+
+        if not w:
+            return None
+
+        if self._st is CompositeFactory.Strategy.ONE:
+            if len(w) == 1:
+                return w[0]
+
+            raise TypeError(f'multiple implementations: {arg} {w}')
+
+        raise TypeError(f'unknown composite strategy: {self._st}')

omlish/marshal/global_.py

@@ -0,0 +1,33 @@
+from .registries import Registry
+from .standard import new_standard_marshaler_factory
+from .base import MarshalContext
+from .base import UnmarshalContext
+from .standard import new_standard_unmarshaler_factory
+
+
+##
+
+
+GLOBAL_REGISTRY = Registry()
+
+
+##
+
+
+GLOBAL_MARSHALER_FACTORY = new_standard_marshaler_factory()
+
+
+def marshal(obj, ty=None, **kwargs):
+    mc = MarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_MARSHALER_FACTORY, **kwargs)
+    return mc.make(ty if ty is not None else type(obj)).marshal(mc, obj)
+
+
+##
+
+
+GLOBAL_UNMARSHALER_FACTORY = new_standard_unmarshaler_factory()
+
+
+def unmarshal(v, ty, **kwargs):
+    uc = UnmarshalContext(GLOBAL_REGISTRY, factory=GLOBAL_UNMARSHALER_FACTORY, **kwargs)
+    return uc.make(ty).unmarshal(uc, v)

omlish/marshal/iterables.py

@@ -0,0 +1,57 @@
+import collections.abc
+import dataclasses as dc
+import functools
+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 .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .values import Value
+
+
+@dc.dataclass(frozen=True)
+class IterableMarshaler(Marshaler):
+    e: Marshaler
+
+    def marshal(self, ctx: MarshalContext, o: ta.Iterable) -> Value:
+        return list(map(functools.partial(self.e.marshal, ctx), o))
+
+
+class IterableMarshalerFactory(MarshalerFactory):
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable):
+            if (e := ctx.make(check.single(rty.args))) is None:
+                return None  # type: ignore
+            return IterableMarshaler(e)
+        if isinstance(rty, type) and issubclass(rty, collections.abc.Iterable):
+            if (e := ctx.make(ta.Any)) is None:
+                return None  # type: ignore
+            return IterableMarshaler(e)
+        return None
+
+
+@dc.dataclass(frozen=True)
+class IterableUnmarshaler(Unmarshaler):
+    ctor: ta.Callable[[ta.Iterable[ta.Any]], ta.Iterable]
+    e: Unmarshaler
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Iterable:
+        return self.ctor(map(functools.partial(self.e.unmarshal, ctx), check.isinstance(v, collections.abc.Iterable)))
+
+
+class IterableUnmarshalerFactory(UnmarshalerFactory):
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Iterable):
+            if (e := ctx.make(check.single(rty.args))) is None:
+                return None  # type: ignore
+            return IterableUnmarshaler(rty.cls, e)  # noqa
+        if isinstance(rty, type) and issubclass(rty, collections.abc.Iterable):
+            if (e := ctx.make(ta.Any)) is None:
+                return None  # type: ignore
+            return IterableUnmarshaler(rty, e)  # noqa
+        return None

omlish/marshal/mappings.py

@@ -0,0 +1,66 @@
+import collections.abc
+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 .base import UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .values import Value
+
+
+@dc.dataclass(frozen=True)
+class MappingMarshaler(Marshaler):
+    ke: Marshaler
+    ve: Marshaler
+
+    def marshal(self, ctx: MarshalContext, o: ta.Mapping) -> Value:
+        return {
+            self.ke.marshal(ctx, uk): self.ve.marshal(ctx, uv)
+            for uk, uv in check.isinstance(o, collections.abc.Mapping).items()
+        }
+
+
+class MappingMarshalerFactory(MarshalerFactory):
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping):
+            kt, vt = rty.args
+            if (ke := ctx.make(kt)) is None or (ve := ctx.make(vt)) is None:
+                return None  # type: ignore
+            return MappingMarshaler(ke, ve)
+        if isinstance(rty, type) and issubclass(rty, collections.abc.Mapping):
+            if (e := ctx.make(ta.Any)) is None:
+                return None  # type: ignore
+            return MappingMarshaler(e, e)
+        return None
+
+
+@dc.dataclass(frozen=True)
+class MappingUnmarshaler(Unmarshaler):
+    ctor: ta.Callable[[ta.Mapping[ta.Any, ta.Any]], ta.Mapping]
+    ke: Unmarshaler
+    ve: Unmarshaler
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Mapping:
+        dct: dict = {}
+        for mk, mv in check.isinstance(v, collections.abc.Mapping).items():
+            dct[self.ke.unmarshal(ctx, mk)] = self.ve.unmarshal(ctx, mv)  # type: ignore
+        return self.ctor(dct)
+
+
+class MappingUnmarshalerFactory(UnmarshalerFactory):
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+        if isinstance(rty, rfl.Generic) and issubclass(rty.cls, collections.abc.Mapping):
+            kt, vt = rty.args
+            if (ke := ctx.make(kt)) is None or (ve := ctx.make(vt)) is None:
+                return None  # type: ignore
+            return MappingUnmarshaler(rty.cls, ke, ve)
+        if isinstance(rty, type) and issubclass(rty, collections.abc.Mapping):
+            if (e := ctx.make(ta.Any)) is None:
+                return None  # type: ignore
+            return MappingUnmarshaler(rty, e, e)
+        return None

omlish/marshal/naming.py

@@ -0,0 +1,17 @@
+import enum
+
+from .. import lang
+from .base import Option
+
+
+class Naming(Option, enum.Enum):
+    SNAKE = 'snake'
+    CAMEL = 'camel'
+
+
+def translate_name(n: str, e: Naming) -> str:
+    if e is Naming.SNAKE:
+        return lang.snake_case(n)
+    if e is Naming.CAMEL:
+        return lang.camel_case(n)
+    raise ValueError(e)

omlish/marshal/objects.py

@@ -0,0 +1,106 @@
+"""
+TODO:
+ - cfg naming
+ - adapters for dataclasses / namedtuples / user objects (as confitured)
+"""
+import collections.abc
+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 UnmarshalContext
+from .base import Unmarshaler
+from .base import UnmarshalerFactory
+from .naming import Naming
+from .values import Value
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ObjectMetadata:
+    field_naming: Naming | None = None
+
+    unknown_field: str | None = None
+
+
+@dc.dataclass(frozen=True)
+class FieldMetadata:
+    name: str | None = None
+    alts: ta.Iterable[str] | None = None
+
+    marshaler: Marshaler | None = None
+    marshaler_factory: MarshalerFactory | None = None
+
+    unmarshaler: Unmarshaler | None = None
+    unmarshaler_factory: UnmarshalerFactory | None = None
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class FieldInfo:
+    name: str
+    type: ta.Any
+    metadata: FieldMetadata
+
+    marshal_name: str
+    unmarshal_names: ta.Sequence[str]
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ObjectMarshaler(Marshaler):
+    fields: ta.Sequence[tuple[FieldInfo, Marshaler]]
+    unknown_field: str | None = None
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        ret = {
+            fi.marshal_name: m.marshal(ctx, getattr(o, fi.name))
+            for fi, m in self.fields
+        }
+        if self.unknown_field is not None:
+            if (ukf := getattr(o, self.unknown_field)):
+                if (dks := set(ret) & set(ukf)):
+                    raise KeyError(f'Unknown field keys duplicate fields: {dks!r}')
+            ret.update(ukf)  # FIXME: marshal?
+        return ret
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ObjectUnmarshaler(Unmarshaler):
+    cls: type
+    fields_by_unmarshal_name: ta.Mapping[str, tuple[FieldInfo, Unmarshaler]]
+    unknown_field: str | None = None
+
+    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
+        if self.unknown_field is not None:
+            kw[self.unknown_field] = 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
+                else:
+                    raise
+            if fi.name in kw:
+                raise KeyError(f'Duplicate keys for field {fi.name!r}: {ks!r}')
+            kw[fi.name] = u.unmarshal(ctx, mv)
+        return self.cls(**kw)