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

omlish/dataclasses/generation/utils.py

@@ -0,0 +1,83 @@
+import typing as ta
+
+from .globals import OBJECT_SETATTR_GLOBAL
+from .globals import FnGlobal
+from .idents import SELF_DICT_IDENT
+from .idents import SELF_IDENT
+
+
+##
+
+
+def build_attr_tuple_body_src_lines(
+        obj_name: str,
+        *attrs: str,
+        prefix: str = '',
+) -> list[str]:
+    return [
+        f'{prefix}{obj_name}.{a},'
+        for a in attrs
+    ]
+
+
+def build_attr_kwargs_body_src_lines(
+        obj_name: str,
+        *attrs: str,
+        prefix: str = '',
+) -> list[str]:
+    return [
+        f'{prefix}{a}={obj_name}.{a},'
+        for a in attrs
+    ]
+
+
+class SetattrSrcBuilder:
+    def __init__(
+            self,
+            *,
+            object_ident: str = SELF_IDENT,
+            object_dict_ident: str | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._object_ident = object_ident
+        self._object_dict_ident = object_dict_ident
+
+        self._has_set_object_dict = False
+        self._global_refs: set[FnGlobal] = set()
+
+    @property
+    def refs(self) -> ta.AbstractSet[FnGlobal]:
+        return self._global_refs
+
+    def __call__(
+            self,
+            name: str,
+            value_src: str,
+            *,
+            frozen: bool,
+            override: bool,
+    ) -> list[str]:
+        if override:
+            if self._object_dict_ident is not None:
+                return [f'{self._object_dict_ident}[{name!r}] = {value_src}']
+
+            else:
+                if not self._has_set_object_dict:
+                    x = [
+                        f'{SELF_DICT_IDENT} = {self._object_ident}.__dict__',
+                    ]
+                    self._has_set_object_dict = True
+                else:
+                    x = []
+                return [
+                    *x,
+                    f'{SELF_DICT_IDENT}[{name!r}] = {value_src}',
+                ]
+
+        elif frozen:
+            self._global_refs.add(OBJECT_SETATTR_GLOBAL)
+            return [f'{OBJECT_SETATTR_GLOBAL.ident}({self._object_ident}, {name!r}, {value_src})']
+
+        else:
+            return [f'{self._object_ident}.{name} = {value_src}']

omlish/dataclasses/{impl/reflect.py → inspect.py}

@@ -1,116 +1,90 @@
-"""
-TODO:
- - more cache-recursive reuse - fields, mro, etc
-"""
 import dataclasses as dc
-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 ParamsExtras
-from .params import get_params
-from .params import get_params_extras
-from .utils import Namespace
-
-
-MISSING = dc.MISSING
+from .. import cached
+from .. import check
+from .. import collections as col
+from .. import lang
+from .. import reflect as rfl
+from .internals import STD_FIELDS_ATTR
+from .internals import StdFieldType
+from .internals import std_field_type
+from .internals import std_is_kw_only
+
+
+ClassAnnotations: ta.TypeAlias = ta.Mapping[str, ta.Any]
 
 
 ##
 
 
-def get_cls_annotations(cls: type) -> ta.Mapping[str, ta.Any]:
+def _get_cls_annotations(cls: type) -> ClassAnnotations:
     # Does not use ta.get_type_hints because that's what std dataclasses do [1]. Might be worth revisiting? A part
     # of why they don't is to not import typing for efficiency but we don't care about that degree of startup speed.
     # [1]: https://github.com/python/cpython/blob/54c63a32d06cb5f07a66245c375eac7d7efb964a/Lib/dataclasses.py#L985-L986  # noqa
     return rfl.get_annotations(cls)
 
 
+_CLS_ANNOTATIONS_CACHE: ta.MutableMapping[type, ClassAnnotations] = weakref.WeakKeyDictionary()
+
+
+def get_cls_annotations(cls: type) -> ClassAnnotations:
+    try:
+        return _CLS_ANNOTATIONS_CACHE[cls]
+    except KeyError:
+        pass
+    ret = _get_cls_annotations(cls)
+    _CLS_ANNOTATIONS_CACHE[cls] = ret
+    return ret
+
+
 ##
 
 
-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))
+class FieldsInspection:
+    def __init__(
+            self,
+            cls: type,
+            *,
+            cls_fields: ta.Mapping[str, dc.Field] | None = None,
+    ) -> None:
         super().__init__()
-        self._cls: type = cls
+
+        self._cls = cls
+
+        self._given_cls_fields = cls_fields
+        if cls_fields is None:
+            cls_fields = getattr(self._cls, STD_FIELDS_ATTR)
+        self._cls_fields = cls_fields
 
     @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 {}
+    @property
+    def cls_fields(self) -> ta.Mapping[str, dc.Field]:
+        return self._cls_fields
 
     @cached.property
     def cls_annotations(self) -> ta.Mapping[str, ta.Any]:
         return get_cls_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 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
+    @lang.cached_function(no_wrapper_update=True)
     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)
+            base_fields = getattr(b, STD_FIELDS_ATTR, None)
             if base_fields is not None:
-                for name in reflect(b).cls_annotations:
+                for name in get_cls_annotations(b):
                     try:
                         f = base_fields[name]
                     except KeyError:
@@ -118,14 +92,14 @@ class ClassInfo:
                     fields[f.name] = f
                     field_owners[f.name] = b
 
-        cls_fields = getattr(self._cls, FIELDS_ATTR)
+        cls_fields = self._cls_fields
         for name, ann in self.cls_annotations.items():
-            if is_kw_only(self._cls, ann):
+            if std_is_kw_only(self._cls, ann):
                 continue
             fields[name] = cls_fields[name]
             field_owners[name] = self._cls
 
-        return ClassInfo._FoundFields(fields, field_owners)
+        return FieldsInspection._FoundFields(fields, field_owners)
 
     @cached.property
     def fields(self) -> ta.Mapping[str, dc.Field]:
@@ -133,7 +107,7 @@ class ClassInfo:
 
     @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]
+        return [f for f in self.fields.values() if std_field_type(f) is StdFieldType.INSTANCE]
 
     @cached.property
     def field_owners(self) -> ta.Mapping[str, type]:
@@ -170,16 +144,5 @@ class ClassInfo:
         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
+def inspect_fields(cls: type) -> FieldsInspection:
+    return FieldsInspection(cls)

omlish/dataclasses/{impl/internals.py → internals.py}

@@ -8,48 +8,32 @@ import typing as ta
 ##
 
 
-HAS_DEFAULT_FACTORY = dc._HAS_DEFAULT_FACTORY  # type: ignore  # noqa
+STD_HAS_DEFAULT_FACTORY = dc._HAS_DEFAULT_FACTORY  # type: ignore  # noqa
 
-FIELDS_ATTR = dc._FIELDS  # type: ignore  # noqa
-PARAMS_ATTR = dc._PARAMS  # type: ignore  # noqa
+STD_FIELDS_ATTR = dc._FIELDS  # type: ignore  # noqa
+STD_PARAMS_ATTR = dc._PARAMS  # type: ignore  # noqa
 
-POST_INIT_NAME = dc._POST_INIT_NAME  # type: ignore  # noqa
+STD_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
-"""
+StdParams = dc._DataclassParams  # type: ignore  # noqa
 
 
 ##
 
 
-is_dataclass_instance = dc._is_dataclass_instance  # type: ignore  # noqa
+std_is_dataclass_instance = dc._is_dataclass_instance  # type: ignore  # noqa
 
 
 ##
 
 
-ATOMIC_TYPES: frozenset[type]
+STD_ATOMIC_TYPES: frozenset[type]
 
 if hasattr(dc, '_ATOMIC_TYPES'):
-    ATOMIC_TYPES = getattr(dc, '_ATOMIC_TYPES')
+    STD_ATOMIC_TYPES = getattr(dc, '_ATOMIC_TYPES')
 
 else:
-    ATOMIC_TYPES = frozenset({
+    STD_ATOMIC_TYPES = frozenset({
         types.NoneType,
         bool,
         int,
@@ -85,10 +69,20 @@ def _patch_missing_ctor() -> None:
 ##
 
 
-class FieldType(enum.Enum):
+class StdFieldType(enum.Enum):
     INSTANCE = dc._FIELD  # type: ignore  # noqa
-    CLASS = dc._FIELD_CLASSVAR  # type: ignore  # noqa
-    INIT = dc._FIELD_INITVAR  # type: ignore  # noqa
+    CLASS_VAR = dc._FIELD_CLASSVAR  # type: ignore  # noqa
+    INIT_VAR = dc._FIELD_INITVAR  # type: ignore  # noqa
+
+
+def std_field_type(f: dc.Field) -> StdFieldType:
+    if (ft := getattr(f, '_field_type')) is not None:
+        return StdFieldType(ft)
+    else:
+        return StdFieldType.INSTANCE
+
+
+##
 
 
 _SELF_MODULE = None
@@ -97,18 +91,18 @@ _SELF_MODULE = None
 def _self_module():
     global _SELF_MODULE
     if _SELF_MODULE is None:
-        _SELF_MODULE = sys.modules[__package__.rpartition('.')[0]]
+        _SELF_MODULE = sys.modules[__package__]
     return _SELF_MODULE
 
 
-def is_classvar(cls: type, ty: ta.Any) -> bool:
+def std_is_classvar(cls: type, ty: ta.Any) -> bool:
     return (
         dc._is_classvar(ty, ta)  # type: ignore  # noqa
         or (isinstance(ty, str) and dc._is_type(ty, cls, ta, ta.ClassVar, dc._is_classvar))  # type: ignore  # noqa
     )
 
 
-def is_initvar(cls: type, ty: ta.Any) -> bool:
+def std_is_initvar(cls: type, ty: ta.Any) -> bool:
     return (
         dc._is_initvar(ty, dc)  # type: ignore  # noqa
         or (
@@ -121,7 +115,7 @@ def is_initvar(cls: type, ty: ta.Any) -> bool:
     )
 
 
-def is_kw_only(cls: type, ty: ta.Any) -> bool:
+def std_is_kw_only(cls: type, ty: ta.Any) -> bool:
     return (
         dc._is_kw_only(ty, dc)  # type: ignore  # noqa
         or (

omlish/dataclasses/metaclass/bases.py

@@ -0,0 +1,69 @@
+import typing as ta
+
+from ..concerns.frozen import unchecked_frozen_base
+from .meta import DataMeta
+from .specs import get_metaclass_spec
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+# @ta.dataclass_transform(field_specifiers=(field,))  # FIXME: ctor
+@unchecked_frozen_base
+class Data(
+    eq=False,
+    order=False,
+    confer=frozenset([
+        'confer',
+        'final_subclasses',
+    ]),
+    metaclass=DataMeta,
+):
+    def __init__(self, *args, **kwargs):
+        # Typechecking barrier
+        super().__init__(*args, **kwargs)
+
+    def __init_subclass__(cls, **kwargs):
+        # Typechecking barrier
+        super().__init_subclass__(**kwargs)
+
+
+class Frozen(
+    Data,
+    frozen=True,
+    eq=False,
+    order=False,
+    confer=frozenset([
+        *get_metaclass_spec(Data).confer,
+        'frozen',
+        'reorder',
+        'cache_hash',
+        'override',
+    ]),
+):
+    pass
+
+
+class Case(
+    Frozen,
+    abstract=True,
+    override=True,
+    final_subclasses=True,
+    abstract_immediate_subclasses=True,
+):
+    pass
+
+
+class Box(
+    Frozen,
+    ta.Generic[T],
+    generic_init=True,
+    confer=frozenset([
+        *get_metaclass_spec(Frozen).confer,
+        'generic_init',
+    ]),
+):
+    v: T

omlish/dataclasses/metaclass/confer.py

@@ -0,0 +1,65 @@
+import dataclasses as dc
+import typing as ta
+
+from ..api.classes.params import get_class_spec
+from .specs import get_metaclass_spec
+
+
+##
+
+
+CONFER_CLASS_PARAMS: tuple[str, ...] = (
+    'eq',
+    'frozen',
+    'kw_only',
+
+    'reorder',
+    'cache_hash',
+    'generic_init',
+    'override',
+)
+
+CONFER_METACLASS_PARAMS: tuple[str, ...] = (
+    'confer',
+    'final_subclasses',
+    'abstract_immediate_subclasses',
+)
+
+
+def confer_kwarg(out: dict[str, ta.Any], k: str, v: ta.Any) -> None:
+    if k in out:
+        if out[k] != v:
+            raise ValueError
+    else:
+        out[k] = v
+
+
+def confer_kwargs(
+        bases: ta.Sequence[type],
+        kwargs: ta.Mapping[str, ta.Any],
+) -> dict[str, ta.Any]:
+    out: dict[str, ta.Any] = {}
+    for base in bases:
+        if not dc.is_dataclass(base):
+            continue
+
+        if (bcs := get_class_spec(base)) is None:
+            continue
+
+        if not (bmp := get_metaclass_spec(bcs)).confer:
+            continue
+
+        for ck in bmp.confer:
+            if ck in kwargs:
+                continue
+
+            if ck in CONFER_CLASS_PARAMS:
+                confer_kwarg(out, ck, getattr(bcs, ck))
+
+            elif ck in CONFER_METACLASS_PARAMS:
+                confer_kwarg(out, ck, getattr(bmp, ck))
+
+            else:
+                raise KeyError(ck)
+
+    return out

omlish/dataclasses/metaclass/meta.py

@@ -0,0 +1,115 @@
+"""
+TODO:
+ - Rewrite lol
+ - Enum - enforce Abstract or Final
+"""
+import abc
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from ..api.classes.decorator import dataclass
+from .confer import CONFER_METACLASS_PARAMS
+from .confer import confer_kwargs
+from .specs import MetaclassSpec
+from .specs import get_metaclass_spec
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class DataMeta(abc.ABCMeta):
+    def __new__(
+            mcls,
+            name,
+            bases,
+            namespace,
+            *,
+
+            abstract=False,
+            sealed=False,
+            final=False,
+
+            metadata=None,
+            **kwargs,
+    ):
+        ckw = confer_kwargs(bases, kwargs)
+        nkw = {**kwargs, **ckw}
+
+        mcp = MetaclassSpec(**{
+            mpa: nkw.pop(mpa)
+            for mpa in CONFER_METACLASS_PARAMS
+            if mpa in nkw
+        })
+
+        metadata = [
+            *([metadata] if metadata is not None else []),
+            mcp,
+        ]
+
+        #
+
+        xbs: list[type] = []
+
+        if any(
+                get_metaclass_spec(b).abstract_immediate_subclasses  # type: ignore[arg-type]
+                for b in bases
+                if dc.is_dataclass(b)
+        ):
+            abstract = True
+
+        final |= (mcp.final_subclasses and not abstract)
+
+        if final and abstract:
+            raise TypeError(f'Class cannot be abstract and final: {name!r}')
+
+        if abstract:
+            xbs.append(lang.Abstract)
+        if sealed:
+            xbs.append(lang.Sealed)
+        if final:
+            xbs.append(lang.Final)
+
+        if xbs:
+            if bases and bases[-1] is ta.Generic:
+                bases = (*bases[:-1], *xbs, bases[-1])
+            else:
+                bases = (*bases, *xbs)
+            if ob := namespace.get('__orig_bases__'):
+                if getattr(ob[-1], '__origin__', None) is ta.Generic:
+                    namespace['__orig_bases__'] = (*ob[:-1], *xbs, ob[-1])
+                else:
+                    namespace['__orig_bases__'] = (*ob, *xbs)
+
+        #
+
+        ofs: set[str] = set()
+        if any(issubclass(b, lang.Abstract) for b in bases) and nkw.get('override'):
+            ofs.update(a for a in namespace.get('__annotations__', []) if a not in namespace)
+            namespace.update((a, dc.MISSING) for a in ofs)
+
+        #
+
+        cls = lang.super_meta(
+            super(),
+            mcls,
+            name,
+            bases,
+            namespace,
+        )
+
+        #
+
+        for a in ofs:
+            delattr(cls, a)
+
+        #
+
+        return dataclass(
+            cls,
+            metadata=metadata,
+            **nkw,
+        )

omlish/dataclasses/metaclass/specs.py

@@ -0,0 +1,38 @@
+import dataclasses as dc
+
+from ... import lang
+from ..api.classes.params import get_class_spec
+from ..specs import ClassSpec
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True, eq=False)
+class MetaclassSpec(lang.Final):
+    confer: frozenset[str] = frozenset()
+
+    final_subclasses: bool = False
+
+    abstract_immediate_subclasses: bool = False
+
+
+DEFAULT_METACLASS_SPEC = MetaclassSpec()
+
+
+##
+
+
+def get_metaclass_spec(obj: type | ClassSpec) -> MetaclassSpec:
+    cs: ClassSpec
+    if isinstance(obj, type):
+        if (cs := get_class_spec(obj)) is None:  # type: ignore[assignment]
+            return DEFAULT_METACLASS_SPEC
+
+    elif isinstance(obj, ClassSpec):
+        cs = obj
+
+    else:
+        raise TypeError(obj)
+
+    return cs.get_last_metadata(MetaclassSpec, DEFAULT_METACLASS_SPEC)