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

omlish/dataclasses/impl/repr.py

@@ -1,66 +0,0 @@
-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
-from .utils import set_new_attribute
-
-
-def repr_fn(
-        fields: ta.Sequence[dc.Field],
-        globals: Namespace,  # noqa
-        *,
-        repr_id: bool = False,
-) -> ta.Callable:
-    locals: dict[str, ta.Any] = {}  # noqa
-
-    fields = sorted(fields, key=lambda f: get_field_extras(f).repr_priority or 0)
-
-    prefix_src = '{self.__class__.__qualname__}'
-    if repr_id:
-        prefix_src += '@{hex(id(self))[2:]}'
-
-    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,
-            f'return f"{prefix_src}({{", ".join(l)}})"',
-        ]
-
-    else:
-        src = [
-            f'return f"{prefix_src}(' +
-            ', '.join([f'{f.name}={{self.{f.name}!r}}' for f in fields]) +
-            ')"',
-        ]
-
-    fn = create_fn(
-        '__repr__',
-        ('self',),
-        src,
-        globals=globals,
-        locals=locals,
-    )
-
-    return reprlib.recursive_repr()(fn)
-
-
-class ReprProcessor(Processor):
-    def _process(self) -> None:
-        if not self._info.params.repr:
-            return
-
-        flds = [f for f in self._info.instance_fields if f.repr]
-        rfn = repr_fn(flds, self._info.globals, repr_id=self._info.params_extras.repr_id)
-        set_new_attribute(self._cls, '__repr__', rfn)  # noqa

omlish/dataclasses/impl/simple.py

@@ -1,50 +0,0 @@
-import inspect
-
-from .init import get_init_fields
-from .processing import Processor
-from .utils import create_fn
-from .utils import set_new_attribute
-
-
-class EqProcessor(Processor):
-    def _process(self) -> None:
-        if not self._info.params.eq:
-            return
-
-        # flds = [f for f in self._info.instance_fields if f.compare]
-        # self_tuple = tuple_str('self', flds)
-        # other_tuple = tuple_str('other', flds)
-        # set_new_attribute(cls, '__eq__', _cmp_fn('__eq__', '==', self_tuple, other_tuple, globals=globals))
-        cmp_fields = [field for field in self._info.instance_fields if field.compare]
-        terms = [f'self.{field.name} == other.{field.name}' for field in cmp_fields]
-        field_comparisons = ' and '.join(terms) or 'True'
-        body = [
-            f'if self is other:',
-            f' return True',
-            f'if other.__class__ is self.__class__:',
-            f' return {field_comparisons}',
-            f'return NotImplemented',
-        ]
-        func = create_fn('__eq__', ('self', 'other'), body, globals=self._info.globals)
-        set_new_attribute(self._cls, '__eq__', func)
-
-
-class DocProcessor(Processor):
-    def _process(self) -> None:
-        if getattr(self._cls, '__doc__'):
-            return
-
-        try:
-            text_sig = str(inspect.signature(self._cls)).replace(' -> None', '')
-        except (TypeError, ValueError):
-            text_sig = ''
-        self._cls.__doc__ = (self._cls.__name__ + text_sig)
-
-
-class MatchArgsProcessor(Processor):
-    def _process(self) -> None:
-        if not self._info.params.match_args:
-            return
-
-        ifs = get_init_fields(self._info.fields.values())
-        set_new_attribute(self._cls, '__match_args__', tuple(f.name for f in ifs.std))

omlish/dataclasses/impl/utils.py

@@ -1,167 +0,0 @@
-import dataclasses as dc
-import textwrap
-import types
-import typing as ta
-
-from ... import check
-from ... import lang
-
-
-T = ta.TypeVar('T')
-Namespace: ta.TypeAlias = ta.MutableMapping[str, ta.Any]
-
-
-def create_fn(
-        name: str,
-        args: ta.Sequence[str],
-        body: ta.Sequence[str],
-        *,
-        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 = {}  # noqa
-    return_annotation = ''
-    if return_type.present:
-        locals['__dataclass_return_type__'] = return_type()
-        return_annotation = '->__dataclass_return_type__'
-    args = ','.join(args)
-    body = '\n'.join(f'  {b}' for b in body)
-
-    txt = f' def {name}({args}){return_annotation}:\n{body}'
-
-    local_vars = ', '.join(locals.keys())
-    txt = f'def __create_fn__({local_vars}):\n{txt}\n return {name}'
-    ns: dict[str, ta.Any] = {}
-    exec(txt, globals, ns)  # type: ignore
-    return ns['__create_fn__'](**locals)
-
-
-# TODO: https://github.com/python/cpython/commit/8945b7ff55b87d11c747af2dad0e3e4d631e62d6
-class FuncBuilder:
-    def __init__(self, globals: Namespace) -> None:  # noqa
-        super().__init__()
-
-        self.names: list[str] = []
-        self.src: list[str] = []
-        self.globals = globals
-        self.locals: Namespace = {}
-        self.overwrite_errors: dict[str, bool] = {}
-        self.unconditional_adds: dict[str, bool] = {}
-
-    def add_fn(
-            self,
-            name: str,
-            args: ta.Sequence[str],
-            body: ta.Sequence[str],
-            *,
-            locals: Namespace | None = None,  # noqa
-            return_type: lang.Maybe[ta.Any] = lang.empty(),
-            overwrite_error: bool = False,
-            unconditional_add: bool = False,
-            decorator: str | None = None,
-    ) -> None:
-        if locals is not None:
-            self.locals.update(locals)
-
-        # Keep track if this method is allowed to be overwritten if it already exists in the class.  The error is
-        # method-specific, so keep it with the name.  We'll use this when we generate all of the functions in the
-        # add_fns_to_class call.  overwrite_error is either True, in which case we'll raise an error, or it's a string,
-        # in which case we'll raise an error and append this string.
-        if overwrite_error:
-            self.overwrite_errors[name] = overwrite_error
-
-        # Should this function always overwrite anything that's already in the class?  The default is to not overwrite a
-        # function that already exists.
-        if unconditional_add:
-            self.unconditional_adds[name] = True
-
-        self.names.append(name)
-
-        if return_type.present:
-            self.locals[f'__dataclass_{name}_return_type__'] = return_type()
-            return_annotation = f' -> __dataclass_{name}_return_type__'
-        else:
-            return_annotation = ''
-        args = ', '.join(args)
-        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 ''
-        self.src.append(f'{deco_str}  def {name}({args}){return_annotation}:\n{body}')
-
-    def add_fns_to_class(self, cls: type) -> None:
-        # The source to all of the functions we're generating.
-        fns_src = '\n'.join(self.src)
-
-        # The locals they use.
-        local_vars = ','.join(self.locals)
-
-        # The names of all of the functions, used for the return value of the outer function.  Need to handle the
-        # 0-tuple specially.
-        if not self.names:
-            return_names = '()'
-        else:
-            return_names = f'({",".join(self.names)},)'
-
-        # txt is the entire function we're going to execute, including the bodies of the functions we're defining.
-        # Here's a greatly simplified version:
-        # def __create_fn__():
-        #   def __init__(self, x, y):
-        #     self.x = x
-        #     self.y = y
-        #   @recursive_repr
-        #   def __repr__(self):
-        #     return f'cls(x={self.x!r},y={self.y!r})'
-        # return __init__,__repr__
-
-        txt = f'def __create_fn__({local_vars}):\n{fns_src}\n  return {return_names}'
-        ns: dict[str, ta.Any] = {}
-        exec(txt, self.globals, ns)  # type: ignore
-        fns = ns['__create_fn__'](**self.locals)
-
-        # Now that we've generated the functions, assign them into cls.
-        for name, fn in zip(self.names, fns):
-            fn.__qualname__ = f'{cls.__qualname__}.{fn.__name__}'
-            if self.unconditional_adds.get(name, False):
-                setattr(cls, name, fn)
-            else:
-                already_exists = set_new_attribute(cls, name, fn)
-
-                # See if it's an error to overwrite this particular function.
-                if already_exists and (msg_extra := self.overwrite_errors.get(name)):
-                    error_msg = (f'Cannot overwrite attribute {fn.__name__} in class {cls.__name__}')
-                    if msg_extra:
-                        error_msg = f'{error_msg} {msg_extra}'
-
-                    raise TypeError(error_msg)
-
-
-def set_qualname(cls: type, value: T) -> T:
-    if isinstance(value, types.FunctionType):
-        value.__qualname__ = f'{cls.__qualname__}.{value.__name__}'
-    return value
-
-
-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 tuple_str(obj_name: str, fields: ta.Iterable[dc.Field]) -> str:
-    # Return a string representing each field of obj_name as a tuple member.  So, if fields is ['x', 'y'] and obj_name
-    # is "self", return "(self.x,self.y)".
-
-    # Special case for the 0-tuple.
-    if not fields:
-        return '()'
-
-    # Note the trailing comma, needed if this turns out to be a 1-tuple.
-    return f'({",".join([f"{obj_name}.{f.name}" for f in fields])},)'