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

omlish/asyncs/trio_asyncio.py

@@ -3,12 +3,16 @@ import typing as ta
 
 from .. import lang
 
+
 if ta.TYPE_CHECKING:
     import asyncio
+
     import sniffio
     import trio_asyncio
+
 else:
     asyncio = lang.proxy_import('asyncio')
+
     sniffio = lang.proxy_import('sniffio')
     trio_asyncio = lang.proxy_import('trio_asyncio')
 
@@ -18,24 +22,30 @@ def check_trio_asyncio() -> None:
         raise RuntimeError('trio_asyncio loop not running')
 
 
-def with_trio_asyncio_loop(fn, *, wait=False):
-    @functools.wraps(fn)
-    async def inner(*args, **kwargs):
-        if trio_asyncio.current_loop.get() is not None:
-            await fn(*args, **kwargs)
-            return
-
-        if sniffio.current_async_library() != 'trio':
-            raise RuntimeError('trio loop not running')
+def with_trio_asyncio_loop(*, wait=False, strict=False):
+    def outer(fn):
+        @functools.wraps(fn)
+        async def inner(*args, **kwargs):
+            if trio_asyncio.current_loop.get() is not None:
+                await fn(*args, **kwargs)
+                return
 
-        loop: asyncio.BaseEventLoop
-        async with trio_asyncio.open_loop() as loop:
-            try:
+            if sniffio.current_async_library() != 'trio':
+                if strict:
+                    raise RuntimeError('trio loop not running')
                 await fn(*args, **kwargs)
-            finally:
-                if wait:
-                    # FIXME: lol
-                    while asyncio.all_tasks(loop):
-                        await asyncio.sleep(.2)
+                return
+
+            loop: asyncio.BaseEventLoop
+            async with trio_asyncio.open_loop() as loop:
+                try:
+                    await fn(*args, **kwargs)
+                finally:
+                    if wait:
+                        # FIXME: lol
+                        while asyncio.all_tasks(loop):
+                            await asyncio.sleep(.1)
+
+        return inner
 
-    return inner
+    return outer

omlish/c3.py

@@ -144,7 +144,7 @@ def compose_mro(
 
     # Remove entries which are strict bases of other entries (they will end up in the MRO anyway.
     def is_strict_base(typ):
-        for other in types:
+        for other in types:  # noqa
             if typ != other and typ in (get_mro(other) or []):
                 return True
         return False

omlish/cached.py

@@ -1,6 +1,5 @@
-from .lang.cached import cached_function
 from .lang.cached import _CachedProperty  # noqa
-
+from .lang.cached import cached_function
 
 function = cached_function
 

omlish/collections/__init__.py

@@ -37,6 +37,7 @@ from .identity import (  # noqa
     IdentityKeyDict,
     IdentitySet,
     IdentityWrapper,
+    IdentityWeakSet,
 )
 
 from .indexed import (  # noqa
@@ -90,9 +91,12 @@ from .utils import (  # noqa
     all_not_equal,
     indexes,
     key_cmp,
+    multi_map,
+    multi_map_by,
     mut_toposort,
     partition,
     toposort,
     unique,
-    unique_dict,
+    unique_map,
+    unique_map_by,
 )

omlish/collections/cache/impl.py

@@ -55,7 +55,7 @@ class CacheImpl(Cache[K, V]):
         if not ta.TYPE_CHECKING:
             from ..._ext.cy.collections.cache import CacheLink as Link
         else:
-            raise ImportError
+            raise ImportError  # noqa
 
     except ImportError:
         class Link:

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/indexed.py

@@ -1,7 +1,7 @@
 import typing as ta
 
-from .identity import IdentitySet
 from .identity import IdentityKeyDict
+from .identity import IdentitySet
 
 
 T = ta.TypeVar('T')

omlish/collections/utils.py

@@ -12,6 +12,9 @@ K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
 
+##
+
+
 def mut_toposort(data: dict[T, set[T]]) -> ta.Iterator[set[T]]:
     for k, v in data.items():
         v.discard(k)
@@ -31,6 +34,9 @@ def toposort(data: ta.Mapping[T, ta.AbstractSet[T]]) -> ta.Iterator[set[T]]:
     return mut_toposort({k: set(v) for k, v in data.items()})
 
 
+##
+
+
 def partition(items: ta.Iterable[T], pred: ta.Callable[[T], bool]) -> tuple[list[T], list[T]]:
     t: list[T] = []
     f: list[T] = []
@@ -54,13 +60,36 @@ def unique(it: ta.Iterable[T], *, identity: bool = False) -> list[T]:
     return ret
 
 
-def unique_dict(items: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, V]:
-    dct: ta.MutableMapping[K, V] = IdentityKeyDict() if identity else {}
-    for k, v in items:
-        if k in dct:
+def unique_map(kvs: ta.Iterable[tuple[K, V]], *, identity: 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)
-        dct[k] = v
-    return dct
+        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 multi_map(kvs: ta.Iterable[tuple[K, V]], *, identity: bool = False) -> ta.MutableMapping[K, list[V]]:
+    d: ta.MutableMapping[K, list[V]] = IdentityKeyDict() if identity else {}
+    l: list[V]
+    for k, v in kvs:
+        try:
+            l = d[k]
+        except KeyError:
+            l = d[k] = []
+        l.append(v)
+    return d
+
+
+def multi_map_by(fn: ta.Callable[[V], K], vs: ta.Iterable[V], *, identity: bool = False) -> ta.MutableMapping[K, list[V]]:  # noqa
+    return multi_map(((fn(v), v) for v in vs), identity=identity)
+
+
+##
 
 
 def all_equal(it: ta.Iterable[T]) -> bool:
@@ -81,6 +110,9 @@ def all_not_equal(it: ta.Iterable[T]) -> bool:
     return True
 
 
+##
+
+
 def key_cmp(fn: ta.Callable[[K, K], int]) -> ta.Callable[[tuple[K, V], tuple[K, V]], int]:
     return lambda t0, t1: fn(t0[0], t1[0])
 

omlish/configs/__init__.py

@@ -0,0 +1,5 @@
+from .classes import (  # noqa
+    Config,
+    Configurable,
+    get_impl,
+)

omlish/configs/classes.py

@@ -0,0 +1,53 @@
+import typing as ta
+import weakref
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+
+
+class Config(
+    dc.Data,
+    lang.Abstract,
+    frozen=True,
+    reorder=True,
+    confer=frozenset([
+        'frozen',
+        'reorder',
+        'confer',
+    ]),
+):
+    pass
+
+
+ConfigT = ta.TypeVar('ConfigT', bound='Config')
+
+_CONFIG_CLS_MAP: ta.MutableMapping[type[Config], type['Configurable']] = weakref.WeakValueDictionary()
+
+
+class Configurable(ta.Generic[ConfigT], lang.Abstract):
+
+    # FIXME: https://github.com/python/mypy/issues/5144
+    Config: ta.ClassVar[type[ConfigT]]  # type: ignore  # noqa
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        cfg_cls = check.issubclass(cls.__dict__['Config'], Config)
+        check.not_in(cfg_cls, _CONFIG_CLS_MAP)
+        _CONFIG_CLS_MAP[cfg_cls] = cls
+
+    def __init__(self, config: ConfigT) -> None:
+        super().__init__()
+
+        self._config: ConfigT = check.isinstance(config, self.Config)
+
+
+def get_impl(cfg: type[Config] | Config) -> type[Configurable]:
+    if isinstance(cfg, type):
+        cfg_cls = check.issubclass(cfg, Config)  # noqa
+    elif isinstance(cfg, Config):
+        cfg_cls = type(cfg)
+    else:
+        raise TypeError(cfg)
+    return _CONFIG_CLS_MAP[cfg_cls]

omlish/configs/strings.py

@@ -0,0 +1,94 @@
+"""
+TODO:
+ - reflecty generalized rewriter, obviously..
+"""
+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

@@ -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/api.py

@@ -34,7 +34,7 @@ def field(  # noqa
         check: ta.Callable[[ta.Any], bool] | None = None,
         check_type: bool | None = None,
         override: bool = False,
-        repr_fn: ta.Callable[[ta.Any], str | None] | None = None
+        repr_fn: ta.Callable[[ta.Any], str | None] | None = None,
 ):  # -> dc.Field
     if default is not MISSING and default_factory is not MISSING:
         raise ValueError('cannot specify both default and default_factory')

omlish/dataclasses/impl/as_.py

@@ -1,8 +1,8 @@
 import copy
 import dataclasses as dc
 
-from .internals import is_dataclass_instance
 from .internals import ATOMIC_TYPES
+from .internals import is_dataclass_instance
 
 
 def asdict(obj, *, dict_factory=dict):  # noqa

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

@@ -9,6 +9,7 @@ from .internals import is_classvar
 from .internals import is_initvar
 from .params import get_field_extras
 
+
 if ta.TYPE_CHECKING:
     from . import api
 else:
@@ -97,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,12 +4,13 @@ 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
-from .internals import FieldType
 from .internals import HAS_DEFAULT_FACTORY
 from .internals import POST_INIT_NAME
+from .internals import FieldType
 from .metadata import Check
 from .metadata import Init
 from .processing import Processor
@@ -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
@@ -24,6 +25,7 @@ from .simple import MatchArgsProcessor
 from .simple import OverridesProcessor
 from .slots import add_slots
 
+
 if ta.TYPE_CHECKING:
     from . import metaclass
 else:
@@ -136,6 +138,7 @@ class MainProcessor:
             DocProcessor,
             MatchArgsProcessor,
             ReplaceProcessor,
+            CopyProcessor,
         ]:
             pcls(self._info).process()
 

omlish/dataclasses/impl/metaclass.py

@@ -39,7 +39,12 @@ def confer_kwargs(
         for ck in bmp.confer:
             if ck in kwargs:
                 continue
-            if ck in ('frozen', 'generic_init', 'kw_only'):
+            if ck in (
+                    'frozen',
+                    'generic_init',
+                    'kw_only',
+                    'reorder',
+            ):
                 confer_kwarg(out, ck, get_params(base).frozen)
             elif ck == 'confer':
                 confer_kwarg(out, 'confer', bmp.confer)

omlish/dataclasses/impl/order.py

@@ -1,7 +1,7 @@
 import typing as ta
 
-from .utils import Namespace
 from .processing import Processor
+from .utils import Namespace
 from .utils import create_fn
 from .utils import set_new_attribute
 from .utils import tuple_str

omlish/dataclasses/impl/reflect.py

@@ -28,9 +28,22 @@ from .params import get_params_extras
 from .utils import Namespace
 
 
+try:
+    import annotationlib  # noqa
+except ImportError:
+    annotationlib = None
+
+
 MISSING = dc.MISSING
 
 
+def _get_annotations(obj):
+    if annotationlib is not None:
+        return annotationlib.get_annotations(obj, format=annotationlib.Format.FORWARDREF)  # noqa
+    else:
+        return inspect.get_annotations(obj)
+
+
 class ClassInfo:
 
     def __init__(self, cls: type, *, _constructing: bool = False) -> None:
@@ -54,7 +67,7 @@ class ClassInfo:
 
     @cached.property
     def cls_annotations(self) -> ta.Mapping[str, ta.Any]:
-        return inspect.get_annotations(self._cls)
+        return _get_annotations(self._cls)
 
     ##
 
@@ -136,7 +149,7 @@ class ClassInfo:
 
     @cached.property
     def generic_mro_lookup(self) -> ta.Mapping[type, rfl.Type]:
-        return col.unique_dict((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)
 
     @cached.property
     def generic_replaced_field_types(self) -> ta.Mapping[str, rfl.Type]: