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

omlish/dataclasses/processing/base.py

@@ -0,0 +1,83 @@
+"""
+TODO:
+ - Configurable? class Config crtc?
+  - all config on specs? prob not desirable purity, prob want ~some~ global config if only defaults
+   - ProcessorConfigSpecProviderFactoryThingy?
+  - FIXME: for now these are processor ctor kwargs that are never overridden
+"""
+import typing as ta
+
+from ... import check
+from ... import lang
+from ..specs import ClassSpec
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+ProcessingContextItemFactory: ta.TypeAlias = ta.Callable[['ProcessingContext'], ta.Any]
+
+
+class ProcessingContext:
+    def __init__(
+            self,
+            cls: type,
+            cs: ClassSpec,
+            item_factories: ta.Mapping[type, ProcessingContextItemFactory],
+            *,
+            options: ta.Sequence[ta.Any] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._cls = cls
+        self._cs = cs
+        self._item_factories = item_factories
+
+        options_dct: dict = {}
+        for o in options or ():
+            check.not_in(type(o), options_dct)
+            options_dct[type(o)] = o
+        self._options_dct = options_dct
+
+        self._items: dict = {}
+
+    @property
+    def cls(self) -> type:
+        return self._cls
+
+    @property
+    def cs(self) -> ClassSpec:
+        return self._cs
+
+    def __getitem__(self, ty: type[T]) -> T:
+        try:
+            return self._items[ty]
+        except KeyError:
+            pass
+
+        fac = self._item_factories[ty]
+        ret = fac(self)
+        self._items[ty] = ret
+        return ret
+
+    def option(self, ty: type[T]) -> T | None:
+        return self._options_dct.get(ty)
+
+
+##
+
+
+class Processor(lang.Abstract):
+    def __init__(self, ctx: ProcessingContext) -> None:
+        super().__init__()
+
+        self._ctx = ctx
+
+    def check(self) -> None:
+        pass
+
+    def process(self, cls: type) -> type:
+        return cls

omlish/dataclasses/processing/driving.py

@@ -0,0 +1,49 @@
+import typing as ta
+
+from .. import concerns as _concerns  # noqa  # imported for registration
+from ..generation import processor as gp
+from ..specs import ClassSpec
+from .base import ProcessingContext
+from .base import Processor
+from .registry import all_processing_context_item_factories
+from .registry import ordered_processor_types
+
+
+##
+
+
+def drive_cls_processing(
+        cls: type,
+        cs: ClassSpec,
+        *,
+        plan_only: bool = False,
+        verbose: bool = False,
+) -> type:
+    options: list[ta.Any] = []
+    if plan_only:
+        options.append(gp.PlanOnly(True))
+    if verbose:
+        options.append(gp.Verbose(True))
+
+    #
+
+    ctx = ProcessingContext(
+        cls,
+        cs,
+        all_processing_context_item_factories(),
+        options=options,
+    )
+
+    processors: list[Processor] = [
+        proc_cls(ctx)
+        for proc_cls in ordered_processor_types()
+    ]
+
+    for p in processors:
+        p.check()
+
+    ret = cls
+    for p in processors:
+        ret = p.process(ret)
+
+    return ret

omlish/dataclasses/processing/priority.py

@@ -0,0 +1,13 @@
+import enum
+
+
+class ProcessorPriority(enum.IntEnum):
+    BOOTSTRAP = enum.auto()
+
+    PRE_GENERATION = enum.auto()
+    GENERATION = enum.auto()
+    POST_GENERATION = enum.auto()
+
+    PRE_SLOTS = enum.auto()
+    SLOTS = enum.auto()
+    POST_SLOTS = enum.auto()

omlish/dataclasses/processing/registry.py

@@ -0,0 +1,81 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+from ... import lang
+from ..utils import SealableRegistry
+from .base import ProcessingContextItemFactory
+from .base import Processor
+from .priority import ProcessorPriority
+
+
+ProcessorT = ta.TypeVar('ProcessorT', bound=Processor)
+
+
+##
+
+
+_PROCESSING_CONTEXT_ITEM_FACTORIES: SealableRegistry[type, ProcessingContextItemFactory] = SealableRegistry()
+
+
+def register_processing_context_item_factory(i_ty):
+    def inner(fn):
+        _PROCESSING_CONTEXT_ITEM_FACTORIES[i_ty] = fn
+        return fn
+
+    return inner
+
+
+@lang.cached_function
+def processing_context_item_factory_for(i_ty: type) -> ProcessingContextItemFactory:
+    return _PROCESSING_CONTEXT_ITEM_FACTORIES[i_ty]
+
+
+@lang.cached_function
+def all_processing_context_item_factories() -> ta.Mapping[type, ProcessingContextItemFactory]:
+    return dict(_PROCESSING_CONTEXT_ITEM_FACTORIES.items())
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ProcessorTypeRegistration:
+    priority: ProcessorPriority
+
+
+_PROCESSOR_TYPES: SealableRegistry[type[Processor], ProcessorTypeRegistration] = SealableRegistry()
+
+
+def register_processor_type(
+        *,
+        priority: ProcessorPriority,
+        **kwargs: ta.Any,
+) -> ta.Callable[[type[ProcessorT]], type[ProcessorT]]:
+    reg = ProcessorTypeRegistration(
+        priority=priority,
+        **kwargs,
+    )
+
+    def inner(ty):
+        check.issubclass(ty, Processor)
+        _PROCESSOR_TYPES[ty] = reg
+        return ty
+
+    return inner
+
+
+@lang.cached_function
+def all_processor_types() -> ta.Mapping[type, ProcessorTypeRegistration]:
+    return dict(_PROCESSOR_TYPES.items())
+
+
+@lang.cached_function
+def ordered_processor_types() -> ta.Sequence[type]:
+    return [
+        t
+        for t, r in sorted(
+            all_processor_types().items(),
+            key=lambda t_r: t_r[1].priority,
+        )
+    ]

omlish/dataclasses/reflection.py

@@ -0,0 +1,81 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import lang
+from .api.classes.conversion import std_params_to_class_spec
+from .api.classes.params import get_class_spec
+from .api.fields.conversion import std_field_to_field_spec
+from .concerns.fields import InitFields
+from .concerns.fields import calc_init_fields
+from .inspect import FieldsInspection
+from .inspect import inspect_fields
+from .internals import STD_PARAMS_ATTR
+from .internals import StdFieldType
+from .internals import std_field_type
+from .specs import ClassSpec
+
+
+##
+
+
+class ClassReflection:
+    def __init__(self, cls: type) -> None:
+        super().__init__()
+
+        self._cls = cls
+
+    @property
+    def cls(self) -> type:
+        return self._cls
+
+    @lang.cached_property
+    def spec(self) -> ClassSpec:
+        if (cs := get_class_spec(self._cls)) is not None:
+            return cs
+
+        try:
+            p = getattr(self._cls, STD_PARAMS_ATTR)
+        except AttributeError:
+            raise TypeError(self._cls) from None
+
+        # This class was not constructed as one of our dataclasses, so surface no additional functionality even if
+        # present as extra_params or such.
+        fsl = [
+            std_field_to_field_spec(
+                f,
+                ignore_metadata=True,
+                ignore_extra_params=True,
+            )
+            for f in dc.fields(self._cls)  # noqa
+        ]
+
+        cs = std_params_to_class_spec(
+            p,
+            fsl,
+        )
+
+        return cs
+
+    @lang.cached_property
+    def fields_inspection(self) -> FieldsInspection:
+        return inspect_fields(self._cls)
+
+    @lang.cached_property
+    def init_fields(self) -> InitFields:
+        return calc_init_fields(
+            self.spec.fields,
+            reorder=self.spec.reorder,
+            class_kw_only=self.spec.kw_only,
+        )
+
+    @lang.cached_property
+    def fields(self) -> ta.Mapping[str, dc.Field]:
+        return {f.name: f for f in dc.fields(self._cls)}  # noqa
+
+    @lang.cached_property
+    def instance_fields(self) -> ta.Sequence[dc.Field]:
+        return [f for f in self.fields.values() if std_field_type(f) is StdFieldType.INSTANCE]
+
+
+def reflect(cls: type) -> ClassReflection:
+    return ClassReflection(cls)

omlish/dataclasses/specs.py

@@ -0,0 +1,224 @@
+"""Should be kept pure. No references to dc std, no references to impl detail."""
+import dataclasses as dc
+import enum
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+CoerceFn: ta.TypeAlias = ta.Callable[[ta.Any], ta.Any]
+ValidateFn: ta.TypeAlias = ta.Callable[[ta.Any], bool]
+ReprFn: ta.TypeAlias = ta.Callable[[ta.Any], str | None]
+
+InitFn: ta.TypeAlias = ta.Callable[[ta.Any], None]
+ClassValidateFn: ta.TypeAlias = ta.Callable[..., bool]
+
+
+class DefaultFactory(ta.NamedTuple):
+    fn: ta.Callable[..., ta.Any]
+
+
+##
+
+
+class FieldType(enum.StrEnum):
+    INSTANCE = enum.auto()
+    CLASS_VAR = enum.auto()
+    INIT_VAR = enum.auto()
+
+    __repr__ = lang.enum_name_repr
+
+
+@dc.dataclass(frozen=True, kw_only=True, eq=False)
+class FieldSpec(lang.Final):
+    name: str
+    annotation: ta.Any
+
+    default: lang.Maybe[DefaultFactory | ta.Any] = lang.empty()
+
+    ##
+    # std
+
+    init: bool = True
+    repr: bool = True
+
+    # This can be a bool or None. If true, this field is included in the generated __hash__() method. If false, this
+    # field is excluded from the generated __hash__(). If None (the default), use the value of compare: this would
+    # normally be the expected behavior, since a field should be included in the hash if it's used for comparisons.
+    # Setting this value to anything other than None is discouraged.
+    hash: bool | None = None  # FIXME: type?
+
+    compare: bool = True
+
+    # This can be a mapping or None. None is treated as an empty dict. This value is wrapped in MappingProxyType() to
+    # make it read-only, and exposed on the Field object. It is not used at all by Data Classes, and is provided as a
+    # third-party extension mechanism. Multiple third-parties can each have their own key, to use as a namespace in the
+    # metadata.
+    metadata: ta.Mapping[ta.Any, ta.Any] | None = None
+
+    kw_only: bool | None = None
+
+    # doc: ta.Any = None
+
+    ##
+    # ext
+
+    # derive: ta.Callable[..., ta.Any] | None = None  # NYI in core
+
+    coerce: bool | CoerceFn | None = None
+    validate: ValidateFn | None = None
+    check_type: bool | type | tuple[type | None, ...] | None = None
+
+    override: bool = False
+
+    repr_fn: ReprFn | None = None
+    repr_priority: int | None = None
+
+    # frozen: bool | None = None  # NYI in core
+
+    ##
+    # derived
+
+    field_type: FieldType = FieldType.INSTANCE
+
+    ##
+    # validate
+
+    def __post_init__(self) -> None:
+        check.non_empty_str(self.name)
+        check.arg(self.name.isidentifier())
+
+        if self.field_type in (FieldType.CLASS_VAR, FieldType.INIT_VAR):
+            if isinstance(self.default.or_else(None), DefaultFactory):
+                raise TypeError(f'field {self.name} cannot have a default factory')
+
+        if self.field_type is FieldType.CLASS_VAR:
+            if self.kw_only is not None:
+                raise TypeError(f'field {self.name} is a ClassVar but specifies kw_only')
+            check.none(self.coerce)
+            check.none(self.validate)
+            check.in_(self.check_type, (None, False))
+
+        if (
+                self.field_type is FieldType.INSTANCE and
+                self.default.present and
+                not isinstance(dfv := self.default.must(), DefaultFactory) and
+                dfv.__class__.__hash__ is None  # noqa
+        ):
+            raise ValueError(
+                f'mutable default {type(dfv)} for field {self.name} '
+                f'is not allowed: use default_factory',
+            )
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True, eq=False)
+class ClassSpec(lang.Final):
+    ##
+    # fields
+
+    fields: ta.Sequence[FieldSpec]
+
+    @property
+    def fields_by_name(self) -> ta.Mapping[str, FieldSpec]:
+        return self._fields_by_name
+
+    _fields_by_name: ta.ClassVar[ta.Mapping[str, FieldSpec]]
+
+    ##
+    # std
+
+    init: bool = True
+    repr: bool = True
+    eq: bool = True
+    order: bool = False
+    unsafe_hash: bool = False
+    frozen: bool = False
+
+    match_args: bool = True
+    kw_only: bool = False
+    slots: bool = False
+    weakref_slot: bool = False
+
+    ##
+    # ext
+
+    metadata: ta.Sequence[ta.Any] | None = None
+
+    @property
+    def metadata_by_type(self) -> ta.Mapping[type, ta.Sequence[ta.Any]]:
+        return self._metadata_by_type
+
+    _metadata_by_type: ta.ClassVar[ta.Mapping[type, ta.Sequence[ta.Any]]]
+
+    @ta.overload
+    def get_last_metadata(self, ty: type[T], default: T) -> T:
+        ...
+
+    @ta.overload
+    def get_last_metadata(self, ty: type[T], default: None = None) -> T | None:
+        ...
+
+    def get_last_metadata(self, ty, default=None):
+        try:
+            mdl = self._metadata_by_type[ty]
+        except KeyError:
+            return default
+        if not mdl:
+            return default
+        return mdl[-1]
+
+    #
+
+    reorder: bool = False
+    cache_hash: bool = False
+    generic_init: bool = False
+    override: bool = False
+    repr_id: bool = False
+
+    ##
+    # callbacks
+
+    init_fns: ta.Sequence[InitFn | property] | None = None
+
+    @dc.dataclass(frozen=True)
+    class ValidateFnWithParams:
+        fn: ClassValidateFn
+        params: ta.Sequence[str]
+
+        def __post_init__(self) -> None:
+            check.not_isinstance(self.params, str)
+
+    validate_fns: ta.Sequence[ValidateFnWithParams] | None = None
+
+    ##
+    # validate
+
+    def __post_init__(self) -> None:
+        fields_by_name: dict[str, FieldSpec] = {}
+        for f in self.fields:
+            check.not_in(f.name, fields_by_name)
+            fields_by_name[f.name] = f
+        object.__setattr__(self, '_fields_by_name', fields_by_name)
+
+        metadata_by_type: dict[type, list[ta.Any]] = {}
+        for md in self.metadata or ():
+            mdt = type(md)
+            try:
+                mdl = metadata_by_type[mdt]
+            except KeyError:
+                mdl = metadata_by_type[mdt] = []
+            mdl.append(md)
+        object.__setattr__(self, '_metadata_by_type', metadata_by_type)
+
+        if self.order and not self.eq:
+            raise ValueError('eq must be true if order is true')

omlish/dataclasses/{impl → tools}/as_.py

@@ -1,21 +1,25 @@
 import copy
 import dataclasses as dc
+import typing as ta
 
-from .internals import ATOMIC_TYPES
-from .internals import is_dataclass_instance
+from ..internals import STD_ATOMIC_TYPES
+from ..internals import std_is_dataclass_instance
+
+
+##
 
 
 def asdict(obj, *, dict_factory=dict):  # noqa
-    if not is_dataclass_instance(obj):  # noqa
+    if not std_is_dataclass_instance(obj):  # noqa
         raise TypeError('asdict() should be called on dataclass instances')
     return _asdict_inner(obj, dict_factory)
 
 
 def _asdict_inner(obj, dict_factory):
-    if type(obj) in ATOMIC_TYPES:
+    if type(obj) in STD_ATOMIC_TYPES:
         return obj
 
-    elif is_dataclass_instance(obj):
+    elif std_is_dataclass_instance(obj):
         l = []
         for f in dc.fields(obj):
             value = _asdict_inner(getattr(obj, f.name), dict_factory)
@@ -41,16 +45,16 @@ def _asdict_inner(obj, dict_factory):
 
 
 def astuple(obj, *, tuple_factory=tuple):  # noqa
-    if not is_dataclass_instance(obj):
+    if not std_is_dataclass_instance(obj):
         raise TypeError('astuple() should be called on dataclass instances')
     return _astuple_inner(obj, tuple_factory)
 
 
 def _astuple_inner(obj, tuple_factory):
-    if type(obj) in ATOMIC_TYPES:
+    if type(obj) in STD_ATOMIC_TYPES:
         return obj
 
-    elif is_dataclass_instance(obj):
+    elif std_is_dataclass_instance(obj):
         l = []
         for f in dc.fields(obj):
             value = _astuple_inner(getattr(obj, f.name), tuple_factory)
@@ -74,3 +78,14 @@ def _astuple_inner(obj, tuple_factory):
 
     else:
         return copy.deepcopy(obj)
+
+
+##
+
+
+def shallow_astuple(o: ta.Any) -> tuple[ta.Any, ...]:
+    return tuple(getattr(o, f.name) for f in dc.fields(o))
+
+
+def shallow_asdict(o: ta.Any) -> dict[str, ta.Any]:
+    return {f.name: getattr(o, f.name) for f in dc.fields(o)}

omlish/dataclasses/tools/iter.py

@@ -0,0 +1,27 @@
+import dataclasses as dc
+import typing as ta
+
+
+##
+
+
+def fields_dict(cls_or_instance: ta.Any) -> dict[str, dc.Field]:
+    return {f.name: f for f in dc.fields(cls_or_instance)}
+
+
+##
+
+
+def iter_items(obj: ta.Any) -> ta.Iterator[tuple[str, ta.Any]]:
+    for f in dc.fields(obj):
+        yield (f.name, getattr(obj, f.name))
+
+
+def iter_keys(obj: ta.Any) -> ta.Iterator[str]:
+    for f in dc.fields(obj):
+        yield f.name
+
+
+def iter_values(obj: ta.Any) -> ta.Iterator[ta.Any]:
+    for f in dc.fields(obj):
+        yield getattr(obj, f.name)

omlish/dataclasses/tools/modifiers.py

@@ -0,0 +1,52 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import check
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class field_modifier:  # noqa
+    def __init__(self, fn: ta.Callable[[dc.Field], dc.Field]) -> None:
+        super().__init__()
+        self.fn = fn
+
+    def __ror__(self, other: T) -> T:
+        return self(other)
+
+    def __call__(self, f: T) -> T:
+        return check.isinstance(self.fn(check.isinstance(f, dc.Field)), dc.Field)  # type: ignore
+
+
+##
+
+
+def update_fields(
+        fn: ta.Callable[[str, dc.Field], dc.Field],
+        fields: ta.Iterable[str] | None = None,
+) -> ta.Callable[[type[T]], type[T]]:
+    def inner(cls):
+        if fields is None:
+            for a, v in list(cls.__dict__.items()):
+                if isinstance(v, dc.Field):
+                    setattr(cls, a, fn(a, v))
+
+        else:
+            for a in fields:
+                try:
+                    v = cls.__dict__[a]
+                except KeyError:
+                    v = dc.field()
+                else:
+                    if not isinstance(v, dc.Field):
+                        v = dc.field(default=v)
+                setattr(cls, a, fn(a, v))
+
+        return cls
+
+    check.not_isinstance(fields, str)
+    return inner

omlish/dataclasses/tools/replace.py

@@ -0,0 +1,17 @@
+import dataclasses as dc
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+def deep_replace(o: T, *args: str | ta.Callable[[ta.Any], ta.Mapping[str, ta.Any]]) -> T:
+    if not args:
+        return o
+    elif len(args) == 1:
+        return dc.replace(o, **args[0](o))  # type: ignore
+    else:
+        return dc.replace(o, **{args[0]: deep_replace(getattr(o, args[0]), *args[1:])})  # type: ignore