omlish 0.0.0.dev283__py3-none-any.whl → 0.0.0.dev285__py3-none-any.whl

omlish/dataclasses/{static.py → tools/static.py}

@@ -8,9 +8,9 @@ import copy
 import dataclasses as dc
 import typing as ta
 
-from .. import lang
-from ..lite.dataclasses import is_immediate_dataclass
-from .impl.api import dataclass
+from ... import lang
+from ...lite.dataclasses import is_immediate_dataclass
+from ..api.classes.decorator import dataclass
 
 
 ##
@@ -122,6 +122,27 @@ class Static(lang.Abstract):
                     # Use a default_factory to allow unsafe (mutable) values.
                     new_fld.default_factory = (lambda v2: lambda: v2)(v)  # noqa
 
+                # FIXME
+                from ..api.fields.metadata import _ExtraFieldParamsMetadata  # noqa
+                from ..specs import FieldSpec
+                try:
+                    x_fs = fld.metadata[FieldSpec]
+                except KeyError:
+                    pass
+                else:
+                    n_md = {
+                        k: v
+                        for k, v in fld.metadata.items()
+                        if k not in (FieldSpec, _ExtraFieldParamsMetadata)
+                    }
+                    n_md[_ExtraFieldParamsMetadata] = {
+                        fs_f.name: getattr(x_fs, fs_f.name)
+                        for fs_f in dc.fields(FieldSpec)  # noqa
+                        if fs_f not in dc.Field.__slots__  # type: ignore[attr-defined]
+                        and fs_f.name not in ('default', 'default_factory')
+                    }
+                    new_fld.metadata = n_md  # type: ignore[assignment]
+
                 setattr(cls, fld.name, new_fld)
                 new_anns[fld.name] = fld.type
 
@@ -144,7 +165,7 @@ class Static(lang.Abstract):
                     )
 
         # Explicitly forbid dc transforms that rebuild the class, such as slots.
-        if (dc_cls := dataclass(cls, frozen=True)) is not cls:
+        if (dc_cls := dataclass(frozen=True)(cls)) is not cls:
             raise TypeError(dc_cls)
 
         dc_flds = dc.fields(cls)  # type: ignore[arg-type]  # noqa

omlish/dataclasses/utils.py

@@ -1,153 +1,98 @@
+import ast
 import collections
-import dataclasses as dc
+import functools
 import types
 import typing as ta
 
 from .. import check
-from .impl.metadata import METADATA_ATTR
-from .impl.metadata import UserMetadata
-from .impl.params import DEFAULT_FIELD_EXTRAS
-from .impl.params import FieldExtras
-from .impl.params import get_field_extras
 
 
 T = ta.TypeVar('T')
 
-
-##
-
-
-def opt_repr(o: ta.Any) -> str | None:
-    return repr(o) if o is not None else None
-
-
-def truthy_repr(o: ta.Any) -> str | None:
-    return repr(o) if o else None
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
 
 
 ##
 
 
-def fields_dict(cls_or_instance: ta.Any) -> dict[str, dc.Field]:
-    return {f.name: f for f in dc.fields(cls_or_instance)}
+def repr_round_trip_value(v: T) -> T:
+    r = repr(v)
+    v2 = ast.literal_eval(r)
+    if v != v2:
+        raise ValueError(v)
+    return v2
 
 
 ##
 
 
-class field_modifier:  # noqa
-    def __init__(self, fn: ta.Callable[[dc.Field], dc.Field]) -> None:
-        super().__init__()
-        self.fn = fn
+def set_qualname(cls: type, value: T) -> T:
+    if isinstance(value, types.FunctionType):
+        value.__qualname__ = f'{cls.__qualname__}.{value.__name__}'
+    return value
 
-    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 set_new_attribute(cls: type, name: str, value: ta.Any) -> bool:
+    if name in cls.__dict__:
+        return True
+    set_qualname(cls, value)
+    setattr(cls, name, value)
+    return False
 
 
-def chain_metadata(*mds: ta.Mapping) -> types.MappingProxyType:
-    return types.MappingProxyType(collections.ChainMap(*mds))  # type: ignore  # noqa
+##
 
 
-def update_class_metadata(cls: type[T], *args: ta.Any) -> type[T]:
-    check.isinstance(cls, type)
-    setattr(cls, METADATA_ATTR, md := getattr(cls, METADATA_ATTR, {}))
-    md.setdefault(UserMetadata, []).extend(args)
-    return cls
+class SealableRegistry(ta.Generic[K, V]):
+    def __init__(self) -> None:
+        super().__init__()
 
+        self._dct: dict[K, V] = {}
+        self._sealed = False
 
-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 seal(self) -> None:
+        self._sealed = True
 
+    def __setitem__(self, k: K, v: V) -> None:
+        check.state(not self._sealed)
+        check.not_in(k, self._dct)
+        self._dct[k] = v
 
-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 __getitem__(self, k: K) -> V:
+        self.seal()
+        return self._dct[k]
 
+    def items(self) -> ta.Iterator[tuple[K, V]]:
+        self.seal()
+        return iter(self._dct.items())
 
-def update_fields(
-        fn: ta.Callable[[str, dc.Field], dc.Field],
-        fields: ta.Iterable[str] | None = None,
-) -> ta.Callable[[type[T]], type[T]]:
-    def inner(cls):
-        if fields is None:
-            for a, v in list(cls.__dict__.items()):
-                if isinstance(v, dc.Field):
-                    setattr(cls, a, fn(a, v))
 
-        else:
-            for a in fields:
-                try:
-                    v = cls.__dict__[a]
-                except KeyError:
-                    v = dc.field()
-                else:
-                    if not isinstance(v, dc.Field):
-                        v = dc.field(default=v)
-                setattr(cls, a, fn(a, v))
+##
 
-        return cls
 
-    check.not_isinstance(fields, str)
+def class_decorator(fn):
+    @functools.wraps(fn)
+    def inner(cls=None, *args, **kwargs):
+        if cls is None:
+            return lambda cls: fn(cls, *args, **kwargs)  # noqa
+        return fn(cls, *args, **kwargs)
     return inner
 
 
-def update_fields_metadata(
-        nmd: ta.Mapping,
-        fields: ta.Iterable[str] | None = None,
-) -> ta.Callable[[type[T]], type[T]]:
-    def inner(a: str, f: dc.Field) -> dc.Field:
-        return update_field_metadata(f, nmd)
-
-    return update_fields(inner, fields)
-
-
 ##
 
 
-def shallow_astuple(o: ta.Any) -> tuple[ta.Any, ...]:
-    return tuple(getattr(o, f.name) for f in dc.fields(o))
+_EMPTY_MAPPING_PROXY: ta.Mapping = types.MappingProxyType({})
 
 
-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
-    elif len(args) == 1:
-        return dc.replace(o, **args[0](o))  # type: ignore
+def chain_mapping_proxy(*ms: ta.Mapping) -> types.MappingProxyType:
+    m: ta.Any
+    if len(ms) > 1:
+        m = collections.ChainMap(*ms)  # type: ignore[arg-type]
+    elif ms:
+        [m] = ms
     else:
-        return dc.replace(o, **{args[0]: deep_replace(getattr(o, args[0]), *args[1:])})  # type: ignore
-
-
-##
-
-
-def iter_items(obj: ta.Any) -> ta.Iterator[tuple[str, ta.Any]]:
-    for f in dc.fields(obj):
-        yield (f.name, getattr(obj, f.name))
-
-
-def iter_keys(obj: ta.Any) -> ta.Iterator[str]:
-    for f in dc.fields(obj):
-        yield f.name
-
+        m = _EMPTY_MAPPING_PROXY
 
-def iter_values(obj: ta.Any) -> ta.Iterator[ta.Any]:
-    for f in dc.fields(obj):
-        yield getattr(obj, f.name)
+    return types.MappingProxyType(m)

omlish/diag/__init__.py

@@ -17,10 +17,10 @@ Debuggers
 
 CPU Profilers
  - cProfile - https://docs.python.org/3/library/profile.html
- - pyinstrument - https://github.com/joerick/pyinstrument
- - py-pspy - https://github.com/benfred/py-spy
- - austin-dist - https://github.com/P403n1x87/austin
- - yappi - https://github.com/sumerc/yappi
+ - yappi - https://github.com/sumerc/yappi - tracing
+ - pyinstrument - https://github.com/joerick/pyinstrument - pretty
+ - py-spy - https://github.com/benfred/py-spy - busted on mac
+ - austin-dist - https://github.com/P403n1x87/austin - old
 
 Memory Profilers
  - tracemalloc - https://docs.python.org/3/library/tracemalloc.html

omlish/inject/bindings.py

@@ -12,7 +12,7 @@ from .types import Unscoped
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Binding(Element, lang.Final):
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))
     provider: Provider = dc.xfield(coerce=check.of_isinstance(Provider))

omlish/inject/eagers.py

@@ -13,6 +13,6 @@ from .keys import Key
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Eager(Element, lang.Final):
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/impl/bindings.py

@@ -11,7 +11,7 @@ from .providers import ProviderImpl
 
 
 @dc.dataclass(frozen=True, eq=False)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class BindingImpl(lang.Final):
     key: Key
     provider: ProviderImpl

omlish/inject/impl/origins.py

@@ -26,7 +26,7 @@ ORIGIN_IGNORED_PACKAGES = frozenset([
     lang.functions.__name__,
 
     dc.__name__,
-    dc.impl.__name__,  # noqa
+    *[m for m in sys.modules if m.startswith(dc.__name__ + '.')],
 ])
 
 

omlish/inject/keys.py

@@ -14,7 +14,7 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Key(lang.Final, ta.Generic[T]):
     ty: rfl.Type = dc.xfield(coerce=rfl.type_)
 

omlish/inject/listeners.py

@@ -20,7 +20,7 @@ ProvisionListener: ta.TypeAlias = ta.Callable[[
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class ProvisionListenerBinding(Element, lang.Final):
     listener: ProvisionListener
 

omlish/inject/multis.py

@@ -30,14 +30,14 @@ def _check_set_multi_key(mk: Key) -> bool:
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class SetBinding(Element, lang.Final):
     multi_key: Key = dc.xfield(validate=_check_set_multi_key)
     dst: Key = dc.xfield(coerce=check.of_isinstance(Key))
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class SetProvider(Provider):
     multi_key: Key = dc.xfield(validate=_check_set_multi_key)
 
@@ -50,7 +50,7 @@ def _check_map_multi_key(mk: Key) -> bool:
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class MapBinding(Element, lang.Final):
     multi_key: Key = dc.xfield(validate=_check_map_multi_key)
     map_key: ta.Any = dc.xfield()
@@ -58,7 +58,7 @@ class MapBinding(Element, lang.Final):
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class MapProvider(Provider):
     multi_key: Key = dc.xfield(validate=_check_map_multi_key)
 

omlish/inject/origins.py

@@ -12,13 +12,13 @@ T = ta.TypeVar('T')
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Origin:
     lst: ta.Sequence[str]
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Origins:
     lst: ta.Sequence[Origin]
 

omlish/inject/overrides.py

@@ -12,7 +12,7 @@ from .elements import as_elements
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Overrides(Element, lang.Final):
     ovr: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
     src: Elements = dc.xfield(coerce=check.of_isinstance(Elements))

omlish/inject/privates.py

@@ -13,13 +13,13 @@ from .keys import as_key
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Expose(Element, lang.Final):
     key: Key = dc.xfield(coerce=as_key)
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class Private(Element, lang.Final):
     elements: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
 

omlish/inject/providers.py

@@ -18,24 +18,24 @@ class Provider(lang.Abstract):
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class FnProvider(Provider):
     fn: ta.Any = dc.xfield(validate=callable)
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class CtorProvider(Provider):
     ty: type = dc.xfield(coerce=check.of_isinstance(type))
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class ConstProvider(Provider):
     v: ta.Any
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class LinkProvider(Provider):
     k: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/scopes.py

@@ -27,7 +27,7 @@ SCOPE_ALIASES: dict[str, Scope] = {}
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class ScopeBinding(Element, lang.Final):
     scope: Scope = dc.xfield(coerce=check.of_isinstance(Scope))
 
@@ -60,7 +60,7 @@ SCOPE_ALIASES['thread'] = ThreadScope()
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class SeededScope(Scope, lang.Final):
     tag: ta.Any = dc.xfield(coerce=check.not_none)
 
@@ -71,7 +71,7 @@ class SeededScope(Scope, lang.Final):
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(cache_hash=True)
+@dc.extra_class_params(cache_hash=True)
 class ScopeSeededProvider(Provider):
     ss: SeededScope = dc.xfield(coerce=check.of_isinstance(SeededScope))
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/lang/__init__.py

@@ -166,6 +166,7 @@ from .generators import (  # noqa
 )
 
 from .imports import (  # noqa
+    LazyGlobals,
     can_import,
     get_real_module_name,
     import_all,
@@ -201,11 +202,9 @@ from .maybes import (  # noqa
 )
 
 from .objects import (  # noqa
-    AttrRepr,
     SimpleProxy,
     anon_object,
     arg_repr,
-    attr_repr,
     can_weakref,
     deep_subclasses,
     dir_dict,
@@ -304,6 +303,11 @@ from ..lite.imports import (  # noqa
     import_module_attr,
 )
 
+from ..lite.reprs import (  # noqa
+    AttrRepr,
+    attr_repr,
+)
+
 from ..lite.timeouts import (  # noqa
     DeadlineTimeout,
     InfiniteTimeout,

omlish/lang/cached/function.py

@@ -1,6 +1,10 @@
 """
 TODO:
+ - !!! lighter weight bound methods
+  - keymaker overhead less important than not rebuilding a whole dc every __get__ on a new instance
  - !! specialize nullary, explicit kwarg
+ - !! use c-backed functools.cache if possible
+  - also just riic
  - !! reconcile A().f() with A.f(A())
   - unbound descriptor *should* still hit instance cache
  - integrate / expose with collections.cache
@@ -10,6 +14,7 @@ TODO:
   - 'staticmethod' or effective equiv - which must resolve to the shared instance
    - and must be transient?
  - use __transient_dict__ to support common state nuking
+ - use __set_name__ ?
 """
 import dataclasses as dc
 import functools
@@ -146,11 +151,12 @@ def _make_cache_key_maker(
 
 
 class _CachedFunction(ta.Generic[T], Abstract):
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class Opts:
         map_maker: ta.Callable[[], ta.MutableMapping] = dict
         lock: DefaultLockable = None
         transient: bool = False
+        no_wrapper_update: bool = False
 
     def __init__(
             self,
@@ -170,7 +176,8 @@ class _CachedFunction(ta.Generic[T], Abstract):
         self._lock = default_lock(opts.lock, False)() if opts.lock is not None else None
         self._values = values if values is not None else opts.map_maker()
         self._value_fn = value_fn if value_fn is not None else fn
-        functools.update_wrapper(self, fn)
+        if not self._opts.no_wrapper_update:
+            functools.update_wrapper(self, fn)
 
     @property
     def _fn(self):
@@ -353,10 +360,14 @@ class _DescriptorCachedFunction(_CachedFunction[T]):
 def cached_function(fn=None, **kwargs):  # noqa
     if fn is None:
         return functools.partial(cached_function, **kwargs)
+
     opts = _CachedFunction.Opts(**kwargs)
+
     if isinstance(fn, staticmethod):
         return _FreeCachedFunction(fn, opts=opts, value_fn=unwrap_func(fn))
+
     scope = classmethod if isinstance(fn, classmethod) else None
+
     return _DescriptorCachedFunction(fn, scope, opts=opts)
 
 

omlish/lang/cached/property.py

@@ -112,7 +112,9 @@ class _TransientCachedProperty(_CachedProperty):
 def cached_property(fn=None, *, transient=False, **kwargs):  # noqa
     if fn is None:
         return functools.partial(cached_property, transient=transient, **kwargs)
-    if transient:
+
+    elif transient:
         return _TransientCachedProperty(fn, **kwargs)
+
     else:
         return _DictCachedProperty(fn, **kwargs)