omlish 0.0.0.dev244__py3-none-any.whl → 0.0.0.dev246__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev244'
-__revision__ = 'e7768b1afd9f43a5f1534c2840691f48c0a89efb'
+__version__ = '0.0.0.dev246'
+__revision__ = '796628c78050f0ca988bfa17c2f5a5cad5ee9056'
 
 
 #

omlish/cached.py

@@ -9,11 +9,12 @@ builtins and thus not distinguish it from a normal property.
         def p(self) -> str: ...
 
 """
-from .lang.cached import _CachedProperty  # noqa
-from .lang.cached import cached_function as _cached_function
+from .lang.cached.function import cached_function as _cached_function
+from .lang.cached.property import cached_property as _cached_property
+
 
 function = _cached_function
 
 property = property  # noqa
 
-globals()['property'] = _CachedProperty  # noqa
+globals()['property'] = _cached_property  # noqa

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,7 +37,7 @@ 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
 
     @property

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,39 +1,64 @@
-from .cached import (  # noqa
+from .attrs import (  # noqa
+    AttrOps,
+    DictAttrOps,
+    STD_ATTR_OPS,
+    StdAttrOps,
+    TRANSIENT_ATTR_OPS,
+    TransientAttrOps,
+    TransientDict,
+    transient_delattr,
+    transient_getattr,
+    transient_setattr,
+)
+
+from .cached.function import (  # noqa
     cached_function,
-    cached_property,
     static_init,
 )
 
-from .classes import (  # noqa
+from .cached.property import (  # noqa
+    cached_property,
+)
+
+from .classes.abstract import (  # noqa
     Abstract,
     AbstractTypeError,
+    get_abstract_methods,
+    is_abstract,
+    is_abstract_class,
+    is_abstract_method,
+    make_abstract,
+    unabstract_class,
+)
+
+from .classes.restrict import (  # noqa
     AnySensitive,
-    Callable,
-    Descriptor,
     Final,
     FinalTypeError,
-    LazySingleton,
-    Marker,
-    Namespace,
     NoBool,
     NotInstantiable,
     NotPicklable,
     PackageSealed,
-    Picklable,
     SENSITIVE_ATTR,
     Sealed,
     SealedError,
     Sensitive,
+    no_bool,
+)
+
+from .classes.simple import (  # noqa
+    LazySingleton,
+    Marker,
+    Namespace,
     SimpleMetaDict,
     Singleton,
+)
+
+from .classes.virtual import (  # noqa
+    Callable,
+    Descriptor,
+    Picklable,
     Virtual,
-    get_abstract_methods,
-    is_abstract,
-    is_abstract_class,
-    is_abstract_method,
-    make_abstract,
-    no_bool,
-    unabstract_class,
     virtual_check,
 )
 
@@ -52,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

@@ -0,0 +1,161 @@
+import abc
+import collections.abc
+import typing as ta
+
+
+##
+
+
+class AttrOps(abc.ABC):
+    class NOT_SET:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    @abc.abstractmethod
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = NOT_SET) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def setattr(self, obj: ta.Any, name: str, value: ta.Any) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def delattr(self, obj: ta.Any, name: str) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+class StdAttrOps(AttrOps):
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrOps.NOT_SET) -> ta.Any:
+        if default is AttrOps.NOT_SET:
+            return getattr(obj, name)
+        else:
+            return getattr(obj, name, default)
+
+    def setattr(self, obj: ta.Any, name: str, value: ta.Any) -> None:
+        setattr(obj, name, value)
+
+    def delattr(self, obj: ta.Any, name: str) -> None:
+        delattr(obj, name)
+
+
+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__()
+
+        self._dct: dict = {}
+
+    def __reduce__(self):
+        return (TransientDict, ())
+
+    def __getitem__(self, item):
+        return self._dct[item]
+
+    def __setitem__(self, key, value):
+        self._dct[key] = value
+
+    def __delitem__(self, key):
+        del self._dct[key]
+
+    def __len__(self):
+        return len(self._dct)
+
+    def __iter__(self):
+        return iter(self._dct)
+
+    def clear(self):
+        self._dct.clear()
+
+    def items(self):
+        return self._dct.items()
+
+    def keys(self):
+        return self._dct.keys()
+
+    def values(self):
+        return self._dct.values()
+
+    def __contains__(self, key, /):
+        return super().__contains__(key)
+
+    def __eq__(self, other, /):
+        raise TypeError(self)
+
+
+#
+
+
+_TRANSIENT_DICT_ATTR = '__transient_dict__'
+
+
+def _get_object_transient_dict(obj: ta.Any) -> TransientDict:
+    try:
+        return obj.__dict__[_TRANSIENT_DICT_ATTR]
+    except KeyError:
+        return obj.__dict__.setdefault(_TRANSIENT_DICT_ATTR, TransientDict())
+
+
+class TransientAttrOps(AttrOps):
+    def getattr(self, obj: ta.Any, name: str, default: ta.Any = AttrOps.NOT_SET) -> ta.Any:
+        td = _get_object_transient_dict(obj)
+        try:
+            return td[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:
+        td = _get_object_transient_dict(obj)
+        td[name] = value
+
+    def delattr(self, obj: ta.Any, name: str) -> None:
+        td = _get_object_transient_dict(obj)
+        try:
+            del td[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+
+TRANSIENT_ATTR_OPS = TransientAttrOps()
+
+transient_getattr = TRANSIENT_ATTR_OPS.getattr
+transient_setattr = TRANSIENT_ATTR_OPS.setattr
+transient_delattr = TRANSIENT_ATTR_OPS.delattr