omlish 0.0.0.dev282__py3-none-any.whl → 0.0.0.dev284__py3-none-any.whl

omlish/lang/objects.py

@@ -11,23 +11,6 @@ T = ta.TypeVar('T')
 ##
 
 
-def attr_repr(
-        obj: ta.Any,
-        *attrs: str,
-        with_module: bool = False,
-        use_qualname: bool = False,
-        with_id: bool = False,
-) -> str:
-    return (
-        f'{obj.__class__.__module__ + "." if with_module else ""}'
-        f'{obj.__class__.__qualname__ if use_qualname else obj.__class__.__name__}'
-        f'{("@" + hex(id(obj))[2:]) if with_id else ""}'
-        f'('
-        f'{", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)}'
-        f')'
-    )
-
-
 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/__init__.py

@@ -50,7 +50,7 @@ from .composite.wrapped import (  # noqa
     WrappedUnmarshaler,
 )
 
-from .exceptions import (  # noqa
+from .errors import (  # noqa
     ForbiddenTypeError,
     MarshalError,
     UnhandledTypeError,

omlish/marshal/base.py

@@ -92,7 +92,7 @@ from .. import dataclasses as dc
 from .. import lang
 from .. import reflect as rfl
 from ..funcs import match as mfs
-from .exceptions import UnhandledTypeError
+from .errors import UnhandledTypeError
 from .factories import RecursiveTypeFactory
 from .factories import TypeCacheFactory
 from .factories import TypeMapFactory

omlish/marshal/{exceptions.py → errors.py}

@@ -1,6 +1,9 @@
 from .. import reflect as rfl
 
 
+##
+
+
 class MarshalError(Exception):
     pass
 

omlish/marshal/objects/dataclasses.py

@@ -50,7 +50,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 +66,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 +76,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
+                ((cpx := dc_rfl.cls_params_extras) is not None and cpx.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.generic_replaced_field_type(field.name))
         else:
             f_ty = type_hints[field.name]
 

omlish/marshal/trivial/forbidden.py

@@ -9,7 +9,7 @@ from ..base import SimpleMarshalerFactory
 from ..base import SimpleUnmarshalerFactory
 from ..base import UnmarshalContext
 from ..base import Unmarshaler
-from ..exceptions import ForbiddenTypeError
+from ..errors import ForbiddenTypeError
 
 
 C = ta.TypeVar('C')

omlish/specs/jmespath/__init__.py

@@ -27,7 +27,7 @@ See:
  - https://github.com/jmespath-community/jmespath.spec/discussions?discussions_q=label%3Ajep-candidate
  - https://github.com/jmespath-community/jmespath.spec/discussions/97
 """  # noqa
-from . import exceptions  # noqa
+from . import errors  # noqa
 from . import functions  # noqa
 from . import lexer  # noqa
 from . import parser  # noqa

omlish/specs/jmespath/cli.py

@@ -5,11 +5,11 @@ import typing as ta
 
 from ...formats import json
 from .ast import Node
-from .exceptions import ArityError
-from .exceptions import JmespathTypeError
-from .exceptions import JmespathValueError
-from .exceptions import ParseError
-from .exceptions import UnknownFunctionError
+from .errors import ArityError
+from .errors import JmespathTypeError
+from .errors import JmespathValueError
+from .errors import ParseError
+from .errors import UnknownFunctionError
 from .parser import compile  # noqa
 from .parser import search
 from .visitor import node_type

omlish/specs/jmespath/functions.py

@@ -5,12 +5,12 @@ import math
 import re
 import typing as ta
 
-from .exceptions import ArityError
-from .exceptions import JmespathError
-from .exceptions import JmespathTypeError
-from .exceptions import JmespathValueError
-from .exceptions import UnknownFunctionError
-from .exceptions import VariadicArityError
+from .errors import ArityError
+from .errors import JmespathError
+from .errors import JmespathTypeError
+from .errors import JmespathValueError
+from .errors import UnknownFunctionError
+from .errors import VariadicArityError
 
 
 T = ta.TypeVar('T')

omlish/specs/jmespath/lexer.py

@@ -4,8 +4,8 @@ import typing as ta
 import warnings
 
 from ... import check
-from .exceptions import EmptyExpressionError
-from .exceptions import LexerError
+from .errors import EmptyExpressionError
+from .errors import LexerError
 from .visitor import Options
 
 

omlish/specs/jmespath/parser.py

@@ -57,9 +57,9 @@ from .ast import Subexpression
 from .ast import UnaryArithmeticOperator
 from .ast import ValueProjection
 from .ast import VariableRef
-from .exceptions import IncompleteExpressionError
-from .exceptions import LexerError
-from .exceptions import ParseError
+from .errors import IncompleteExpressionError
+from .errors import LexerError
+from .errors import ParseError
 from .lexer import Lexer
 from .lexer import Token
 from .visitor import GraphvizVisitor

omlish/specs/jmespath/visitor.py

@@ -36,7 +36,7 @@ from .ast import Subexpression
 from .ast import UnaryArithmeticOperator
 from .ast import ValueProjection
 from .ast import VariableRef
-from .exceptions import UndefinedVariableError
+from .errors import UndefinedVariableError
 from .functions import DefaultFunctions
 from .functions import Functions
 from .scope import ScopedChainDict

omlish/sql/queries/base.py

@@ -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/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.dev282.dist-info → omlish-0.0.0.dev284.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev282
+Version: 0.0.0.dev284
 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