omlish 0.0.0.dev1__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

omlish/dataclasses/impl/fields.py

@@ -55,7 +55,7 @@ def preprocess_field(
     if ft in (FieldType.CLASS, FieldType.INIT):
         if f.default_factory is not MISSING:
             raise TypeError(f'field {f.name} cannot have a default factory')
-    f._field_type = ft.value  # type: ignore
+    f._field_type = ft.value  # type: ignore  # noqa
 
     if ft in (FieldType.INSTANCE, FieldType.INIT):
         if f.kw_only is MISSING:
@@ -88,7 +88,7 @@ def field_assign(
 def field_init(
         f: dc.Field,
         frozen: bool,
-        locals: dict[str, ta.Any],
+        locals: dict[str, ta.Any],  # noqa
         self_name: str,
         slots: bool,
 ) -> ta.Sequence[str]:
@@ -112,7 +112,7 @@ def field_init(
         locals[cn] = f.type
         lines.append(
             f'if not __dataclass_builtins_isinstance__({f.name}, {cn}): '
-            f'raise __dataclass_builtins_TypeError__({f.name}, {cn})'
+            f'raise __dataclass_builtins_TypeError__({f.name}, {cn})',
         )
 
     value: str | None = None
@@ -135,12 +135,12 @@ def field_init(
             locals[default_name] = f.default
             value = f.name
 
+    elif slots and f.default is not MISSING:
+        locals[default_name] = f.default
+        value = default_name
+
     else:
-        if slots and f.default is not MISSING:
-            locals[default_name] = f.default
-            value = default_name
-        else:
-            pass
+        pass
 
     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/frozen.py

@@ -10,9 +10,9 @@ from .utils import set_new_attribute
 def frozen_get_del_attr(
         cls: type,
         fields: ta.Sequence[dc.Field],
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> tuple[ta.Callable, ta.Callable]:
-    locals = {
+    locals = {  # noqa
         'cls': cls,
         'FrozenInstanceError': dc.FrozenInstanceError,
     }

omlish/dataclasses/impl/init.py

@@ -3,7 +3,7 @@ import inspect
 import typing as ta
 
 from ... import lang
-from .exceptions import CheckException
+from .exceptions import CheckError
 from .fields import field_init
 from .fields import field_type
 from .fields import has_default
@@ -64,7 +64,7 @@ class InitBuilder:
             fields: ta.Mapping[str, dc.Field],
             has_post_init: bool,
             self_name: str,
-            globals: Namespace,
+            globals: Namespace,  # noqa
     ) -> None:
         super().__init__()
 
@@ -86,7 +86,7 @@ class InitBuilder:
                 elif seen_default:
                     raise TypeError(f'non-default argument {f.name!r} follows default argument {seen_default.name!r}')
 
-        locals: dict[str, ta.Any] = {}
+        locals: dict[str, ta.Any] = {}  # noqa
 
         if self._info.params_extras.generic_init:
             get_fty = lambda f: self._info.generic_replaced_field_annotations[f.name]
@@ -99,7 +99,7 @@ class InitBuilder:
             '__dataclass_builtins_object__': object,
             '__dataclass_builtins_isinstance__': isinstance,
             '__dataclass_builtins_TypeError__': TypeError,
-            '__dataclass_CheckException__': CheckException,
+            '__dataclass_CheckException__': CheckError,
         })
 
         body_lines: list[str] = []
@@ -109,7 +109,7 @@ class InitBuilder:
                 self._info.params.frozen,
                 locals,
                 self._self_name,
-                self._info.params12.slots,
+                self._info.params.slots,
             )
 
             if f_lines:
@@ -143,7 +143,7 @@ class InitBuilder:
 
         return create_fn(
             '__init__',
-            [self._self_name] + _init_params,
+            [self._self_name, *_init_params],
             body_lines,
             locals=locals,
             globals=self._globals,

omlish/dataclasses/impl/internals.py

@@ -17,6 +17,21 @@ POST_INIT_NAME = dc._POST_INIT_NAME  # type: ignore  # noqa
 
 Params = dc._DataclassParams  # type: ignore  # noqa
 
+"""
+@dc.dataclass(frozen=True)
+class Params:
+    init = True
+    repr = True
+    eq = True
+    order = False
+    unsafe_hash = False
+    frozen = False
+    match_args = True
+    kw_only = False
+    slots = False
+    weakref_slot = False
+"""
+
 
 ##
 
@@ -27,7 +42,7 @@ is_dataclass_instance = dc._is_dataclass_instance  # type: ignore  # noqa
 ##
 
 
-ATOMIC_TYPES: ta.FrozenSet[type]
+ATOMIC_TYPES: frozenset[type]
 
 if hasattr(dc, '_ATOMIC_TYPES'):
     ATOMIC_TYPES = getattr(dc, '_ATOMIC_TYPES')

omlish/dataclasses/impl/main.py

@@ -84,7 +84,7 @@ class MainProcessor:
 
         cls_fields: list[dc.Field] = []
 
-        kw_only = self._info.params12.kw_only
+        kw_only = self._info.params.kw_only
         kw_only_seen = False
         for name, ann in self._info.cls_annotations.items():
             if is_kw_only(self._cls, ann):
@@ -111,11 +111,11 @@ class MainProcessor:
 
     @lang.cached_function
     def _transform_slots(self) -> None:
-        if self._info.params12.weakref_slot and not self._info.params12.slots:
+        if self._info.params.weakref_slot and not self._info.params.slots:
             raise TypeError('weakref_slot is True but slots is False')
-        if not self._info.params12.slots:
+        if not self._info.params.slots:
             return
-        self._cls = add_slots(self._cls, self._info.params.frozen, self._info.params12.weakref_slot)
+        self._cls = add_slots(self._cls, self._info.params.frozen, self._info.params.weakref_slot)
 
     @lang.cached_function
     def process(self) -> type:

omlish/dataclasses/impl/metaclass.py

@@ -59,7 +59,7 @@ class DataMeta(abc.ABCMeta):
             # confer=frozenset(),
 
             metadata=None,
-            **kwargs
+            **kwargs,
     ):
         cls = lang.super_meta(
             super(),
@@ -97,7 +97,7 @@ class Data(metaclass=DataMeta):
             spi = super().__post_init__  # type: ignore  # noqa
         except AttributeError:
             if args or kwargs:
-                raise TypeError(args, kwargs)
+                raise TypeError(args, kwargs) from None
         else:
             spi(*args, **kwargs)
 

omlish/dataclasses/impl/metadata.py

@@ -58,7 +58,7 @@ class Check(lang.Marker):
     pass
 
 
-def check(fn: ta.Union[ta.Callable[..., bool], staticmethod]) -> None:
+def check(fn: ta.Callable[..., bool] | staticmethod) -> None:
     _append_cls_md(Check, fn)
 
 

omlish/dataclasses/impl/order.py

@@ -12,7 +12,7 @@ def cmp_fn(
         op: str,
         self_tuple: str,
         other_tuple: str,
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> ta.Callable:
     return create_fn(
         name,
@@ -43,5 +43,5 @@ class OrderProcessor(Processor):
             if set_new_attribute(self._cls, name, cmp_fn(name, op, self_tuple, other_tuple, globals=self._info.globals)):  # noqa
                 raise TypeError(
                     f'Cannot overwrite attribute {name} in class {self._cls.__name__}. '
-                    f'Consider using functools.total_ordering'
+                    f'Consider using functools.total_ordering',
                 )

omlish/dataclasses/impl/params.py

@@ -28,7 +28,6 @@ Params:
     weakref_slot: bool = False
 """
 import dataclasses as dc
-import sys
 import typing as ta
 
 from ... import lang
@@ -38,18 +37,16 @@ from .metadata import EMPTY_METADATA
 from .metadata import METADATA_ATTR
 
 
-IS_12 = sys.version_info[1] >= 12
-
-
 ##
 
 
 @dc.dataclass(frozen=True)
 class FieldExtras(lang.Final):
-    coerce: ta.Optional[ta.Union[bool, ta.Callable[[ta.Any], ta.Any]]] = None
-    check: ta.Optional[ta.Callable[[ta.Any], bool]] = None
-    check_type: ta.Optional[bool] = None
+    coerce: bool | ta.Callable[[ta.Any], ta.Any] | None = None
+    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
 
 
 DEFAULT_FIELD_EXTRAS = FieldExtras()
@@ -82,37 +79,6 @@ def get_params(obj: ta.Any) -> Params:
 ##
 
 
-@dc.dataclass(frozen=True)
-class Params12(lang.Final):
-    match_args: bool = True
-    kw_only: bool = False
-    slots: bool = False
-    weakref_slot: bool = False
-
-
-DEFAULT_PARAMS12 = Params12()
-
-
-def get_params12(obj: ta.Any) -> Params12:
-    if IS_12:
-        p = get_params(obj)
-        return Params12(
-            match_args=p.match_args,
-            kw_only=p.kw_only,
-            slots=p.slots,
-            weakref_slot=p.weakref_slot,
-        )
-
-    if (pcls := get_params_cls(obj)) is None:
-        raise TypeError(pcls)
-
-    md = pcls.__dict__.get(METADATA_ATTR, EMPTY_METADATA)
-    return md.get(Params12, DEFAULT_PARAMS12)
-
-
-##
-
-
 @dc.dataclass(frozen=True)
 class ParamsExtras(lang.Final):
     reorder: bool = False

omlish/dataclasses/impl/reflect.py

@@ -22,10 +22,8 @@ from .metadata import METADATA_ATTR
 from .metadata import Metadata
 from .metadata import get_merged_metadata
 from .params import PARAMS_ATTR
-from .params import Params12
 from .params import ParamsExtras
 from .params import get_params
-from .params import get_params12
 from .params import get_params_extras
 from .utils import Namespace
 
@@ -55,7 +53,7 @@ class ClassInfo:
             return {}
 
     @cached.property
-    def cls_annotations(self) -> dict[str, ta.Any]:
+    def cls_annotations(self) -> ta.Mapping[str, ta.Any]:
         return inspect.get_annotations(self._cls)
 
     ##
@@ -68,10 +66,6 @@ class ClassInfo:
     def cls_params(self) -> Params | None:
         return self._cls.__dict__.get(PARAMS_ATTR)
 
-    @cached.property
-    def params12(self) -> Params12:
-        return get_params12(self._cls)
-
     @cached.property
     def params_extras(self) -> ParamsExtras:
         return get_params_extras(self._cls)

omlish/dataclasses/impl/replace.py

@@ -11,7 +11,7 @@ from .utils import set_new_attribute
 MISSING = dc.MISSING
 
 
-def replace(obj, /, **changes):
+def replace(obj, /, **changes):  # noqa
     if not is_dataclass_instance(obj):
         raise TypeError('replace() should be called on dataclass instances')
     return _replace(obj, **changes)

omlish/dataclasses/impl/repr.py

@@ -2,6 +2,7 @@ import dataclasses as dc
 import reprlib
 import typing as ta
 
+from .params import get_field_extras
 from .processing import Processor
 from .utils import Namespace
 from .utils import create_fn
@@ -10,17 +11,34 @@ from .utils import set_new_attribute
 
 def repr_fn(
         fields: ta.Sequence[dc.Field],
-        globals: Namespace,
+        globals: Namespace,  # noqa
 ) -> ta.Callable:
+    locals: dict[str, ta.Any] = {}  # noqa
+    if any(get_field_extras(f).repr_fn is not None for f in fields):
+        lst: list[str] = []
+        for f in fields:
+            if (fex := get_field_extras(f)).repr_fn is not None:
+                locals[fn_name := f'__repr_fn__{f.name}'] = fex.repr_fn
+                lst.append(f"if (r := {fn_name}(self.{f.name})) is not None: l.append(f'{f.name}={{r}}')")
+            else:
+                lst.append(f"l.append(f'{f.name}={{self.{f.name}!r}}')")
+        src = [
+            'l = []',
+            *lst,
+            'return f"{self.__class__.__qualname__}({", ".join(l)})"',
+        ]
+    else:
+        src = [
+            'return f"{self.__class__.__qualname__}(' +
+            ', '.join([f'{f.name}={{self.{f.name}!r}}' for f in fields]) +
+            ')"',
+        ]
     fn = create_fn(
         '__repr__',
         ('self',),
-        [
-            'return f"{self.__class__.__qualname__}(' +
-            ', '.join([f"{f.name}={{self.{f.name}!r}}" for f in fields]) +
-            ')"'
-        ],
+        src,
         globals=globals,
+        locals=locals,
     )
     return reprlib.recursive_repr()(fn)
 

omlish/dataclasses/impl/simple.py

@@ -16,7 +16,7 @@ class OverridesProcessor(Processor):
             if not fx.override:
                 continue
 
-            if self._info.params12.slots:
+            if self._info.params.slots:
                 raise TypeError
 
             self_name = '__dataclass_self__' if 'self' in self._info.fields else 'self'
@@ -85,7 +85,7 @@ class DocProcessor(Processor):
 
 class MatchArgsProcessor(Processor):
     def _process(self) -> None:
-        if not self._info.params12.match_args:
+        if not self._info.params.match_args:
             return
 
         ifs = get_init_fields(self._info.fields.values())

omlish/dataclasses/impl/slots.py

@@ -55,8 +55,8 @@ def add_slots(
             inherited_slots.__contains__,
             itertools.chain(
                 field_names,
-                ('__weakref__',) if weakref_slot else ()
-            )
+                ('__weakref__',) if weakref_slot else (),
+            ),
         ),
     )
 

omlish/dataclasses/impl/utils.py

@@ -16,15 +16,15 @@ def create_fn(
         args: ta.Sequence[str],
         body: ta.Sequence[str],
         *,
-        globals: ta.Optional[Namespace] = None,
-        locals: ta.Optional[Namespace] = None,
+        globals: Namespace | None = None,  # noqa
+        locals: Namespace | None = None,  # noqa
         return_type: lang.Maybe[ta.Any] = lang.empty(),
 ) -> ta.Callable:
     check.not_isinstance(args, str)
     check.not_isinstance(body, str)
 
     if locals is None:
-        locals = {}
+        locals = {}  # noqa
     return_annotation = ''
     if return_type.present:
         locals['__dataclass_return_type__'] = return_type()
@@ -43,7 +43,7 @@ def create_fn(
 
 # TODO: https://github.com/python/cpython/commit/8945b7ff55b87d11c747af2dad0e3e4d631e62d6
 class FuncBuilder:
-    def __init__(self, globals: Namespace) -> None:
+    def __init__(self, globals: Namespace) -> None:  # noqa
         super().__init__()
 
         self.names: list[str] = []
@@ -59,11 +59,11 @@ class FuncBuilder:
             args: ta.Sequence[str],
             body: ta.Sequence[str],
             *,
-            locals: ta.Optional[Namespace] = None,
+            locals: Namespace | None = None,  # noqa
             return_type: lang.Maybe[ta.Any] = lang.empty(),
             overwrite_error: bool = False,
             unconditional_add: bool = False,
-            decorator: ta.Optional[str] = None,
+            decorator: str | None = None,
     ) -> None:
         if locals is not None:
             self.locals.update(locals)
@@ -91,7 +91,7 @@ class FuncBuilder:
         body = textwrap.indent('\n'.join(body), '    ')
 
         # Compute the text of the entire function, add it to the text we're generating.
-        deco_str = "  {decorator}\n" if decorator else ""
+        deco_str = '  {decorator}\n' if decorator else ''
         self.src.append(f'{deco_str}  def {name}({args}){return_annotation}:\n{body}')
 
     def add_fns_to_class(self, cls: type) -> None:

omlish/defs.py

@@ -4,6 +4,8 @@ class definitions. Should be used sparingly for methods not directly used by hum
 remain @property's for type annotation, tool assistance, debugging, and otherwise, but these are still nice to have in
 certain circumstances (the real-world alternative usually being simply not adding them).
 """
+# ruff: noqa: ANN201
+
 import abc
 import functools
 import operator
@@ -62,29 +64,23 @@ def build_attr_repr(obj, *, mro=False):
     if mro:
         attrs = [
             attr
-            for ty in sorted(reversed(type(obj).__mro__), key=lambda _ty: _ty.__dict__.get('__repr_priority__', 0))
+            for ty in sorted(reversed(type(obj).__mro__), key=lambda _ty: _ty.__dict__.get('__repr_priority__', 0))  # noqa
             for attr in ty.__dict__.get('__repr_attrs__', [])]
     else:
         attrs = obj.__repr_attrs__
-    return '%s@%s(%s)' % (
-        type(obj).__name__,
-        hex(id(obj))[2:],
-        ', '.join('%s=%s' % (attr, '<self>' if value is obj else _repr(value))
-                  for attr in attrs for value in [getattr(obj, attr)]))
+    s = ', '.join(f'{a}={"<self>" if v is obj else _repr(v)}' for a in attrs for v in [getattr(obj, a)])
+    return f'{type(obj).__name__}@{hex(id(obj))[2:]}({s})'
 
 
 @_repr_guard
 def build_repr(obj, *attrs):
-    return '%s@%s(%s)' % (
-        type(obj).__name__,
-        hex(id(obj))[2:],
-        ', '.join('%s=%r' % (attr, getattr(obj, attr)) for attr in attrs))
+    return f'{type(obj).__name__}@{hex(id(obj))[2:]}({", ".join(f"{attr}={getattr(obj, attr)!r}" for attr in attrs)})'
 
 
 @_basic
 @lang.cls_dct_fn()
-def repr(cls_dct, *attrs, mro=False, priority=None):
-    def __repr__(self):
+def repr(cls_dct, *attrs, mro=False, priority=None):  # noqa
+    def __repr__(self):  # noqa
         return build_attr_repr(self, mro=mro)
 
     cls_dct['__repr_attrs__'] = attrs
@@ -95,7 +91,7 @@ def repr(cls_dct, *attrs, mro=False, priority=None):
 
 @lang.cls_dct_fn()
 def bare_repr(cls_dct, *attrs):
-    def __repr__(self):
+    def __repr__(self):  # noqa
         return lang.attr_repr(self, *attrs)
 
     cls_dct['__repr__'] = __repr__
@@ -103,7 +99,7 @@ def bare_repr(cls_dct, *attrs):
 
 @lang.cls_dct_fn()
 def name_repr(cls_dct):
-    def __repr__(self):
+    def __repr__(self):  # noqa
         return self.__name__
 
     cls_dct['__repr__'] = __repr__
@@ -111,7 +107,7 @@ def name_repr(cls_dct):
 
 @lang.cls_dct_fn()
 def ne(cls_dct):
-    def __ne__(self, other):
+    def __ne__(self, other):  # noqa
         return not (self == other)
 
     cls_dct['__ne__'] = __ne__
@@ -137,12 +133,12 @@ def no_order(cls_dct, *, raise_=None):
 @_basic
 @lang.cls_dct_fn()
 def hash_eq(cls_dct, *attrs):
-    def __hash__(self):
+    def __hash__(self):  # noqa
         return hash(tuple(getattr(self, attr) for attr in attrs))
 
     cls_dct['__hash__'] = __hash__
 
-    def __eq__(self, other):
+    def __eq__(self, other):  # noqa
         if type(other) is not type(self):
             return False
         for attr in attrs: