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

omlish/check.py

@@ -58,7 +58,7 @@ def _unpack_isinstance_spec(spec: ta.Any) -> tuple:
     return spec
 
 
-def isinstance(v: ta.Any, spec: ta.Union[type[T], tuple], msg: Message = None) -> T:  # noqa
+def isinstance(v: ta.Any, spec: type[T] | tuple, msg: Message = None) -> T:  # noqa
     if not _isinstance(v, _unpack_isinstance_spec(spec)):
         _raise(TypeError, 'Must be instance', msg, v, spec)
     return v

omlish/collections/__init__.py

@@ -25,6 +25,10 @@ from .coerce import (  # noqa
     seq_or_none,
 )
 
+from .exceptions import (  # noqa
+    DuplicateKeyError,
+)
+
 from .frozen import (  # noqa
     Frozen,
     FrozenDict,

omlish/collections/exceptions.py

@@ -0,0 +1,2 @@
+class DuplicateKeyError(KeyError):
+    pass

omlish/collections/utils.py

@@ -3,6 +3,8 @@ import itertools
 import typing as ta
 
 from .. import check
+from .. import lang
+from .exceptions import DuplicateKeyError
 from .identity import IdentityKeyDict
 from .identity import IdentitySet
 
@@ -48,29 +50,56 @@ def partition(items: ta.Iterable[T], pred: ta.Callable[[T], bool]) -> tuple[list
     return t, f
 
 
-def unique(it: ta.Iterable[T], *, identity: bool = False) -> list[T]:
+def unique(
+        it: ta.Iterable[T],
+        *,
+        key: ta.Callable[[T], ta.Any] = lang.identity,
+        identity: bool = False,
+        strict: bool = False,
+) -> list[T]:
     if isinstance(it, str):
         raise TypeError(it)
     ret: list[T] = []
-    seen: ta.MutableSet[T] = IdentitySet() if identity else set()
+    seen: ta.MutableSet = IdentitySet() if identity else set()
     for e in it:
-        if e not in seen:
-            seen.add(e)
+        k = key(e)
+        if k in seen:
+            if strict:
+                raise DuplicateKeyError(k, e)
+        else:
+            seen.add(k)
             ret.append(e)
     return ret
 
 
-def unique_map(kvs: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, V]:
+def unique_map(
+        kvs: ta.Iterable[tuple[K, V]],
+        *,
+        identity: bool = False,
+        strict: bool = False,
+) -> ta.MutableMapping[K, V]:
     d: ta.MutableMapping[K, V] = IdentityKeyDict() if identity else {}
     for k, v in kvs:
         if k in d:
-            raise KeyError(k)
-        d[k] = v
+            if strict:
+                raise DuplicateKeyError(k)
+        else:
+            d[k] = v
     return d
 
 
-def unique_map_by(fn: ta.Callable[[V], K], vs: ta.Iterable[V], *, identity: bool = False) -> ta.MutableMapping[K, V]:
-    return unique_map(((fn(v), v) for v in vs), identity=identity)
+def unique_map_by(
+        fn: ta.Callable[[V], K],
+        vs: ta.Iterable[V],
+        *,
+        identity: bool = False,
+        strict: bool = False,
+) -> ta.MutableMapping[K, V]:
+    return unique_map(
+        ((fn(v), v) for v in vs),
+        identity=identity,
+        strict=strict,
+    )
 
 
 def multi_map(kvs: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, list[V]]:

omlish/configs/strings.py

@@ -1,6 +1,8 @@
 """
 TODO:
  - reflecty generalized rewriter, obviously..
+ - env vars
+ - coalescing - {$FOO|$BAR|baz}
 """
 import collections.abc
 import typing as ta

omlish/dataclasses/__init__.py

@@ -36,6 +36,11 @@ from .impl.as_ import (  # noqa
     astuple,
 )
 
+from .impl.params import (  # noqa
+    FieldExtras,
+    get_field_extras,
+)
+
 from .impl.replace import (  # noqa
     replace,
 )
@@ -85,8 +90,10 @@ from .impl.reflect import (  # noqa
 
 from .utils import (  # noqa
     chain_metadata,
+    deep_replace,
     field_modifier,
     maybe_post_init,
     opt_repr,
+    update_field_extras,
     update_field_metadata,
 )

omlish/dataclasses/impl/descriptors.py

@@ -0,0 +1,95 @@
+import abc
+import dataclasses as dc
+import typing as ta
+
+from ... import defs
+
+
+class AbstractFieldDescriptor(abc.ABC):
+
+    def __init__(
+            self,
+            *,
+            default: ta.Any = dc.MISSING,
+            frozen: bool = False,
+            name: str | None = None,
+            pre_set: ta.Callable[[ta.Any, ta.Any], ta.Any] | None = None,
+            post_set: ta.Callable[[ta.Any, ta.Any], None] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._default = default
+        self._frozen = frozen
+        self._name = name
+        self._pre_set = pre_set
+        self._post_set = post_set
+
+    defs.repr('name')
+    defs.getter('default', 'frozen', 'name', 'pre_set', 'post_set')
+
+    def __set_name__(self, owner, name):
+        if self._name is None:
+            self._name = name
+
+    def __get__(self, instance, owner=None):
+        if instance is not None:
+            try:
+                return self._get(instance)
+            except AttributeError:
+                pass
+        if self._default is not dc.MISSING:
+            return self._default
+        raise AttributeError(self._name)
+
+    @abc.abstractmethod
+    def _get(self, instance):
+        raise NotImplementedError
+
+    def __set__(self, instance, value):
+        if self._frozen:
+            raise dc.FrozenInstanceError(f'cannot assign to field {self._name!r}')
+        if self._pre_set is not None:
+            value = self._pre_set(instance, value)
+        self._set(instance, value)
+        if self._post_set is not None:
+            self._post_set(instance, value)
+
+    @abc.abstractmethod
+    def _set(self, instance, value):
+        raise NotImplementedError
+
+    def __delete__(self, instance):
+        if self._frozen:
+            raise dc.FrozenInstanceError(f'cannot delete field {self._name!r}')
+        self._del(instance)
+
+    @abc.abstractmethod
+    def _del(self, instance):
+        raise NotImplementedError
+
+
+class PyFieldDescriptor(AbstractFieldDescriptor):
+
+    def __init__(
+            self,
+            attr: str,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__(**kwargs)
+
+        self._attr = attr
+
+    defs.repr('attr', 'name')
+    defs.getter('attr')
+
+    def _get(self, instance):
+        return getattr(instance, self._attr)
+
+    def _set(self, instance, value):
+        setattr(instance, self._attr, value)
+
+    def _del(self, instance):
+        delattr(instance, self._attr)
+
+
+FieldDescriptor = PyFieldDescriptor

omlish/dataclasses/impl/reflect.py

@@ -149,7 +149,7 @@ class ClassInfo:
 
     @cached.property
     def generic_mro_lookup(self) -> ta.Mapping[type, rfl.Type]:
-        return col.unique_map((check.not_none(rfl.get_concrete_type(g)), g) for g in self.generic_mro)
+        return col.unique_map(((check.not_none(rfl.get_concrete_type(g)), g) for g in self.generic_mro), strict=True)
 
     @cached.property
     def generic_replaced_field_types(self) -> ta.Mapping[str, rfl.Type]:

omlish/dataclasses/utils.py

@@ -4,6 +4,9 @@ import types
 import typing as ta
 
 from .. import check
+from .impl.params import DEFAULT_FIELD_EXTRAS
+from .impl.params import FieldExtras
+from .impl.params import get_field_extras
 
 
 T = ta.TypeVar('T')
@@ -42,3 +45,23 @@ 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
+
+
+def update_field_extras(f: dc.Field, *, unless_non_default: bool = False, **kwargs: ta.Any) -> dc.Field:
+    fe = get_field_extras(f)
+    return update_field_metadata(f, {
+        FieldExtras: dc.replace(fe, **{
+            k: v
+            for k, v in kwargs.items()
+            if not unless_non_default or v != getattr(DEFAULT_FIELD_EXTRAS, k)
+        }),
+    })
+
+
+def deep_replace(o: T, *args: str | ta.Callable[[ta.Any], ta.Mapping[str, ta.Any]]) -> T:
+    if not args:
+        return o
+    elif len(args) == 1:
+        return dc.replace(o, **args[0](o))  # type: ignore
+    else:
+        return dc.replace(o, **{args[0]: deep_replace(getattr(o, args[0]), *args[1:])})  # type: ignore

omlish/{lang/datetimes.py → datetimes.py}

@@ -1,5 +1,8 @@
+# ruff: noqa: UP007
+# @omlish-lite
 import datetime
 import re
+import typing as ta
 
 
 def to_seconds(value: datetime.timedelta) -> float:
@@ -18,8 +21,7 @@ def months_ago(date: datetime.date, num: int) -> datetime.date:
     return datetime.date(ago_year, ago_month, 1)
 
 
-def parse_date(s: str, tz: datetime.timezone | None = None) -> datetime.date:
-
+def parse_date(s: str, tz: ta.Optional[datetime.timezone] = None) -> datetime.date:
     if s.lower() in ['today', 'now']:
         return datetime.datetime.now(tz=tz)
     elif s.lower() == 'yesterday':
@@ -39,7 +41,8 @@ _TIMEDELTA_STR_RE = re.compile(
     r'((?P<days>-?\d+)\s*days?,\s*)?'
     r'(?P<hours>\d?\d):(?P<minutes>\d\d)'
     r':(?P<seconds>\d\d+(\.\d+)?)'
-    r'\s*$')
+    r'\s*$',
+)
 
 
 _TIMEDELTA_DHMS_RE = re.compile(
@@ -49,7 +52,8 @@ _TIMEDELTA_DHMS_RE = re.compile(
     r',?\s*((?P<hours>\d+(\.\d+)?)\s*(h|hours?))?'
     r',?\s*((?P<minutes>\d+(\.\d+)?)\s*(m|minutes?))?'
     r',?\s*((?P<seconds>\d+(\.\d+)?)\s*(s|secs?|seconds?))?'
-    r'\s*$')
+    r'\s*$',
+)
 
 
 def parse_timedelta(s: str) -> datetime.timedelta:

omlish/diag/procfs.py

@@ -14,7 +14,7 @@ import typing as ta
 from .. import iterators as it
 from .. import lang
 from .. import os as oos
-from ..serde import json
+from ..formats import json
 from .procstats import ProcStats
 
 

omlish/diag/threads.py

@@ -9,6 +9,90 @@ import traceback
 import typing as ta
 
 
+##
+
+
+def dump_threads(out: ta.IO) -> None:
+    out.write('\n\n')
+
+    thrs_by_tid = {t.ident: t for t in threading.enumerate()}
+
+    for tid, fr in sys._current_frames().items():  # noqa
+        try:
+            thr = thrs_by_tid[tid]
+        except KeyError:
+            thr_rpr = repr(tid)
+        else:
+            thr_rpr = repr(thr)
+
+        tb = traceback.format_stack(fr)
+
+        out.write(f'{thr_rpr}\n')
+        out.write('\n'.join(l.strip() for l in tb))
+        out.write('\n\n')
+
+
+def dump_threads_str() -> str:
+    out = io.StringIO()
+    dump_threads(out)
+    return out.getvalue()
+
+
+##
+
+
+class StoppableThread:
+    def __init__(
+            self,
+            fn: ta.Callable[[], None],
+            interval_s: float,
+            *,
+            tick_immediately: bool = False,
+            start: bool = False,
+            **kwargs: ta.Any,
+    ) -> None:
+        super().__init__()
+        self._fn = fn
+        self._interval_s = interval_s
+        self._tick_immediately = tick_immediately
+        self._thread = threading.Thread(target=self._loop, **kwargs)
+        self._stop_event = threading.Event()
+        if start:
+            self.start()
+
+    @property
+    def thread(self) -> threading.Thread:
+        return self._thread
+
+    @property
+    def ident(self) -> int | None:
+        return self._thread.ident
+
+    def start(self) -> None:
+        return self._thread.start()
+
+    def stop_nowait(self) -> None:
+        self._stop_event.set()
+
+    def stop_wait(self, timeout: float | None = None) -> None:
+        self.stop_nowait()
+        self._thread.join(timeout)
+
+    def _loop(self) -> None:
+        if self._tick_immediately:
+            self._fn()
+
+        while True:
+            self._stop_event.wait(self._interval_s)
+            if self._stop_event.is_set():
+                return
+
+            self._fn()
+
+
+##
+
+
 _DEBUG_THREAD_COUNTER = itertools.count()
 
 
@@ -18,47 +102,23 @@ def create_thread_dump_thread(
         out: ta.TextIO = sys.stderr,
         start: bool = False,
         nodaemon: bool = False,
-) -> threading.Thread:
-    def dump():
-        cthr = threading.current_thread()
-        thrs_by_tid = {t.ident: t for t in threading.enumerate()}
-
-        buf = io.StringIO()
-        for tid, fr in sys._current_frames().items():  # noqa
-            if tid == cthr.ident:
-                continue
-
-            try:
-                thr = thrs_by_tid[tid]
-            except KeyError:
-                thr_rpr = repr(tid)
-            else:
-                thr_rpr = repr(thr)
-
-            tb = traceback.format_stack(fr)
-
-            buf.write(f'{thr_rpr}\n')
-            buf.write('\n'.join(l.strip() for l in tb))
-            buf.write('\n\n')
+) -> StoppableThread:
+    def proc() -> None:
+        try:
+            out.write(dump_threads_str())
+        except Exception as e:  # noqa
+            out.write(repr(e) + '\n\n')
 
-        out.write(buf.getvalue())
-
-    def proc():
-        while True:
-            time.sleep(interval_s)
-            try:
-                dump()
-            except Exception as e:  # noqa
-                out.write(repr(e) + '\n\n')
-
-    dthr = threading.Thread(
-        target=proc,
+    return StoppableThread(
+        proc,
+        interval_s,
         daemon=not nodaemon,
         name=f'thread-dump-thread-{next(_DEBUG_THREAD_COUNTER)}',
+        start=start,
     )
-    if start:
-        dthr.start()
-    return dthr
+
+
+##
 
 
 def create_suicide_thread(
@@ -67,20 +127,43 @@ def create_suicide_thread(
         interval_s: float = 1.,
         parent_thread: threading.Thread | None = None,
         start: bool = False,
-) -> threading.Thread:
+) -> StoppableThread:
+    """Kills process when parent_thread dies."""
+
     if parent_thread is None:
         parent_thread = threading.current_thread()
 
-    def proc():
-        while True:
-            parent_thread.join(interval_s)
-            if not parent_thread.is_alive():
-                os.kill(os.getpid(), sig)
+    def proc() -> None:
+        if not parent_thread.is_alive():
+            os.kill(os.getpid(), sig)
 
-    dthr = threading.Thread(
-        target=proc,
+    return StoppableThread(
+        proc,
+        interval_s,
         name=f'suicide-thread-{next(_DEBUG_THREAD_COUNTER)}',
+        start=start,
+    )
+
+
+##
+
+
+def create_timebomb_thread(
+        delay_s: float,
+        *,
+        sig: int = signal.SIGKILL,
+        interval_s: float = 1.,
+        start: bool = False,
+) -> StoppableThread:
+    def proc() -> None:
+        if time.time() >= deadline:
+            os.kill(os.getpid(), sig)
+
+    deadline = time.time() + delay_s
+
+    return StoppableThread(
+        proc,
+        interval_s,
+        name=f'timebomb-thread-{next(_DEBUG_THREAD_COUNTER)}',
+        start=start,
     )
-    if start:
-        dthr.start()
-    return dthr

omlish/docker.py

@@ -18,13 +18,14 @@ import datetime
 import re
 import shlex
 import subprocess
+import sys
 import typing as ta
 
 from . import check
 from . import dataclasses as dc
 from . import lang
 from . import marshal as msh
-from .serde import json
+from .formats import json
 
 
 if ta.TYPE_CHECKING:
@@ -168,3 +169,17 @@ def timebomb_payload(delay_s: float, name: str = 'omlish-docker-timebomb') -> st
         'sh -c \'killall5 -9 -o $PPID -o $$ ; kill 1\''
         ') &'
     )
+
+
+##
+
+
+_LIKELY_IN_DOCKER_PATTERN = re.compile(r'^overlay / .*/docker/')
+
+
+def is_likely_in_docker() -> bool:
+    if sys.platform != 'linux':
+        return False
+    with open('/proc/mounts') as f:  # type: ignore
+        ls = f.readlines()
+    return any(_LIKELY_IN_DOCKER_PATTERN.match(l) for l in ls)

omlish/fnpairs.py

@@ -4,11 +4,7 @@ TODO:
   - csv
   - csvloader
   - cbor
-  - cloudpickle
   - alt json backends
- - compression
-  - snappy
-  - lz4
  - wrapped (wait for usecase)
 """
 import abc

omlish/{serde → formats}/dotenv.py

@@ -20,6 +20,7 @@
 # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# https://github.com/theskumar/python-dotenv/tree/4d505f2c9bc3569791e64bca0f2e4300f43df0e0/src/dotenv
 import abc
 import codecs
 import contextlib
@@ -544,6 +545,7 @@ def dotenv_values(
     verbose: bool = False,
     interpolate: bool = True,
     encoding: str | None = 'utf-8',
+    env: ta.Mapping[str, str] | None = None,
 ) -> dict[str, str | None]:
     """
     Parse a .env file and return its content as a dict.
@@ -571,4 +573,5 @@ def dotenv_values(
         interpolate=interpolate,
         override=True,
         encoding=encoding,
+        env=env,
     ).dict()

omlish/{serde → formats}/yaml.py

@@ -136,7 +136,7 @@ class _cached_class_property:  # noqa
     def __set_name__(self, owner, name):
         self._attr = '_' + name
 
-    def __get__(self, instance, owner):
+    def __get__(self, instance, owner=None):
         if owner is None:
             if instance is None:
                 raise RuntimeError
@@ -152,7 +152,7 @@ class _cached_class_property:  # noqa
 class WrappedLoaders(lang.Namespace):
 
     @staticmethod
-    def _wrap(cls):
+    def _wrap(cls):  # noqa
         return type('NodeWrapping$' + cls.__name__, (NodeWrappingConstructorMixin, cls), {})
 
     Base: type['yaml.BaseLoader'] = _cached_class_property(lambda cls: cls._wrap(yaml.BaseLoader))  # type: ignore

omlish/graphs/trees.py

@@ -190,7 +190,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         e: ta.Any
         d: ta.Any
         if identity:
-            e, d = id, col.unique_map((id(n), n) for n, _ in pairs)
+            e, d = id, col.unique_map(((id(n), n) for n, _ in pairs), strict=True)
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}

omlish/http/consts.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - import mimetypes lol
+"""
 import base64
 import http
 
@@ -46,6 +50,8 @@ CONTENT_TYPE_ICON = b'image/x-icon'
 CONTENT_TYPE_JSON = b'application/json'
 CONTENT_TYPE_JSON_UTF8 = b'; '.join([CONTENT_TYPE_JSON, CONTENT_CHARSET_UTF8])
 
+CONTENT_TYPE_PNG = b'image/png'
+
 CONTENT_TYPE_TEXT = b'text/plain'
 CONTENT_TYPE_TEXT_UTF8 = b'; '.join([CONTENT_TYPE_TEXT, CONTENT_CHARSET_UTF8])
 

omlish/http/sessions.py

@@ -45,7 +45,7 @@ def bytes_to_int(bytestr: bytes) -> int:
 class Signer:
     @dc.dataclass(frozen=True)
     class Config:
-        secret_key: str | sec.Secret = dc.field()
+        secret_key: str | sec.SecretRef = dc.field()
         salt: str = 'cookie-session'
 
     def __init__(
@@ -65,7 +65,7 @@ class Signer:
 
     @lang.cached_function
     def derive_key(self) -> bytes:
-        mac = hmac.new(self._secrets.fix(self._config.secret_key).encode(), digestmod=self.digest())
+        mac = hmac.new(self._secrets.fix(self._config.secret_key).reveal().encode(), digestmod=self.digest())
         mac.update(self._config.salt.encode())
         return mac.digest()
 

omlish/inject/__init__.py

@@ -117,3 +117,7 @@ from .types import (  # noqa
     Tag,
     Unscoped,
 )
+
+from .utils import (  # noqa
+    ConstFn,
+)

omlish/inject/binder.py

@@ -87,14 +87,14 @@ def bind(
         *,
         tag: ta.Any = None,
 
-        in_: Scope | None = None,
-        singleton: bool = False,
-
         to_fn: ta.Any = None,
         to_ctor: ta.Any = None,
         to_const: ta.Any = None,
         to_key: ta.Any = None,
 
+        in_: Scope | None = None,
+        singleton: bool = False,
+
         eager: bool = False,
         expose: bool = False,
 ) -> Element | Elements: