omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev7__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,
@@ -37,6 +41,7 @@ from .identity import (  # noqa
     IdentityKeyDict,
     IdentitySet,
     IdentityWrapper,
+    IdentityWeakSet,
 )
 
 from .indexed import (  # noqa

omlish/collections/exceptions.py

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

omlish/collections/identity.py

@@ -1,6 +1,7 @@
 import contextlib
 import operator as op
 import typing as ta
+import weakref
 
 from .. import lang
 from .mappings import yield_dict_init
@@ -103,3 +104,9 @@ class IdentitySet(ta.MutableSet[T]):
 
     def __iter__(self) -> ta.Iterator[T]:
         return iter(self._dict.values())
+
+
+class IdentityWeakSet(weakref.WeakSet):
+    def __init__(self, init=None):
+        super().__init__()
+        self.data = IdentitySet(init)  # type: ignore

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

@@ -0,0 +1,96 @@
+"""
+TODO:
+ - reflecty generalized rewriter, obviously..
+ - env vars
+ - coalescing - {$FOO|$BAR|baz}
+"""
+import collections.abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from ..text import glyphsplit
+
+
+T = ta.TypeVar('T')
+
+
+class InterpolateStringsMetadata(lang.Marker):
+    pass
+
+
+@dc.field_modifier
+def secret_or_key_field(f: dc.Field) -> dc.Field:
+    return dc.update_field_metadata(f, {
+        InterpolateStringsMetadata: True,
+    })
+
+
+@dc.field_modifier
+def interpolate_field(f: dc.Field) -> dc.Field:
+    return dc.update_field_metadata(f, {InterpolateStringsMetadata: True})
+
+
+class StringRewriter:
+    def __init__(self, fn: ta.Callable[[str], str]) -> None:
+        super().__init__()
+        self._fn = fn
+
+    def __call__(self, v: T, *, _soft: bool = False) -> T:
+        if v is None:
+            return None  # type: ignore
+
+        if dc.is_dataclass(v):
+            kw = {}
+            for f in dc.fields(v):
+                fv = getattr(v, f.name)
+                nfv = self(fv, _soft=not f.metadata.get(InterpolateStringsMetadata))
+                if fv is not nfv:
+                    kw[f.name] = nfv
+            if not kw:
+                return v  # type: ignore
+            return dc.replace(v, **kw)
+
+        if isinstance(v, str):
+            if not _soft:
+                v = self._fn(v)  # type: ignore
+            return v  # type: ignore
+
+        if isinstance(v, lang.BUILTIN_SCALAR_ITERABLE_TYPES):
+            return v  # type: ignore
+
+        if isinstance(v, collections.abc.Mapping):
+            nm = []
+            b = False
+            for mk, mv in v.items():
+                nk, nv = self(mk, _soft=_soft), self(mv, _soft=_soft)
+                nm.append((nk, nv))
+                b |= nk is not mk or nv is not mv
+            if not b:
+                return v  # type: ignore
+            return v.__class__(nm)  # type: ignore
+
+        if isinstance(v, (collections.abc.Sequence, collections.abc.Set)):
+            nl = []
+            b = False
+            for le in v:
+                ne = self(le, _soft=_soft)
+                nl.append(ne)
+                b |= ne is not le
+            if not b:
+                return v  # type: ignore
+            return v.__class__(nl)  # type: ignore
+
+        return v
+
+
+def interpolate_strings(v: T, rpl: ta.Mapping[str, str]) -> T:
+    def fn(v):
+        if not v:
+            return v
+        sps = glyphsplit.split_braces(v)
+        if len(sps) == 1 and isinstance(sps[0], str):
+            return sps[0]
+        return ''.join(rpl[p.s] if isinstance(p, glyphsplit.GlyphMatch) else p for p in sps)
+
+    return StringRewriter(fn)(v)

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,
 )
@@ -55,6 +60,7 @@ globals()['make_dataclass'] = xmake_dataclass
 
 from .impl.exceptions import (  # noqa
     CheckError,
+    FieldCheckError,
 )
 
 from .impl.metaclass import (  # noqa
@@ -81,3 +87,13 @@ from .impl.reflect import (  # noqa
     ClassInfo,
     reflect,
 )
+
+from .utils import (  # noqa
+    chain_metadata,
+    deep_replace,
+    field_modifier,
+    maybe_post_init,
+    opt_repr,
+    update_field_extras,
+    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/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/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/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

@@ -0,0 +1,67 @@
+import collections
+import dataclasses as dc
+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')
+
+
+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
+
+
+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/__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 ..formats 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