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

omlish/dataclasses/impl/metadata.py

@@ -1,75 +0,0 @@
-import types
-import typing as ta
-
-from ... import lang
-
-
-METADATA_ATTR = '__dataclass_metadata__'
-
-Metadata: ta.TypeAlias = ta.Mapping[ta.Any, ta.Any]
-
-EMPTY_METADATA: Metadata = types.MappingProxyType({})
-
-_CLASS_MERGED_KEYS: set[str] = set()
-CLASS_MERGED_KEYS: ta.AbstractSet = _CLASS_MERGED_KEYS
-
-
-def _class_merged(o):
-    _CLASS_MERGED_KEYS.add(o)
-    return o
-
-
-def get_merged_metadata(obj: ta.Any) -> Metadata:
-    cls = obj if isinstance(obj, type) else type(obj)
-    dct: dict[ta.Any, ta.Any] = {}
-    for cur in cls.__mro__[::-1]:
-        if not (smd := cur.__dict__.get(METADATA_ATTR)):
-            continue
-        for k, v in smd.items():
-            if k in CLASS_MERGED_KEYS:
-                dct.setdefault(k, []).extend(v)
-            else:
-                dct[k] = v
-    return dct
-
-
-def _append_cls_md(k, v):
-    lang.get_caller_cls_dct(1).setdefault(METADATA_ATTR, {}).setdefault(k, []).append(v)
-
-
-##
-
-
-@_class_merged
-class UserMetadata(lang.Marker):
-    pass
-
-
-@lang.cls_dct_fn()
-def metadata(cls_dct, *args) -> None:
-    cls_dct.setdefault(METADATA_ATTR, {}).setdefault(UserMetadata, []).extend(args)
-
-
-##
-
-
-@_class_merged
-class Validate(lang.Marker):
-    pass
-
-
-def validate(fn: ta.Callable[..., bool] | staticmethod) -> None:
-    _append_cls_md(Validate, fn)
-
-
-##
-
-
-@_class_merged
-class Init(lang.Marker):
-    pass
-
-
-def init(obj):
-    _append_cls_md(Init, obj)
-    return obj

omlish/dataclasses/impl/order.py

@@ -1,57 +0,0 @@
-import typing as ta
-
-from .processing import Processor
-from .utils import Namespace
-from .utils import create_fn
-from .utils import set_new_attribute
-from .utils import tuple_str
-
-
-def cmp_fn(
-        name: str,
-        op: str,
-        self_tuple: str,
-        other_tuple: str,
-        globals: Namespace,  # noqa
-) -> ta.Callable:
-    return create_fn(
-        name,
-        ('self', 'other'),
-        [
-            'if other.__class__ is self.__class__:',
-            f' return {self_tuple}{op}{other_tuple}',
-            'return NotImplemented',
-        ],
-        globals=globals,
-    )
-
-
-class OrderProcessor(Processor):
-    def _process(self) -> None:
-        if not self._info.params.order:
-            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)
-        for name, op in [
-            ('__lt__', '<'),
-            ('__le__', '<='),
-            ('__gt__', '>'),
-            ('__ge__', '>='),
-        ]:
-            if set_new_attribute(
-                    self._cls,  # noqa
-                    name,
-                    cmp_fn(
-                        name,
-                        op,
-                        self_tuple,
-                        other_tuple,
-                        globals=self._info.globals,
-                    ),
-            ):
-                raise TypeError(
-                    f'Cannot overwrite attribute {name} in class {self._cls.__name__}. '
-                    f'Consider using functools.total_ordering',
-                )

omlish/dataclasses/impl/overrides.py

@@ -1,53 +0,0 @@
-from ... import lang
-from .fields import field_assign
-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 or self._info.params_extras.override):
-                continue
-
-            if self._info.params.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,
-                            True,
-                        ),
-                    ],
-                    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,
-            )

omlish/dataclasses/impl/params.py

@@ -1,128 +0,0 @@
-"""
-@dc.dataclass(frozen=True)
-class Field_:
-    name: str | None = None
-    type: Any = None
-    default: Any | MISSING = MISSING
-    default_factory: Any | MISSING = MISSING
-    repr: bool = True
-    hash: bool | None = None
-    init: bool = True
-    compare: bool = True
-    metadata: Metadata | None = None
-    kw_only: bool | MISSING = MISSING
-
-    if sys.version_info >= (3, 13):
-        doc: str | None = None
-
-    _field_type: Any = None
-
-
-@dc.dataclass(frozen=True)
-class Params_:
-    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
-"""
-import dataclasses as dc
-import typing as ta
-
-from ... import lang
-from .internals import PARAMS_ATTR
-from .internals import Params
-from .metadata import EMPTY_METADATA
-from .metadata import METADATA_ATTR
-
-
-##
-
-
-@dc.dataclass(frozen=True, kw_only=True)
-class FieldExtras(lang.Final):
-    derive: ta.Callable[..., ta.Any] | None = None  # TODO
-    coerce: bool | ta.Callable[[ta.Any], ta.Any] | None = None
-    validate: ta.Callable[[ta.Any], bool] | None = None
-    check_type: bool | type | tuple[type | None, ...] | None = None
-    override: bool = False
-    repr_fn: ta.Callable[[ta.Any], str | None] | None = None
-    repr_priority: int | None = None
-    frozen: bool | None = None  # TODO
-
-
-DEFAULT_FIELD_EXTRAS = FieldExtras()
-
-
-def get_field_extras(f: dc.Field) -> FieldExtras:
-    if not isinstance(f, dc.Field):
-        raise TypeError(f)
-    return f.metadata.get(FieldExtras, DEFAULT_FIELD_EXTRAS)
-
-
-##
-
-
-def get_params_cls(obj: ta.Any) -> type | None:
-    if not isinstance(obj, type):
-        obj = type(obj)
-    for cur in obj.__mro__:
-        if PARAMS_ATTR in cur.__dict__:
-            return cur
-    return None
-
-
-def get_params(obj: ta.Any) -> Params:
-    if not hasattr(obj, PARAMS_ATTR):
-        raise TypeError(obj)
-    return getattr(obj, PARAMS_ATTR)
-
-
-##
-
-
-@dc.dataclass(frozen=True, kw_only=True)
-class ParamsExtras(lang.Final):
-    reorder: bool = False
-    cache_hash: bool = False
-    generic_init: bool = False
-    override: bool = False
-    repr_id: bool = False
-
-
-DEFAULT_PARAMS_EXTRAS = ParamsExtras()
-
-
-def get_params_extras(obj: ta.Any) -> ParamsExtras:
-    if (pcls := get_params_cls(obj)) is None:
-        raise TypeError(pcls)
-
-    md = pcls.__dict__.get(METADATA_ATTR, EMPTY_METADATA)
-    return md.get(ParamsExtras, DEFAULT_PARAMS_EXTRAS)
-
-
-##
-
-
-@dc.dataclass(frozen=True)
-class MetaclassParams:
-    confer: frozenset[str] = frozenset()
-    final_subclasses: bool = False
-    abstract_immediate_subclasses: bool = False
-
-
-DEFAULT_METACLASS_PARAMS = MetaclassParams()
-
-
-def get_metaclass_params(obj: ta.Any) -> MetaclassParams:
-    if (pcls := get_params_cls(obj)) is None:
-        raise TypeError(pcls)
-
-    md = pcls.__dict__.get(METADATA_ATTR, EMPTY_METADATA)
-    return md.get(MetaclassParams, DEFAULT_METACLASS_PARAMS)

omlish/dataclasses/impl/processing.py

@@ -1,24 +0,0 @@
-import typing as ta
-
-from ... import lang
-
-
-if ta.TYPE_CHECKING:
-    from .reflect import ClassInfo
-
-
-class Processor(lang.Abstract):
-    def __init__(self, info: 'ClassInfo') -> None:
-        super().__init__()
-        self._cls = info.cls
-        self._info = info
-
-    def check(self) -> None:
-        pass
-
-    @lang.cached_function
-    def process(self) -> None:
-        self._process()
-
-    def _process(self) -> None:
-        raise NotImplementedError

omlish/dataclasses/impl/replace.py

@@ -1,40 +0,0 @@
-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):  # noqa
-    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

@@ -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])},)'