omlish 0.0.0.dev1__py3-none-any.whl

omlish/dataclasses/impl/reflect.py

@@ -0,0 +1,173 @@
+"""
+TODO:
+ - more cache-recursive reuse - fields, mro, etc
+"""
+import dataclasses as dc
+import inspect
+import sys
+import typing as ta
+import weakref
+
+from ... import cached
+from ... import check
+from ... import collections as col
+from ... import lang
+from ... import reflect as rfl
+from .fields import field_type
+from .internals import FIELDS_ATTR
+from .internals import FieldType
+from .internals import Params
+from .internals import is_kw_only
+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
+
+
+MISSING = dc.MISSING
+
+
+class ClassInfo:
+
+    def __init__(self, cls: type, *, _constructing: bool = False) -> None:
+        check.isinstance(cls, type)
+        self._constructing = _constructing
+        if not _constructing:
+            check.arg(dc.is_dataclass(cls))
+        super().__init__()
+        self._cls: type = cls
+
+    @property
+    def cls(self) -> type:
+        return self._cls  # noqa
+
+    @cached.property
+    def globals(self) -> Namespace:
+        if self._cls.__module__ in sys.modules:
+            return sys.modules[self._cls.__module__].__dict__
+        else:
+            return {}
+
+    @cached.property
+    def cls_annotations(self) -> dict[str, ta.Any]:
+        return inspect.get_annotations(self._cls)
+
+    ##
+
+    @cached.property
+    def params(self) -> Params:
+        return get_params(self._cls)
+
+    @cached.property
+    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)
+
+    @cached.property
+    def cls_params_extras(self) -> ParamsExtras | None:
+        return (self.cls_metadata or {}).get(ParamsExtras)
+
+    @cached.property
+    def cls_metadata(self) -> Metadata | None:
+        return self._cls.__dict__.get(METADATA_ATTR)
+
+    @cached.property
+    def merged_metadata(self) -> Metadata:
+        return get_merged_metadata(self._cls)
+
+    ##
+
+    class _FoundFields(ta.NamedTuple):
+        fields: dict[str, dc.Field]
+        field_owners: dict[str, type]
+
+    @lang.cached_function
+    def _find_fields(self) -> _FoundFields:
+        if self._constructing:
+            check.in_(FIELDS_ATTR, self._cls.__dict__)
+
+        fields: dict[str, dc.Field] = {}
+        field_owners: dict[str, type] = {}
+
+        for b in self._cls.__mro__[-1:0:-1]:
+            base_fields = getattr(b, FIELDS_ATTR, None)
+            if base_fields is not None:
+                for name in reflect(b).cls_annotations:
+                    try:
+                        f = base_fields[name]
+                    except KeyError:
+                        continue
+                    fields[f.name] = f
+                    field_owners[f.name] = b
+
+        cls_fields = getattr(self._cls, FIELDS_ATTR)
+        for name, ann in self.cls_annotations.items():
+            if is_kw_only(self._cls, ann):
+                continue
+            fields[name] = cls_fields[name]
+            field_owners[name] = self._cls
+
+        return ClassInfo._FoundFields(fields, field_owners)
+
+    @cached.property
+    def fields(self) -> ta.Mapping[str, dc.Field]:
+        return self._find_fields().fields
+
+    @cached.property
+    def instance_fields(self) -> ta.Sequence[dc.Field]:
+        return [f for f in self.fields.values() if field_type(f) is FieldType.INSTANCE]
+
+    @cached.property
+    def field_owners(self) -> ta.Mapping[str, type]:
+        return self._find_fields().field_owners
+
+    ##
+
+    @cached.property
+    def generic_mro(self) -> ta.Sequence[rfl.Type]:
+        return rfl.ALIAS_UPDATING_GENERIC_SUBSTITUTION.generic_mro(self._cls)
+
+    @cached.property
+    def generic_mro_lookup(self) -> ta.Mapping[type, rfl.Type]:
+        return col.unique_dict((check.not_none(rfl.get_concrete_type(g)), g) for g in self.generic_mro)
+
+    @cached.property
+    def generic_replaced_field_types(self) -> ta.Mapping[str, rfl.Type]:
+        ret: dict[str, ta.Any] = {}
+        for f in self.fields.values():
+            fo = self.field_owners[f.name]
+            go = self.generic_mro_lookup[fo]
+            tvr = rfl.get_type_var_replacements(go)
+            fty = rfl.type_(f.type)
+            rty = rfl.replace_type_vars(fty, tvr, update_aliases=True)
+            ret[f.name] = rty
+        return ret
+
+    @cached.property
+    def generic_replaced_field_annotations(self) -> ta.Mapping[str, ta.Any]:
+        return {k: rfl.to_annotation(v) for k, v in self.generic_replaced_field_types.items()}
+
+
+_CLASS_INFO_CACHE: ta.MutableMapping[type, ClassInfo] = weakref.WeakKeyDictionary()
+
+
+def reflect(obj: ta.Any) -> ClassInfo:
+    cls = obj if isinstance(obj, type) else type(obj)
+    try:
+        return _CLASS_INFO_CACHE[cls]
+    except KeyError:
+        _CLASS_INFO_CACHE[cls] = info = ClassInfo(cls)
+        return info

omlish/dataclasses/impl/replace.py

@@ -0,0 +1,40 @@
+import dataclasses as dc
+
+from .fields import field_type
+from .internals import FIELDS_ATTR
+from .internals import FieldType
+from .internals import is_dataclass_instance
+from .processing import Processor
+from .utils import set_new_attribute
+
+
+MISSING = dc.MISSING
+
+
+def replace(obj, /, **changes):
+    if not is_dataclass_instance(obj):
+        raise TypeError('replace() should be called on dataclass instances')
+    return _replace(obj, **changes)
+
+
+def _replace(obj, /, **changes):
+    for f in getattr(obj, FIELDS_ATTR).values():
+        if (ft := field_type(f)) is FieldType.CLASS:
+            continue
+
+        if not f.init:
+            if f.name in changes:
+                raise TypeError(f'field {f.name} is declared with init=False, it cannot be specified with replace()')
+            continue
+
+        if f.name not in changes:
+            if ft is FieldType.INIT and f.default is MISSING:
+                raise TypeError(f'InitVar {f.name!r} must be specified with replace()')
+            changes[f.name] = getattr(obj, f.name)
+
+    return obj.__class__(**changes)
+
+
+class ReplaceProcessor(Processor):
+    def _process(self) -> None:
+        set_new_attribute(self._cls, '__replace__', _replace)

omlish/dataclasses/impl/repr.py

@@ -0,0 +1,34 @@
+import dataclasses as dc
+import reprlib
+import typing as ta
+
+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,
+) -> ta.Callable:
+    fn = create_fn(
+        '__repr__',
+        ('self',),
+        [
+            'return f"{self.__class__.__qualname__}(' +
+            ', '.join([f"{f.name}={{self.{f.name}!r}}" for f in fields]) +
+            ')"'
+        ],
+        globals=globals,
+    )
+    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]
+        set_new_attribute(self._cls, '__repr__', repr_fn(flds, self._info.globals))  # noqa

omlish/dataclasses/impl/simple.py

@@ -0,0 +1,92 @@
+import inspect
+
+from ... import lang
+from .fields import field_assign
+from .init import get_init_fields
+from .params import get_field_extras
+from .processing import Processor
+from .utils import create_fn
+from .utils import set_new_attribute
+
+
+class OverridesProcessor(Processor):
+    def _process(self) -> None:
+        for f in self._info.instance_fields:
+            fx = get_field_extras(f)
+            if not fx.override:
+                continue
+
+            if self._info.params12.slots:
+                raise TypeError
+
+            self_name = '__dataclass_self__' if 'self' in self._info.fields else 'self'
+
+            getter = create_fn(
+                f.name,
+                (self_name,),
+                [f'return {self_name}.__dict__[{f.name!r}]'],
+                globals=self._info.globals,
+                return_type=lang.just(f.type),
+            )
+            prop = property(getter)
+
+            if not self._info.params.frozen:
+                setter = create_fn(
+                    f.name,
+                    (self_name, f'{f.name}: __dataclass_type_{f.name}__'),
+                    [field_assign(self._info.params.frozen, f.name, f.name, self_name, fx.override)],
+                    globals=self._info.globals,
+                    locals={f'__dataclass_type_{f.name}__': f.type},
+                    return_type=lang.just(None),
+                )
+                prop = prop.setter(setter)
+
+            set_new_attribute(
+                self._cls,
+                f.name,
+                prop,
+            )
+
+
+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.params12.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/slots.py

@@ -0,0 +1,80 @@
+import dataclasses as dc
+import itertools
+
+
+MISSING = dc.MISSING
+
+
+def _dataclass_getstate(self):
+    return [getattr(self, f.name) for f in dc.fields(self)]
+
+
+def _dataclass_setstate(self, state):
+    for field, value in zip(dc.fields(self), state):
+        object.__setattr__(self, field.name, value)
+
+
+def _get_slots(cls):
+    match cls.__dict__.get('__slots__'):
+        # A class which does not define __slots__ at all is equivalent to a class defining
+        #   __slots__ = ('__dict__', '__weakref__')
+        # `__dictoffset__` and `__weakrefoffset__` can tell us whether the base type has dict/weakref slots, in a way
+        # that works correctly for both Python classes and C extension types. Extension types don't use `__slots__` for
+        # slot creation
+        case None:
+            slots = []
+            if getattr(cls, '__weakrefoffset__', -1) != 0:
+                slots.append('__weakref__')
+            if getattr(cls, '__dictrefoffset__', -1) != 0:
+                slots.append('__dict__')
+            yield from slots
+        case str(slot):
+            yield slot
+        # Slots may be any iterable, but we cannot handle an iterator because it will already be (partially) consumed.
+        case iterable if not hasattr(iterable, '__next__'):
+            yield from iterable
+        case _:
+            raise TypeError(f"Slots of '{cls.__name__}' cannot be determined")
+
+
+def add_slots(
+        cls: type,
+        is_frozen: bool,
+        weakref_slot: bool,
+) -> type:
+    if '__slots__' in cls.__dict__:
+        raise TypeError(f'{cls.__name__} already specifies __slots__')
+
+    cls_dict = dict(cls.__dict__)
+    field_names = tuple(f.name for f in dc.fields(cls))  # noqa
+
+    inherited_slots = set(itertools.chain.from_iterable(map(_get_slots, cls.__mro__[1:-1])))
+
+    cls_dict['__slots__'] = tuple(
+        itertools.filterfalse(
+            inherited_slots.__contains__,
+            itertools.chain(
+                field_names,
+                ('__weakref__',) if weakref_slot else ()
+            )
+        ),
+    )
+
+    for field_name in field_names:
+        cls_dict.pop(field_name, None)
+
+    cls_dict.pop('__dict__', None)
+    cls_dict.pop('__weakref__', None)
+
+    qualname = getattr(cls, '__qualname__', None)
+    cls = type(cls)(cls.__name__, cls.__bases__, cls_dict)
+    if qualname is not None:
+        cls.__qualname__ = qualname
+
+    if is_frozen:
+        if '__getstate__' not in cls_dict:
+            cls.__getstate__ = _dataclass_getstate  # type: ignore
+        if '__setstate__' not in cls_dict:
+            cls.__setstate__ = _dataclass_setstate  # type: ignore
+
+    return cls

omlish/dataclasses/impl/utils.py

@@ -0,0 +1,167 @@
+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: ta.Optional[Namespace] = None,
+        locals: ta.Optional[Namespace] = None,
+        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 = {}
+    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:
+        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: ta.Optional[Namespace] = None,
+            return_type: lang.Maybe[ta.Any] = lang.empty(),
+            overwrite_error: bool = False,
+            unconditional_add: bool = False,
+            decorator: ta.Optional[str] = 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])},)'