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

omlish/lang/imports.py

@@ -3,6 +3,7 @@ TODO:
  - proxy_init 'as' alias support - attrs of (src, dst)
 """
 import contextlib
+import functools
 import importlib.util
 import sys
 import types
@@ -254,6 +255,64 @@ def _trigger_conditional_imports(package: str) -> None:
 ##
 
 
+class LazyGlobals:
+    def __init__(
+            self,
+            *,
+            globals: ta.MutableMapping[str, ta.Any] | None = None,  # noqa
+            update_globals: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self._globals = globals
+        self._update_globals = update_globals
+
+        self._attr_fns: dict[str, ta.Callable[[], ta.Any]] = {}
+
+    @classmethod
+    def install(cls, globals: ta.MutableMapping[str, ta.Any]) -> 'LazyGlobals':  # noqa
+        try:
+            xga = globals['__getattr__']
+        except KeyError:
+            pass
+        else:
+            if not isinstance(xga, cls):
+                raise RuntimeError(f'Module already has __getattr__ hook: {xga}')  # noqa
+            return xga
+
+        lm = cls(
+            globals=globals,
+            update_globals=True,
+        )
+
+        globals['__getattr__'] = lm
+
+        return lm
+
+    def set_fn(self, attr: str, fn: ta.Callable[[], ta.Any]) -> 'LazyGlobals':
+        self._attr_fns[attr] = fn
+        return self
+
+    def get(self, attr: str) -> ta.Any:
+        try:
+            fn = self._attr_fns[attr]
+        except KeyError:
+            raise AttributeError(attr) from None
+
+        val = fn()
+
+        if self._update_globals and self._globals is not None:
+            self._globals[attr] = val
+
+        return val
+
+    def __call__(self, attr: str) -> ta.Any:
+        return self.get(attr)
+
+
+##
+
+
 class NamePackage(ta.NamedTuple):
     name: str
     package: str
@@ -266,16 +325,13 @@ class _ProxyInit:
 
     def __init__(
             self,
+            lazy_globals: LazyGlobals,
             name_package: NamePackage,
-            *,
-            globals: ta.MutableMapping[str, ta.Any] | None = None,  # noqa
-            update_globals: bool = False,
     ) -> None:
         super().__init__()
 
+        self._lazy_globals = lazy_globals
         self._name_package = name_package
-        self._globals = globals
-        self._update_globals = update_globals
 
         self._imps_by_attr: dict[str, _ProxyInit._Import] = {}
         self._mods_by_pkgs: dict[str, ta.Any] = {}
@@ -287,13 +343,17 @@ class _ProxyInit:
     def add(self, package: str, attrs: ta.Iterable[str | tuple[str, str]]) -> None:
         if isinstance(attrs, str):
             raise TypeError(attrs)
+
         for attr in attrs:
             if isinstance(attr, tuple):
                 imp_attr, attr = attr
             else:
                 imp_attr = attr
+
             self._imps_by_attr[attr] = self._Import(package, imp_attr)
 
+            self._lazy_globals.set_fn(attr, functools.partial(self.get, attr))
+
     def get(self, attr: str) -> ta.Any:
         try:
             imp = self._imps_by_attr[attr]
@@ -307,9 +367,6 @@ class _ProxyInit:
 
         val = getattr(mod, imp.attr)
 
-        if self._update_globals and self._globals is not None:
-            self._globals[attr] = val
-
         return val
 
 
@@ -329,13 +386,14 @@ def proxy_init(
     pi: _ProxyInit
     try:
         pi = globals['__proxy_init__']
+
     except KeyError:
         pi = _ProxyInit(
+            LazyGlobals.install(globals),
             init_name_package,
-            globals=globals,
         )
         globals['__proxy_init__'] = pi
-        globals['__getattr__'] = pi.get
+
     else:
         if pi.name_package != init_name_package:
             raise Exception(f'Wrong init name: {pi.name_package=} != {init_name_package=}')

omlish/lang/objects.py

@@ -1,8 +1,3 @@
-"""
-TODO:
- - reprlib / recur guard (merge w/ defs.py)
-"""
-import dataclasses as dc
 import types
 import typing as ta
 import weakref
@@ -16,47 +11,6 @@ T = ta.TypeVar('T')
 ##
 
 
-@dc.dataclass(frozen=True)
-class AttrRepr:
-    attrs: ta.Sequence[str]
-
-    _: dc.KW_ONLY
-
-    with_module: bool = False
-    use_qualname: bool = False
-    with_id: bool = False
-    value_filter: ta.Callable[[ta.Any], bool] | None = None
-
-    @classmethod
-    def of(cls, *attrs: str, **kwargs: ta.Any) -> 'AttrRepr':
-        return cls(attrs, **kwargs)
-
-    def __call__(self, obj: ta.Any) -> str:
-        vs = ', '.join(
-            f'{attr}={v!r}'
-            for attr in self.attrs
-            for v in [getattr(obj, attr)]
-            if self.value_filter is None or self.value_filter(v)
-        )
-        return (
-            f'{obj.__class__.__module__ + "." if self.with_module else ""}'
-            f'{obj.__class__.__qualname__ if self.use_qualname else obj.__class__.__name__}'
-            f'{("@" + hex(id(obj))[2:]) if self.with_id else ""}'
-            f'({vs})'
-        )
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-        def __repr__(other):  # noqa
-            return self(other)
-        return __repr__.__get__(instance, owner)
-
-
-def attr_repr(obj: ta.Any, *attrs: str, **kwargs: ta.Any) -> str:
-    return AttrRepr(attrs, **kwargs)(obj)
-
-
 def arg_repr(*args: ta.Any, **kwargs: ta.Any) -> str:
     return ', '.join(*(
         list(map(repr, args)) +

omlish/lite/reprs.py

@@ -0,0 +1,84 @@
+# ruff: noqa: UP007
+import dataclasses as dc
+import typing as ta
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class AttrRepr:
+    attrs: ta.Sequence[str]
+
+    # _: dc.KW_ONLY
+
+    with_module: bool = False
+    use_qualname: bool = False
+    with_id: bool = False
+    value_filter: ta.Optional[ta.Callable[[ta.Any], bool]] = None
+    recursive: bool = False
+
+    @classmethod
+    def of(cls, *attrs: str, **kwargs: ta.Any) -> 'AttrRepr':
+        return cls(attrs, **kwargs)
+
+    #
+
+    def _build_(self, obj: ta.Any) -> str:
+        vs = ', '.join(
+            f'{attr}={v!r}'
+            for attr in self.attrs
+            for v in [getattr(obj, attr)]
+            if self.value_filter is None or self.value_filter(v)
+        )
+
+        return (
+            f'{obj.__class__.__module__ + "." if self.with_module else ""}'
+            f'{obj.__class__.__qualname__ if self.use_qualname else obj.__class__.__name__}'
+            f'{("@" + hex(id(obj))[2:]) if self.with_id else ""}'
+            f'({vs})'
+        )
+
+    _build: ta.ClassVar[ta.Callable[[ta.Any], str]]
+
+    def __call__(self, obj: ta.Any) -> str:
+        try:
+            build: ta.Any = self._build
+
+        except AttributeError:
+            build = self._build_
+            if self.recursive:
+                build = self._reprlib().recursive_repr()(build)
+            object.__setattr__(self, '_build', build)
+
+        return build(obj)
+
+    #
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+
+        def __repr__(other):  # noqa
+            return self(other)
+
+        return __repr__.__get__(instance, owner)
+
+    #
+
+    _reprlib_: ta.ClassVar[ta.Any]
+
+    @classmethod
+    def _reprlib(cls) -> ta.Any:
+        try:
+            return cls._reprlib_
+        except AttributeError:
+            pass
+
+        reprlib = __import__('reprlib')
+        cls._reprlib_ = reprlib
+        return reprlib
+
+
+def attr_repr(obj: ta.Any, *attrs: str, **kwargs: ta.Any) -> str:
+    return AttrRepr(attrs, **kwargs)(obj)

omlish/marshal/objects/dataclasses.py

@@ -34,11 +34,7 @@ from .unmarshal import ObjectUnmarshaler
 
 
 def get_dataclass_metadata(ty: type) -> ObjectMetadata:
-    return check.opt_single(
-        e
-        for e in dc.get_merged_metadata(ty).get(dc.UserMetadata, [])
-        if isinstance(e, ObjectMetadata)
-    ) or ObjectMetadata()
+    return check.single(dc.reflect(ty).spec.metadata_by_type.get(ObjectMetadata) or [ObjectMetadata()])
 
 
 def get_dataclass_field_infos(
@@ -50,7 +46,7 @@ def get_dataclass_field_infos(
 
     dc_md = get_dataclass_metadata(ty)
     dc_naming = dc_md.field_naming or opts.get(Naming)
-    dc_rf = dc.reflect(ty)
+    dc_rfl = dc.reflect(ty)
 
     fi_defaults = {
         k: v
@@ -66,7 +62,7 @@ def get_dataclass_field_infos(
     type_hints = ta.get_type_hints(ty)
 
     ret: list[FieldInfo] = []
-    for field in dc_rf.instance_fields:
+    for field in dc_rfl.instance_fields:
         if (f_naming := field.metadata.get(Naming, dc_naming)) is not None:
             um_name = translate_name(field.name, f_naming)
         else:
@@ -76,10 +72,10 @@ def get_dataclass_field_infos(
 
         f_ty: ta.Any
         if (
-                ((cpx := dc_rf.cls_params_extras) is not None and cpx.generic_init) or
+                dc_rfl.spec.generic_init or
                 (fmd is not None and fmd.options.generic_replace)
         ):
-            f_ty = rfl.to_annotation(dc_rf.generic_replaced_field_type(field.name))
+            f_ty = rfl.to_annotation(dc_rfl.fields_inspection.generic_replaced_field_type(field.name))
         else:
             f_ty = type_hints[field.name]
 

omlish/marshal/objects/helpers.py

@@ -14,7 +14,7 @@ T = ta.TypeVar('T')
 def update_field_metadata(**kwargs: ta.Any) -> dc.field_modifier:
     @dc.field_modifier
     def inner(f: dc.Field) -> dc.Field:
-        return dc.update_field_metadata(f, {
+        return dc.set_field_metadata(f, {
             FieldMetadata: f.metadata.get(FieldMetadata, FieldMetadata()).update(**kwargs),
         })
     return inner
@@ -25,7 +25,7 @@ def update_fields_metadata(
         **kwargs: ta.Any,
 ) -> ta.Callable[[type[T]], type[T]]:
     def inner(a: str, f: dc.Field) -> dc.Field:
-        return dc.update_field_metadata(f, {
+        return dc.set_field_metadata(f, {
             FieldMetadata: f.metadata.get(FieldMetadata, FieldMetadata()).update(**kwargs),
         })
 
@@ -37,7 +37,7 @@ def update_object_metadata(
         **kwargs: ta.Any,
 ):
     def inner(cls):
-        return dc.update_class_metadata(cls, ObjectMetadata(**kwargs))
+        return dc.append_class_metadata(cls, ObjectMetadata(**kwargs))
 
     if cls is not None:
         inner(cls)

omlish/secrets/marshal.py

@@ -44,7 +44,7 @@ class StrOrSecretRefMarshalerUnmarshaler(msh.Marshaler, msh.Unmarshaler):
 def marshal_secret_field(f: dc.Field) -> dc.Field:
     """Mostly obsolete with auto-registration below."""
 
-    return dc.update_field_metadata(f, {
+    return dc.set_field_metadata(f, {
         msh.FieldMetadata: dc.replace(
             f.metadata.get(msh.FieldMetadata, msh.FieldMetadata()),
             marshaler=StrOrSecretRefMarshalerUnmarshaler(),

omlish/secrets/secrets.py

@@ -79,7 +79,7 @@ def secret_repr(o: SecretRefOrStr | None) -> str | None:
 
 @dc.field_modifier
 def secret_field(f: dc.Field) -> dc.Field:
-    return dc.update_field_extras(
+    return dc.update_extra_field_params(
         f,
         repr_fn=secret_repr,
         unless_non_default=True,

omlish/sql/queries/base.py

@@ -29,7 +29,7 @@ class Node(
     lang.Abstract,
     eq=False,
     confer=frozenset([
-        *dc.get_metaclass_params(dc.Frozen).confer,
+        *dc.get_metaclass_spec(dc.Frozen).confer,
         'eq',
     ]),
 ):
@@ -61,10 +61,10 @@ class Node(
         except KeyError:
             pass
 
-        dc_info = dc.reflect(cls)
+        dc_rfl = dc.reflect(cls)
         fields = Node._Fields(
-            cmp_fields=tuple(f.name for f in dc_info.instance_fields if f.compare),
-            hash_fields=tuple(f.name for f in dc_info.instance_fields if (f.compare if f.hash is None else f.hash)),
+            cmp_fields=tuple(f.name for f in dc_rfl.instance_fields if f.compare),
+            hash_fields=tuple(f.name for f in dc_rfl.instance_fields if (f.compare if f.hash is None else f.hash)),
         )
 
         setattr(cls, '__node_fields__', fields)

omlish/text/mangle.py

@@ -1,6 +1,7 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
 import dataclasses as dc
+import re
 import typing as ta
 
 from ..lite.cached import cached_nullary
@@ -26,16 +27,74 @@ class StringMangler:
         check.not_in(self.escape, self.escaped)
         check.arg(len(set(self.escaped)) == len(self.escaped))
 
+    #
+
+    @cached_nullary
+    def replaced(self) -> ta.Tuple[str, ...]:
+        return (self.escape, *self.escaped)
+
+    @cached_nullary
+    def replaced_set(self) -> ta.FrozenSet[str]:
+        return frozenset(self.replaced())
+
+    @cached_nullary
+    def replaced_indexes(self) -> ta.Mapping[str, int]:
+        return {s: i for i, s in enumerate(self.replaced())}
+
+    @cached_nullary
+    def replaced_pat(self) -> re.Pattern:
+        return re.compile('|'.join(re.escape(k) for k in self.replaced()))
+
+    #
+
+    @cached_nullary
+    def replacement_pad(self) -> int:
+        return len('%x' % (len(self.replaced()),))  # noqa
+
     @cached_nullary
     def replacements(self) -> ta.Sequence[ta.Tuple[str, str]]:
-        return [(l, self.escape + str(i)) for i, l in enumerate([self.escape, *self.escaped])]
+        fmt = f'%0{self.replacement_pad()}x'
+        return [
+            (l, self.escape + fmt % (i,))
+            for i, l in enumerate(self.replaced())
+        ]
+
+    @cached_nullary
+    def replacements_dict(self) -> ta.Mapping[str, str]:
+        return dict(self.replacements())
+
+    @cached_nullary
+    def inverse_replacements_dict(self) -> ta.Mapping[str, str]:
+        return {v: k for k, v in self.replacements()}
+
+    @cached_nullary
+    def replacements_pat(self) -> re.Pattern:
+        return re.compile(''.join([re.escape(self.escape), '.' * self.replacement_pad()]))
+
+    #
+
+    # def mangle(self, s: str) -> str:
+    #     ecs = sorted(
+    #         frozenset(s) & self.replaced_set(),
+    #         key=self.replaced_indexes().__getitem__,
+    #         )
+    #     rd = self.replacements_dict()
+    #     for l in ecs:
+    #         r = rd[l]
+    #         s = s.replace(l, r)
+    #     return s
 
     def mangle(self, s: str) -> str:
-        for l, r in self.replacements():
-            s = s.replace(l, r)
-        return s
+        rd = self.replacements_dict()
+        return self.replaced_pat().sub(lambda m: rd[m.group(0)], s)
+
+    #
+
+    # def unmangle(self, s: str) -> str:
+    #     for l, r in reversed(self.replacements()):
+    #         s = s.replace(r, l)
+    #     return s
 
     def unmangle(self, s: str) -> str:
-        for l, r in reversed(self.replacements()):
-            s = s.replace(r, l)
-        return s
+        ird = self.inverse_replacements_dict()
+        return self.replacements_pat().sub(lambda m: ird[m.group(0)], s)

omlish/typedvalues/marshal.py

@@ -32,7 +32,7 @@ class TypedValueMarshalerFactory(msh.MarshalerFactoryMatchClass):
     ))
     def _build_scalar(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
         dc_rfl = dc.reflect(check.isinstance(rty, type))
-        v_rty = check.single(dc_rfl.generic_replaced_field_annotations.values())
+        v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
         v_m = ctx.make(v_rty)
         return msh.WrappedMarshaler(lambda _, o: o.v, v_m)
 
@@ -58,7 +58,7 @@ class TypedValueUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
     def _build_scalar(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
         rty = check.isinstance(rty, type)
         dc_rfl = dc.reflect(rty)
-        v_rty = check.single(dc_rfl.generic_replaced_field_annotations.values())
+        v_rty = check.single(dc_rfl.fields_inspection.generic_replaced_field_annotations.values())
         v_u = ctx.make(v_rty)
         return msh.WrappedUnmarshaler(lambda _, v: rty(v), v_u)
 

omlish/typedvalues/values.py

@@ -36,7 +36,7 @@ class UniqueTypedValue(TypedValue, lang.Abstract):
 
 
 @dc.dataclass(frozen=True)
-@dc.extra_params(generic_init=True)
+@dc.extra_class_params(generic_init=True)
 class ScalarTypedValue(TypedValue, lang.Abstract, ta.Generic[T]):
     v: T
 

{omlish-0.0.0.dev283.dist-info → omlish-0.0.0.dev285.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev283
+Version: 0.0.0.dev285
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -15,7 +15,7 @@ License-File: LICENSE
 Provides-Extra: all
 Requires-Dist: anyio~=4.9; extra == "all"
 Requires-Dist: sniffio~=1.3; extra == "all"
-Requires-Dist: greenlet~=3.1; extra == "all"
+Requires-Dist: greenlet~=3.2; extra == "all"
 Requires-Dist: trio~=0.29; extra == "all"
 Requires-Dist: trio-asyncio~=0.15; extra == "all"
 Requires-Dist: lz4~=4.4; extra == "all"
@@ -53,7 +53,7 @@ Requires-Dist: wrapt~=1.17; extra == "all"
 Provides-Extra: async
 Requires-Dist: anyio~=4.9; extra == "async"
 Requires-Dist: sniffio~=1.3; extra == "async"
-Requires-Dist: greenlet~=3.1; extra == "async"
+Requires-Dist: greenlet~=3.2; extra == "async"
 Requires-Dist: trio~=0.29; extra == "async"
 Requires-Dist: trio-asyncio~=0.15; extra == "async"
 Provides-Extra: compress