omlish 0.0.0.dev245__py3-none-any.whl → 0.0.0.dev247__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev245'
-__revision__ = 'c3979ac75a1b25b3c679bc0310afb6364c124c4c'
+__version__ = '0.0.0.dev247'
+__revision__ = '537438b3d967f194ec6ec7277d9e06205bac12b5'
 
 
 #

omlish/collections/__init__.py

@@ -63,7 +63,6 @@ from .mappings import (  # noqa
     DynamicTypeMap,
     guarded_map_update,
     multikey_dict,
-    yield_dict_init,
 )
 
 from .ordered import (  # noqa

omlish/collections/frozen.py

@@ -3,7 +3,7 @@ import collections.abc
 import itertools
 import typing as ta
 
-from .mappings import yield_dict_init
+from .. import lang
 
 
 T = ta.TypeVar('T')
@@ -27,7 +27,7 @@ class FrozenDict(ta.Mapping[K, V], Frozen):
         if len(args) > 1:
             raise TypeError(args)
         self._dct: dict[K, V] = {}
-        self._dct.update(yield_dict_init(*args, **kwargs))
+        self._dct.update(lang.yield_dict_init(*args, **kwargs))
 
     @property
     def debug(self) -> ta.Mapping[K, V]:

omlish/collections/hasheq.py

@@ -8,7 +8,6 @@ import dataclasses as dc
 import typing as ta
 
 from .. import lang
-from .mappings import yield_dict_init
 
 
 K = ta.TypeVar('K')
@@ -64,7 +63,7 @@ class HashEqMap(ta.MutableMapping[K, V]):
         self._dct: dict[int, list[HashEqMap._Node[K, V]]] = {}
         self._len = 0
 
-        for k, v in yield_dict_init(*args, **kwargs):
+        for k, v in lang.yield_dict_init(*args, **kwargs):
             self[k] = v
 
     def __len__(self) -> int:

omlish/collections/identity.py

@@ -4,7 +4,6 @@ import typing as ta
 import weakref
 
 from .. import lang
-from .mappings import yield_dict_init
 
 
 T = ta.TypeVar('T')
@@ -38,9 +37,12 @@ class IdentityKeyDict(ta.MutableMapping[K, V]):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__()
         self._dict: dict[int, tuple[K, V]] = {}
-        for k, v in yield_dict_init(*args, **kwargs):
+        for k, v in lang.yield_dict_init(*args, **kwargs):
             self[k] = v
 
+    def __reduce__(self):
+        return (type(self), (list(self.items()),))
+
     @property
     def debug(self) -> ta.Sequence[tuple[K, V]]:
         return list(self.items())
@@ -75,6 +77,9 @@ class IdentitySet(ta.MutableSet[T]):
             for item in init:
                 self.add(item)
 
+    def __reduce__(self):
+        return (type(self), (list(self),))
+
     @property
     def debug(self) -> ta.Sequence[T]:
         return list(self)

omlish/collections/mappings.py

@@ -1,4 +1,3 @@
-import collections.abc
 import typing as ta
 import weakref
 
@@ -33,21 +32,6 @@ def guarded_map_update(
     return dst
 
 
-def yield_dict_init(*args, **kwargs) -> ta.Iterable[tuple[ta.Any, ta.Any]]:
-    if len(args) > 1:
-        raise TypeError
-    if args:
-        [src] = args
-        if isinstance(src, collections.abc.Mapping):
-            for k in src:
-                yield (k, src[k])
-        else:
-            for k, v in src:
-                yield (k, v)
-    for k, v in kwargs.items():
-        yield (k, v)
-
-
 class TypeMap(ta.Generic[T]):
     def __init__(self, items: ta.Iterable[T] = ()) -> None:
         super().__init__()

omlish/collections/sorted/sorted.py

@@ -2,7 +2,6 @@ import abc
 import typing as ta
 
 from ... import lang
-from ..mappings import yield_dict_init
 
 
 T = ta.TypeVar('T')
@@ -83,7 +82,7 @@ class SortedListDict(SortedMutableMapping[K, V]):
     def __init__(self, impl: SortedCollection, *args, **kwargs) -> None:
         super().__init__()
         self._impl = impl
-        for k, v in yield_dict_init(*args, **kwargs):
+        for k, v in lang.yield_dict_init(*args, **kwargs):
             self[k] = v
 
     @property

omlish/daemons/services.py

@@ -1,3 +1,10 @@
+"""
+TODO:
+ - jsonl pidfile
+  - time started
+  - code version / revision
+  - venv?
+"""
 import abc
 import threading
 import typing as ta

omlish/dataclasses/__init__.py

@@ -108,6 +108,9 @@ from .utils import (  # noqa
     update_fields,
     update_fields_metadata,
 
+    shallow_astuple,
+    shallow_asdict,
+
     deep_replace,
 
     iter_items,

omlish/dataclasses/utils.py

@@ -32,6 +32,9 @@ def fields_dict(cls_or_instance: ta.Any) -> dict[str, dc.Field]:
     return {f.name: f for f in dc.fields(cls_or_instance)}
 
 
+##
+
+
 class field_modifier:  # noqa
     def __init__(self, fn: ta.Callable[[dc.Field], dc.Field]) -> None:
         super().__init__()
@@ -112,6 +115,17 @@ def update_fields_metadata(
 ##
 
 
+def shallow_astuple(o: ta.Any) -> tuple[ta.Any, ...]:
+    return tuple(getattr(o, f.name) for f in dc.fields(o))
+
+
+def shallow_asdict(o: ta.Any) -> dict[str, ta.Any]:
+    return {f.name: getattr(o, f.name) for f in dc.fields(o)}
+
+
+##
+
+
 def deep_replace(o: T, *args: str | ta.Callable[[ta.Any], ta.Mapping[str, ta.Any]]) -> T:
     if not args:
         return o

omlish/http/handlers.py

@@ -79,6 +79,22 @@ class LoggingHttpHandler(HttpHandler_):
         return resp
 
 
+@dc.dataclass(frozen=True)
+class ExceptionLoggingHttpHandler(HttpHandler_):
+    handler: HttpHandler
+    log: logging.Logger
+    message: ta.Union[str, ta.Callable[[HttpHandlerRequest, BaseException], str]] = 'Error in http handler'
+
+    def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        try:
+            return self.handler(req)
+        except Exception as e:  # noqa
+            if callable(msg := self.message):
+                msg = msg(req, e)
+            self.log.exception(msg)
+            raise
+
+
 ##
 
 

omlish/lang/__init__.py

@@ -1,5 +1,6 @@
 from .attrs import (  # noqa
     AttrOps,
+    DictAttrOps,
     STD_ATTR_OPS,
     StdAttrOps,
     TRANSIENT_ATTR_OPS,
@@ -76,6 +77,11 @@ from .cmp import (  # noqa
     cmp,
 )
 
+from .collections import (  # noqa
+    merge_dicts,
+    yield_dict_init,
+)
+
 from .contextmanagers import (  # noqa
     AsyncContextManager,
     ContextManaged,

omlish/lang/attrs.py

@@ -47,6 +47,35 @@ STD_ATTR_OPS = StdAttrOps()
 ##
 
 
+class DictAttrOps(AttrOps):
+    def __init__(self, dct: ta.MutableMapping[str, ta.Any] | None = None) -> None:
+        super().__init__()
+
+        if dct is None:
+            dct = {}
+        self._dct = dct
+
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrOps.NOT_SET) -> ta.Any:
+        try:
+            return self._dct[name]
+        except KeyError:
+            if default is not AttrOps.NOT_SET:
+                return default
+            raise AttributeError(name) from None
+
+    def setattr(self, obj: ta.Any, name: str, value: ta.Any) -> None:
+        self._dct[name] = value
+
+    def delattr(self, obj: ta.Any, name: str) -> None:
+        try:
+            del self._dct[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+
+##
+
+
 class TransientDict(collections.abc.MutableMapping):
     def __init__(self) -> None:
         super().__init__()

omlish/lang/cached/function.py

@@ -6,6 +6,7 @@ TODO:
   - must support free functions (which have no instance nor owner)
   - 'staticmethod' or effective equiv - which must resolve to the shared instance
    - and must be transient?
+ - use __transient_dict__ to support common state nuking
 """
 import dataclasses as dc
 import functools

omlish/lang/collections.py

@@ -0,0 +1,50 @@
+import collections.abc
+import typing as ta
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+def yield_dict_init(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterable[tuple[ta.Any, ta.Any]]:
+    if len(args) > 1:
+        raise TypeError
+    if args:
+        [src] = args
+        if isinstance(src, collections.abc.Mapping):
+            for k in src:
+                yield (k, src[k])
+        else:
+            for k, v in src:
+                yield (k, v)
+    for k, v in kwargs.items():
+        yield (k, v)
+
+
+def merge_dicts(
+        *dcts: ta.Mapping[K, V],
+        pair_fn: ta.Callable[[K, V], tuple[K, V] | None] | None = None,
+        conflict_fn: ta.Callable[[K, V, V], tuple[K, V] | None] | None = None,
+) -> dict[K, V]:
+    out: dict[K, V] = {}
+
+    for d in dcts:
+        for k_v in d.items():
+            if pair_fn is not None and (k_v := pair_fn(*k_v)) is None:  # type: ignore[assignment]
+                continue
+
+            k, v = k_v
+            if k in out:
+                if conflict_fn is None:
+                    raise KeyError(k)
+
+                if (k_v := conflict_fn(k, out[k], v)) is None:  # type: ignore[assignment]
+                    continue
+                k, v = k_v
+
+            out[k] = v
+
+    return out

omlish/marshal/__init__.py

@@ -28,6 +28,16 @@ from .base import (  # noqa
     ReflectOverride,
 )
 
+from .composite.iterables import (  # noqa
+    IterableMarshaler,
+    IterableUnmarshaler,
+)
+
+from .composite.wrapped import (  # noqa
+    WrappedMarshaler,
+    WrappedUnmarshaler,
+)
+
 from .exceptions import (  # noqa
     ForbiddenTypeError,
     MarshalError,
@@ -49,6 +59,14 @@ from .naming import (  # noqa
     translate_name,
 )
 
+from .objects.dataclasses import (  # noqa
+    AbstractDataclassFactory,
+    DataclassMarshalerFactory,
+    DataclassUnmarshalerFactory,
+    get_dataclass_field_infos,
+    get_dataclass_metadata,
+)
+
 from .objects.helpers import (  # noqa
     update_field_metadata,
     update_fields_metadata,
@@ -75,14 +93,18 @@ from .objects.unmarshal import (  # noqa
 )
 
 from .polymorphism.marshal import (  # noqa
+    PolymorphismMarshaler,
     PolymorphismMarshalerFactory,
     make_polymorphism_marshaler,
 )
 
 from .polymorphism.metadata import (  # noqa
+    FieldTypeTagging,
     Impl,
     Impls,
     Polymorphism,
+    TypeTagging,
+    WrapperTypeTagging,
     polymorphism_from_subclasses,
 )
 
@@ -97,6 +119,7 @@ from .polymorphism.unions import (  # noqa
 )
 
 from .polymorphism.unmarshal import (  # noqa
+    PolymorphismUnmarshaler,
     PolymorphismUnmarshalerFactory,
     make_polymorphism_unmarshaler,
 )

omlish/marshal/composite/wrapped.py

@@ -0,0 +1,26 @@
+import dataclasses as dc
+import typing as ta
+
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..values import Value
+
+
+@dc.dataclass(frozen=True)
+class WrappedMarshaler(Marshaler):
+    wrapper: ta.Callable[[MarshalContext, ta.Any], ta.Any]
+    m: Marshaler
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        return self.m.marshal(ctx, self.wrapper(ctx, o))
+
+
+@dc.dataclass(frozen=True)
+class WrappedUnmarshaler(Unmarshaler):
+    unwrapper: ta.Callable[[UnmarshalContext, ta.Any], ta.Any]
+    u: Unmarshaler
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        return self.unwrapper(ctx, self.u.unmarshal(ctx, v))

omlish/marshal/objects/dataclasses.py

@@ -41,12 +41,16 @@ def get_dataclass_metadata(ty: type) -> ObjectMetadata:
     ) or ObjectMetadata()
 
 
-def get_field_infos(
+def get_dataclass_field_infos(
         ty: type,
-        opts: col.TypeMap[Option] = col.TypeMap(),
+        opts: col.TypeMap[Option] | None = None,
 ) -> FieldInfos:
+    if opts is None:
+        opts = col.TypeMap()
+
     dc_md = get_dataclass_metadata(ty)
     dc_naming = dc_md.field_naming or opts.get(Naming)
+    dc_rf = dc.reflect(ty)
 
     fi_defaults = {
         k: v
@@ -62,18 +66,24 @@ def get_field_infos(
     type_hints = ta.get_type_hints(ty)
 
     ret: list[FieldInfo] = []
-    for field in dc.fields(ty):
+    for field in dc_rf.fields.values():
         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
 
+        f_ty: ta.Any
+        if (cpx := dc_rf.cls_params_extras) is not None and cpx.generic_init:
+            f_ty = dc_rf.generic_replaced_field_annotations[field.name]
+        else:
+            f_ty = type_hints[field.name]
+
         fi_kw = dict(fi_defaults)
         fo_kw = dict(fo_defaults)
 
         fi_kw.update(
             name=field.name,
-            type=type_hints[field.name],
+            type=f_ty,
             metadata=FieldMetadata(),
 
             marshal_name=um_name,
@@ -158,7 +168,22 @@ def _make_field_obj(ctx, ty, obj, fac):
 ##
 
 
-class DataclassMarshalerFactory(MarshalerFactory):
+class AbstractDataclassFactory(lang.Abstract):
+    def _get_metadata(self, ty: type) -> ObjectMetadata:
+        return get_dataclass_metadata(ty)
+
+    def _get_field_infos(
+            self,
+            ty: type,
+            opts: col.TypeMap[Option] | None = None,
+    ) -> FieldInfos:
+        return get_dataclass_field_infos(ty, opts)
+
+
+##
+
+
+class DataclassMarshalerFactory(AbstractDataclassFactory, MarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, type) and dc.is_dataclass(rty) and not lang.is_abstract_class(rty)
 
@@ -167,8 +192,8 @@ class DataclassMarshalerFactory(MarshalerFactory):
         check.state(dc.is_dataclass(ty))
         check.state(not lang.is_abstract_class(ty))
 
-        dc_md = get_dataclass_metadata(ty)
-        fis = get_field_infos(ty, ctx.options)
+        dc_md = self._get_metadata(ty)
+        fis = self._get_field_infos(ty, ctx.options)
 
         fields = [
             (fi, _make_field_obj(ctx, fi.type, fi.metadata.marshaler, fi.metadata.marshaler_factory))
@@ -185,7 +210,7 @@ class DataclassMarshalerFactory(MarshalerFactory):
 ##
 
 
-class DataclassUnmarshalerFactory(UnmarshalerFactory):
+class DataclassUnmarshalerFactory(AbstractDataclassFactory, UnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
         return isinstance(rty, type) and dc.is_dataclass(rty) and not lang.is_abstract_class(rty)
 
@@ -194,8 +219,8 @@ class DataclassUnmarshalerFactory(UnmarshalerFactory):
         check.state(dc.is_dataclass(ty))
         check.state(not lang.is_abstract_class(ty))
 
-        dc_md = get_dataclass_metadata(ty)
-        fis = get_field_infos(ty, ctx.options)
+        dc_md = self._get_metadata(ty)
+        fis = self._get_field_infos(ty, ctx.options)
 
         d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
         defaults: dict[str, ta.Any] = {}
@@ -213,7 +238,7 @@ class DataclassUnmarshalerFactory(UnmarshalerFactory):
                     raise Exception(f'Embedded fields cannot have specials: {e_ty}')
 
                 embeds[fi.name] = e_ty
-                for e_fi in get_field_infos(e_ty, ctx.options):
+                for e_fi in self._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)

omlish/marshal/objects/namedtuples.py

@@ -22,7 +22,7 @@ from .unmarshal import ObjectUnmarshaler
 ##
 
 
-def _is_named_tuple(rty: rfl.Type) -> bool:
+def _is_namedtuple(rty: rfl.Type) -> bool:
     return (
         isinstance(rty, type) and
         issubclass(rty, tuple) and
@@ -30,11 +30,11 @@ def _is_named_tuple(rty: rfl.Type) -> bool:
     )
 
 
-def get_field_infos(
+def get_namedtuple_field_infos(
         ty: type,
         opts: col.TypeMap[Option] = col.TypeMap(),
 ) -> FieldInfos:
-    check.arg(_is_named_tuple(ty), ty)
+    check.arg(_is_namedtuple(ty), ty)
 
     sig = inspect.signature(ty)
 
@@ -57,14 +57,14 @@ def get_field_infos(
 
 class NamedtupleMarshalerFactory(MarshalerFactory):
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
-        return _is_named_tuple(rty)
+        return _is_namedtuple(rty)
 
     def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
-        check.state(_is_named_tuple(rty))
+        check.state(_is_namedtuple(rty))
         ty = check.isinstance(rty, type)
         check.state(not lang.is_abstract_class(ty))
 
-        fis = get_field_infos(ty, ctx.options)
+        fis = get_namedtuple_field_infos(ty, ctx.options)
 
         fields = [
             (fi, ctx.make(fi.type))
@@ -81,14 +81,14 @@ class NamedtupleMarshalerFactory(MarshalerFactory):
 
 class NamedtupleUnmarshalerFactory(UnmarshalerFactory):
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
-        return _is_named_tuple(rty)
+        return _is_namedtuple(rty)
 
     def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
-        check.state(_is_named_tuple(rty))
+        check.state(_is_namedtuple(rty))
         ty = check.isinstance(rty, type)
         check.state(not lang.is_abstract_class(ty))
 
-        fis = get_field_infos(ty, ctx.options)
+        fis = get_namedtuple_field_infos(ty, ctx.options)
 
         d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
         defaults: dict[str, ta.Any] = {}

omlish/marshal/polymorphism/marshal.py

@@ -1,7 +1,9 @@
+import abc
 import dataclasses as dc
 import typing as ta
 
 from ... import check
+from ... import lang
 from ... import reflect as rfl
 from ..base import MarshalContext
 from ..base import Marshaler
@@ -17,20 +19,32 @@ from .metadata import WrapperTypeTagging
 ##
 
 
+class PolymorphismMarshaler(Marshaler, lang.Abstract):
+    @abc.abstractmethod
+    def get_impls(self) -> ta.Mapping[type, tuple[str, Marshaler]]:
+        raise NotImplementedError
+
+
 @dc.dataclass(frozen=True)
-class WrapperPolymorphismMarshaler(Marshaler):
+class WrapperPolymorphismMarshaler(PolymorphismMarshaler):
     m: ta.Mapping[type, tuple[str, Marshaler]]
 
+    def get_impls(self) -> ta.Mapping[type, tuple[str, Marshaler]]:
+        return self.m
+
     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):
+class FieldPolymorphismMarshaler(PolymorphismMarshaler):
     m: ta.Mapping[type, tuple[str, Marshaler]]
     tf: str
 
+    def get_impls(self) -> ta.Mapping[type, tuple[str, Marshaler]]:
+        return self.m
+
     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

omlish/marshal/polymorphism/unmarshal.py

@@ -1,8 +1,10 @@
+import abc
 import collections.abc
 import dataclasses as dc
 import typing as ta
 
 from ... import check
+from ... import lang
 from ... import reflect as rfl
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
@@ -18,10 +20,19 @@ from .metadata import WrapperTypeTagging
 ##
 
 
+class PolymorphismUnmarshaler(Unmarshaler, lang.Abstract):
+    @abc.abstractmethod
+    def get_impls(self) -> ta.Mapping[str, Unmarshaler]:
+        raise NotImplementedError
+
+
 @dc.dataclass(frozen=True)
-class WrapperPolymorphismUnmarshaler(Unmarshaler):
+class WrapperPolymorphismUnmarshaler(PolymorphismUnmarshaler):
     m: ta.Mapping[str, Unmarshaler]
 
+    def get_impls(self) -> ta.Mapping[str, Unmarshaler]:
+        return self.m
+
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
         ma = check.isinstance(v, collections.abc.Mapping)
         [(tag, iv)] = ma.items()
@@ -30,10 +41,13 @@ class WrapperPolymorphismUnmarshaler(Unmarshaler):
 
 
 @dc.dataclass(frozen=True)
-class FieldPolymorphismUnmarshaler(Unmarshaler):
+class FieldPolymorphismUnmarshaler(PolymorphismUnmarshaler):
     m: ta.Mapping[str, Unmarshaler]
     tf: str
 
+    def get_impls(self) -> ta.Mapping[str, Unmarshaler]:
+        return self.m
+
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any | None:
         ma = dict(check.isinstance(v, collections.abc.Mapping))
         tag = ma.pop(self.tf)