omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev6__py3-none-any.whl

omlish/dataclasses/__init__.py

@@ -55,6 +55,7 @@ globals()['make_dataclass'] = xmake_dataclass
 
 from .impl.exceptions import (  # noqa
     CheckError,
+    FieldCheckError,
 )
 
 from .impl.metaclass import (  # noqa
@@ -81,3 +82,11 @@ from .impl.reflect import (  # noqa
     ClassInfo,
     reflect,
 )
+
+from .utils import (  # noqa
+    chain_metadata,
+    field_modifier,
+    maybe_post_init,
+    opt_repr,
+    update_field_metadata,
+)

omlish/dataclasses/impl/copy.py

@@ -0,0 +1,30 @@
+"""
+TODO:
+ - __deepcopy__
+"""
+import dataclasses as dc
+
+from .fields import field_type
+from .internals import FIELDS_ATTR
+from .internals import FieldType
+from .processing import Processor
+from .utils import set_new_attribute
+
+
+MISSING = dc.MISSING
+
+
+def _copy(obj):
+    kw = {}
+
+    for f in getattr(obj, FIELDS_ATTR).values():
+        if field_type(f) is FieldType.CLASS:
+            continue
+        kw[f.name] = getattr(obj, f.name)
+
+    return obj.__class__(**kw)
+
+
+class CopyProcessor(Processor):
+    def _process(self) -> None:
+        set_new_attribute(self._cls, '__copy__', _copy)

omlish/dataclasses/impl/exceptions.py

@@ -1,2 +1,8 @@
 class CheckError(Exception):
     pass
+
+
+class FieldCheckError(CheckError):
+    def __init__(self, field: str) -> None:
+        super().__init__(field)
+        self.field = field

omlish/dataclasses/impl/fields.py

@@ -98,51 +98,50 @@ def field_init(
 
     lines = []
 
-    if fx.coerce is not None:
-        cn = f'__dataclass_coerce__{f.name}__'
-        locals[cn] = fx.coerce
-        lines.append(f'{f.name} = {cn}({f.name})')
-
-    if fx.check is not None:
-        cn = f'__dataclass_check__{f.name}__'
-        locals[cn] = fx.check
-        lines.append(f'if not {cn}({f.name}): raise __dataclass_CheckException__')
-
-    if fx.check_type:
-        cn = f'__dataclass_check_type__{f.name}__'
-        locals[cn] = f.type
-        lines.append(
-            f'if not __dataclass_builtins_isinstance__({f.name}, {cn}): '
-            f'raise __dataclass_builtins_TypeError__({f.name}, {cn})',
-        )
-
     value: str | None = None
     if f.default_factory is not MISSING:
         if f.init:
             locals[default_name] = f.default_factory
-            value = (
-                f'{default_name}() '
-                f'if {f.name} is __dataclass_HAS_DEFAULT_FACTORY__ '
-                f'else {f.name}'
-            )
+            lines.append(f'if {f.name} is __dataclass_HAS_DEFAULT_FACTORY__: {f.name} = {default_name}()')
+            value = f.name
         else:
             locals[default_name] = f.default_factory
-            value = f'{default_name}()'
+            lines.append(f'{f.name} = {default_name}()')
+            value = f.name
 
     elif f.init:
         if f.default is MISSING:
             value = f.name
         elif f.default is not MISSING:
-            locals[default_name] = f.default
+            locals[default_name] = f.default  # Not referenced her, just useful / consistent to have in function scope
             value = f.name
 
     elif slots and f.default is not MISSING:
         locals[default_name] = f.default
+        lines.append(f'{f.name} = {default_name}')
         value = default_name
 
     else:
         pass
 
+    if fx.coerce is not None:
+        cn = f'__dataclass_coerce__{f.name}__'
+        locals[cn] = fx.coerce
+        lines.append(f'{value} = {cn}({value})')
+
+    if fx.check is not None:
+        cn = f'__dataclass_check__{f.name}__'
+        locals[cn] = fx.check
+        lines.append(f'if not {cn}({value}): raise __dataclass_FieldCheckError__({f.name})')
+
+    if fx.check_type:
+        cn = f'__dataclass_check_type__{f.name}__'
+        locals[cn] = f.type
+        lines.append(
+            f'if not __dataclass_builtins_isinstance__({value}, {cn}): '
+            f'raise __dataclass_builtins_TypeError__({value}, {cn})',
+        )
+
     if value is not None and field_type(f) is not FieldType.INIT:
         lines.append(field_assign(frozen, f.name, value, self_name, fx.override))  # noqa
 

omlish/dataclasses/impl/init.py

@@ -4,6 +4,7 @@ import typing as ta
 
 from ... import lang
 from .exceptions import CheckError
+from .exceptions import FieldCheckError
 from .fields import field_init
 from .fields import field_type
 from .fields import has_default
@@ -99,7 +100,8 @@ class InitBuilder:
             '__dataclass_builtins_object__': object,
             '__dataclass_builtins_isinstance__': isinstance,
             '__dataclass_builtins_TypeError__': TypeError,
-            '__dataclass_CheckException__': CheckError,
+            '__dataclass_CheckError__': CheckError,
+            '__dataclass_FieldCheckError__': FieldCheckError,
         })
 
         body_lines: list[str] = []
@@ -126,7 +128,7 @@ class InitBuilder:
             locals[cn] = fn
             csig = inspect.signature(fn)
             cas = ', '.join(p.name for p in csig.parameters.values())
-            body_lines.append(f'if not {cn}({cas}): raise __dataclass_CheckException__')
+            body_lines.append(f'if not {cn}({cas}): raise __dataclass_CheckError__')
 
         for i, fn in enumerate(self._info.merged_metadata.get(Init, [])):
             cn = f'__dataclass_init_{i}__'

omlish/dataclasses/impl/main.py

@@ -4,6 +4,7 @@ import typing as ta
 
 from ... import check
 from ... import lang
+from .copy import CopyProcessor
 from .fields import preprocess_field
 from .frozen import FrozenProcessor
 from .hashing import HashProcessor
@@ -137,6 +138,7 @@ class MainProcessor:
             DocProcessor,
             MatchArgsProcessor,
             ReplaceProcessor,
+            CopyProcessor,
         ]:
             pcls(self._info).process()
 

omlish/dataclasses/utils.py

@@ -0,0 +1,44 @@
+import collections
+import dataclasses as dc
+import types
+import typing as ta
+
+from .. import check
+
+
+T = ta.TypeVar('T')
+
+
+def maybe_post_init(sup: ta.Any) -> bool:
+    try:
+        fn = sup.__post_init__
+    except AttributeError:
+        return False
+    fn()
+    return True
+
+
+def opt_repr(o: ta.Any) -> str | None:
+    return repr(o) if o is not None else None
+
+
+class field_modifier:  # noqa
+    def __init__(self, fn: ta.Callable[[dc.Field], dc.Field]) -> None:
+        super().__init__()
+        self.fn = fn
+
+    def __ror__(self, other: T) -> T:
+        return self(other)
+
+    def __call__(self, f: T) -> T:
+        return check.isinstance(self.fn(check.isinstance(f, dc.Field)), dc.Field)  # type: ignore
+
+
+def chain_metadata(*mds: ta.Mapping) -> types.MappingProxyType:
+    return types.MappingProxyType(collections.ChainMap(*mds))  # type: ignore  # noqa
+
+
+def update_field_metadata(f: dc.Field, nmd: ta.Mapping) -> dc.Field:
+    check.isinstance(f, dc.Field)
+    f.metadata = chain_metadata(nmd, f.metadata)
+    return f

omlish/diag/__init__.py

@@ -0,0 +1,4 @@
+"""
+TODO:
+ - https://github.com/aristocratos/btop/blob/00c90884c328eb3e44a0ab094e833161092aae9c/src/linux/btop_collect.cpp#L443
+"""

omlish/diag/procfs.py

@@ -12,9 +12,9 @@ import sys
 import typing as ta
 
 from .. import iterators as it
-from .. import json
 from .. import lang
 from .. import os as oos
+from ..serde import json
 from .procstats import ProcStats
 
 
@@ -42,7 +42,7 @@ def parse_size(s: str) -> int:
     return int(v) * us[u]
 
 
-class ProcStat(lang.Namespace):
+class ProcStat(lang.Namespace, lang.Final):
     PID = 0
     COMM = 1
     STATE = 2

omlish/{testing → diag}/pydevd.py

@@ -32,6 +32,7 @@ import os
 import sys
 import tempfile
 import textwrap
+import threading
 import types
 import typing as ta
 
@@ -243,3 +244,37 @@ def maybe_reexec(
         args = [args[0], bootstrap_path]
 
     os.execvp(sys.executable, args)
+
+
+def debug_unhandled_exception(exc_info: ta.Any = None) -> None:
+    if exc_info is None:
+        exc_info = sys.exc_info()
+
+    try:
+        import pydevd
+        from pydevd import pydevd_tracing
+
+    except ImportError:
+        return
+
+    exctype, value, traceback = exc_info
+    frames = []
+    while traceback:
+        frames.append(traceback.tb_frame)
+        traceback = traceback.tb_next
+
+    thread = threading.current_thread()
+    frames_by_id = {id(frame): frame for frame in frames}
+    frame = frames[-1]
+    exception = (exctype, value, traceback)
+
+    if hasattr(thread, 'additional_info'):
+        thread.additional_info.pydev_message = 'server exception'
+    try:
+        debugger = pydevd.debugger  # noqa
+    except AttributeError:
+        debugger = pydevd.get_global_debugger()  # noqa
+
+    pydevd_tracing.SetTrace(None)
+
+    debugger.stop_on_unhandled_exception(thread, frame, frames_by_id, exception)

omlish/dispatch/_dispatch2.py

@@ -0,0 +1,65 @@
+import abc
+import typing as ta
+import weakref
+
+from .dispatch import find_impl
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class Dispatcher(ta.Generic[T]):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._impls_by_arg_cls: dict[type, T] = {}
+        self._dispatch_cache: dict[ta.Any, T | None] = {}
+
+        def cache_remove(k, self_ref=weakref.ref(self)):
+            if (ref_self := self_ref()) is not None:
+                cache = ref_self._dispatch_cache  # noqa
+                try:
+                    del cache[k]
+                except KeyError:
+                    pass
+
+        self._cache_remove = cache_remove
+
+        self._cache_token: ta.Any = None
+
+    def cache_size(self) -> int:
+        return len(self._dispatch_cache)
+
+    def register(self, impl: T, cls_col: ta.Iterable[type]) -> T:
+        for cls in cls_col:
+            self._impls_by_arg_cls[cls] = impl
+
+            if self._cache_token is None and hasattr(cls, '__abstractmethods__'):
+                self._cache_token = abc.get_cache_token()
+
+        self._dispatch_cache.clear()
+        return impl
+
+    def dispatch(self, cls: type) -> T | None:
+        if self._cache_token is not None and (current_token := abc.get_cache_token()) != self._cache_token:
+            self._dispatch_cache.clear()
+            self._cache_token = current_token
+
+        cls_ref = weakref.ref(cls)
+        try:
+            return self._dispatch_cache[cls_ref]
+        except KeyError:
+            pass
+        del cls_ref
+
+        impl: T | None
+        try:
+            impl = self._impls_by_arg_cls[cls]
+        except KeyError:
+            impl = find_impl(cls, self._impls_by_arg_cls)
+
+        self._dispatch_cache[weakref.ref(cls, self._cache_remove)] = impl
+        return impl

omlish/dispatch/_dispatch3.py

@@ -0,0 +1,104 @@
+import abc
+import typing as ta
+import weakref
+
+from .dispatch import find_impl
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class DispatchCacheProtocol(ta.Protocol[T]):
+    def size(self) -> int: ...
+    def prepare(self, cls: type) -> None: ...
+    def clear(self) -> None: ...
+    def put(self, cls: type, impl: T) -> None: ...
+    def get(self, cls: type) -> T: ...  # Raises[KeyError]
+
+
+class DispatcherProtocol(ta.Protocol[T]):
+    def cache_size(self) -> int: ...
+    def register(self, impl: T, cls_col: ta.Iterable[type]) -> T: ...
+    def dispatch(self, cls: type) -> T | None: ...
+
+
+##
+
+
+class DispatchCache(DispatchCacheProtocol[T]):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._dct: dict[ta.Any, T] = {}
+
+        def remove(k, self_ref=weakref.ref(self)):
+            if (ref_self := self_ref()) is not None:
+                dct = ref_self._dct  # noqa
+                try:
+                    del dct[k]
+                except KeyError:
+                    pass
+
+        self._remove = remove
+
+        self._token: ta.Any = None
+
+    def size(self) -> int:
+        return len(self._dct)
+
+    def prepare(self, cls: type) -> None:
+        if self._token is None and hasattr(cls, '__abstractmethods__'):
+            self._token = abc.get_cache_token()
+
+        self.clear()
+
+    def clear(self) -> None:
+        if self._dct:
+            self._dct.clear()
+
+    def put(self, cls: type, impl: T) -> None:
+        self._dct[weakref.ref(cls, self._remove)] = impl
+
+    def get(self, cls: type) -> T:
+        if self._token is not None and (current_token := abc.get_cache_token()) != self._token:
+            self._dct.clear()
+            self._token = current_token
+
+        cls_ref = weakref.ref(cls)
+        return self._dct[cls_ref]
+
+
+class Dispatcher(DispatcherProtocol[T]):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._impls_by_arg_cls: dict[type, T] = {}
+        self._cache: DispatchCache[T | None] = DispatchCache()
+
+    def cache_size(self) -> int:
+        return self._cache.size()
+
+    def register(self, impl: T, cls_col: ta.Iterable[type]) -> T:
+        for cls in cls_col:
+            self._impls_by_arg_cls[cls] = impl
+            self._cache.prepare(cls)
+
+        return impl
+
+    def dispatch(self, cls: type) -> T | None:
+        try:
+            return self._cache.get(cls)
+        except KeyError:
+            pass
+
+        impl: T | None
+        try:
+            impl = self._impls_by_arg_cls[cls]
+        except KeyError:
+            impl = find_impl(cls, self._impls_by_arg_cls)
+
+        self._cache.put(cls, impl)
+        return impl

omlish/docker.py

@@ -22,9 +22,9 @@ import typing as ta
 
 from . import check
 from . import dataclasses as dc
-from . import json
 from . import lang
 from . import marshal as msh
+from .serde import json
 
 
 if ta.TYPE_CHECKING:

omlish/fnpairs.py

@@ -29,6 +29,7 @@ if ta.TYPE_CHECKING:
     import tomllib as _tomllib
 
     import cloudpickle as _cloudpickle
+    import json5 as _json5
     import lz4.frame as _lz4_frame
     import snappy as _snappy
     import yaml as _yaml
@@ -44,6 +45,7 @@ else:
     _tomllib = lang.proxy_import('tomllib')
 
     _cloudpickle = lang.proxy_import('cloudpickle')
+    _json5 = lang.proxy_import('json5')
     _lz4_frame = lang.proxy_import('lz4.frame')
     _snappy = lang.proxy_import('snappy')
     _yaml = lang.proxy_import('yaml')
@@ -391,6 +393,15 @@ class Cloudpickle(ObjectBytes_):
         return _cloudpickle.loads(t)
 
 
+@_register_extension('json5')
+class Json5(ObjectStr_):
+    def forward(self, f: ta.Any) -> str:
+        return _json5.dumps(f)
+
+    def backward(self, t: str) -> ta.Any:
+        return _json5.loads(t)
+
+
 @_register_extension('yml', 'yaml')
 class Yaml(ObjectStr_):
     def forward(self, f: ta.Any) -> str:

omlish/http/asgi.py

@@ -18,9 +18,10 @@ AsgiMessage: ta.TypeAlias = ta.Mapping[str, ta.Any]
 AsgiRecv: ta.TypeAlias = ta.Callable[[], ta.Awaitable[AsgiMessage]]
 AsgiSend: ta.TypeAlias = ta.Callable[[AsgiMessage], ta.Awaitable[None]]
 AsgiApp: ta.TypeAlias = ta.Callable[[AsgiScope, AsgiRecv, AsgiSend], ta.Awaitable[None]]
+AsgiWrapper: ta.TypeAlias = ta.Callable[[AsgiApp, AsgiScope, AsgiRecv, AsgiSend], ta.Awaitable[None]]
 
 
-class AbstractAsgiApp(abc.ABC):
+class AsgiApp_(abc.ABC):  # noqa
     @abc.abstractmethod
     async def __call__(self, scope: AsgiScope, recv: AsgiRecv, send: AsgiSend) -> None:
         raise NotImplementedError

omlish/http/collections.py

@@ -0,0 +1,15 @@
+import typing as ta
+
+
+V = ta.TypeVar('V')
+
+
+class HttpMap(ta.Mapping[str, V]):
+    def __getitem__(self, k):
+        raise NotImplementedError
+
+    def __len__(self):
+        raise NotImplementedError
+
+    def __iter__(self):
+        raise NotImplementedError

omlish/http/consts.py

@@ -1,4 +1,5 @@
-import http  # noqa
+import base64
+import http
 
 
 ##
@@ -31,6 +32,8 @@ STATUS_GATEWAY_TIMEOUT = format_status(http.HTTPStatus.GATEWAY_TIMEOUT)
 
 
 HEADER_CONTENT_TYPE = b'Content-Type'
+HEADER_ACCEPT = b'Accept'
+
 CONTENT_CHARSET_UTF8 = b'charset=utf-8'
 
 CONTENT_TYPE_BYTES = b'application/octet-stream'
@@ -45,3 +48,15 @@ CONTENT_TYPE_JSON_UTF8 = b'; '.join([CONTENT_TYPE_JSON, CONTENT_CHARSET_UTF8])
 
 CONTENT_TYPE_TEXT = b'text/plain'
 CONTENT_TYPE_TEXT_UTF8 = b'; '.join([CONTENT_TYPE_TEXT, CONTENT_CHARSET_UTF8])
+
+
+##
+
+
+HEADER_AUTH = b'Authorization'
+BEARER_AUTH_HEADER_PREFIX = b'Bearer '
+BASIC_AUTH_HEADER_PREFIX = b'Basic '
+
+
+def format_basic_auth_header(username: str, password: str) -> bytes:
+    return BASIC_AUTH_HEADER_PREFIX + base64.b64encode(':'.join([username, password]).encode())

omlish/http/sessions.py

@@ -10,6 +10,7 @@ import zlib
 
 from .. import fnpairs as fps
 from .. import lang
+from .. import secrets as sec
 from .cookies import dump_cookie
 from .cookies import parse_cookie
 from .json import JSON_TAGGER
@@ -44,13 +45,19 @@ def bytes_to_int(bytestr: bytes) -> int:
 class Signer:
     @dc.dataclass(frozen=True)
     class Config:
-        secret_key: str
+        secret_key: str | sec.Secret = dc.field()
         salt: str = 'cookie-session'
 
-    def __init__(self, config: Config) -> None:
+    def __init__(
+            self,
+            config: Config,
+            *,
+            secrets: sec.Secrets = sec.EMPTY_SECRETS,
+    ) -> None:
         super().__init__()
 
         self._config = config
+        self._secrets = secrets
 
     @lang.cached_function
     def digest(self) -> ta.Any:
@@ -58,7 +65,7 @@ class Signer:
 
     @lang.cached_function
     def derive_key(self) -> bytes:
-        mac = hmac.new(self._config.secret_key.encode(), digestmod=self.digest())
+        mac = hmac.new(self._secrets.fix(self._config.secret_key).encode(), digestmod=self.digest())
         mac.update(self._config.salt.encode())
         return mac.digest()