omlish 0.0.0.dev218__py3-none-any.whl → 0.0.0.dev220__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev218'
-__revision__ = '0d15b9d5ec9832621506a90856baf7d140dd63ad'
+__version__ = '0.0.0.dev220'
+__revision__ = '3af8855e48e09d340dd21835f45fe8a21a262fa9'
 
 
 #
@@ -42,7 +42,7 @@ class Project(ProjectBase):
         ],
 
         'compress': [
-            'lz4 ~= 4.3',
+            'lz4 ~= 4.4',
             # 'lz4 @ git+https://github.com/wrmsr/python-lz4@wrmsr_20240830_GIL_NOT_USED'
 
             'python-snappy ~= 0.7',

omlish/antlr/dot.py

@@ -1,12 +1,19 @@
+import typing as ta
+
 from ..graphs import dot
 from . import runtime as antlr4
 from .utils import yield_contexts
 
 
-def dot_ctx(root: antlr4.ParserRuleContext) -> dot.Graph:
-    stmts: list[dot.Stmt] = [
-        dot.RawStmt('rankdir=LR;'),
-    ]
+def dot_ctx(
+        root: antlr4.ParserRuleContext,
+        *,
+        left_to_right: bool = False,
+) -> dot.Graph:
+    stmts: list[dot.Stmt] = []
+
+    if left_to_right:
+        stmts.append(dot.RawStmt('rankdir=LR;'))
 
     for c in yield_contexts(root):
         if isinstance(c, antlr4.TerminalNode):
@@ -27,5 +34,5 @@ def dot_ctx(root: antlr4.ParserRuleContext) -> dot.Graph:
     return dot.Graph(stmts)
 
 
-def open_dot_ctx(root: antlr4.ParserRuleContext) -> None:
-    dot.open_dot(dot.render(dot_ctx(root)))
+def open_dot_ctx(root: antlr4.ParserRuleContext, **kwargs: ta.Any) -> None:
+    dot.open_dot(dot.render(dot_ctx(root)), **kwargs)

omlish/dataclasses/__init__.py

@@ -67,6 +67,7 @@ from .impl.metaclass import (  # noqa
     DataMeta,
     Data,
     Frozen,
+    Case,
     Box,
 )
 

omlish/dataclasses/impl/api.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - fix code redundancy
+"""
 import collections.abc
 import contextlib
 import dataclasses as dc
@@ -91,6 +95,7 @@ def dataclass(  # noqa
         reorder=MISSING,
         cache_hash=MISSING,
         generic_init=MISSING,
+        override=MISSING,
 ):
     def wrap(cls):
         pkw = dict(
@@ -113,6 +118,7 @@ def dataclass(  # noqa
             reorder=reorder,
             cache_hash=cache_hash,
             generic_init=generic_init,
+            override=override,
         )))
         pex = ParamsExtras(**epk)
 
@@ -161,6 +167,7 @@ def make_dataclass(  # noqa
         reorder=MISSING,
         cache_hash=MISSING,
         generic_init=MISSING,
+        override=MISSING,
 ):
     if namespace is None:
         namespace = {}
@@ -221,6 +228,7 @@ def make_dataclass(  # noqa
         reorder=reorder,
         cache_hash=cache_hash,
         generic_init=generic_init,
+        override=override,
     )
 
 
@@ -233,6 +241,7 @@ def extra_params(  # noqa
         reorder=MISSING,
         cache_hash=MISSING,
         generic_init=MISSING,
+        override=MISSING,
 ):
     def inner(cls):
         if PARAMS_ATTR in cls.__dict__:
@@ -249,6 +258,7 @@ def extra_params(  # noqa
             reorder=reorder,
             cache_hash=cache_hash,
             generic_init=generic_init,
+            override=override,
         ))
 
         return cls

omlish/dataclasses/impl/fields.py

@@ -165,6 +165,7 @@ def field_init(
         locals: dict[str, ta.Any],  # noqa
         self_name: str,
         slots: bool,
+        cls_override: bool,
 ) -> ta.Sequence[str]:
     default_name = f'__dataclass_dflt_{f.name}__'
     fx = get_field_extras(f)
@@ -235,6 +236,12 @@ def field_init(
         )
 
     if value is not None and field_type(f) is not FieldType.INIT:
-        lines.append(field_assign(frozen, f.name, value, self_name, fx.override))  # noqa
+        lines.append(field_assign(
+            frozen,
+            f.name,
+            value,
+            self_name,
+            fx.override or cls_override,
+        ))
 
     return lines

omlish/dataclasses/impl/init.py

@@ -74,7 +74,6 @@ def init_param(f: dc.Field) -> str:
 
 
 class InitBuilder:
-
     def __init__(
             self,
             info: ClassInfo,
@@ -128,6 +127,7 @@ class InitBuilder:
                 locals,
                 self._self_name,
                 self._info.params.slots,
+                self._info.params_extras.override,
             )
 
             if f_lines:

omlish/dataclasses/impl/main.py

@@ -13,6 +13,7 @@ from .internals import FIELDS_ATTR
 from .internals import PARAMS_ATTR
 from .internals import Params
 from .order import OrderProcessor
+from .overrides import OverridesProcessor
 from .params import ParamsExtras
 from .processing import Processor
 from .reflect import ClassInfo
@@ -21,7 +22,6 @@ from .repr import ReprProcessor
 from .simple import DocProcessor
 from .simple import EqProcessor
 from .simple import MatchArgsProcessor
-from .simple import OverridesProcessor
 from .slots import add_slots
 
 

omlish/dataclasses/impl/metaclass.py

@@ -9,6 +9,7 @@ import dataclasses as dc
 import typing as ta
 
 from ... import lang
+from .api import MISSING
 from .api import dataclass
 from .api import field  # noqa
 from .params import MetaclassParams
@@ -20,6 +21,28 @@ from .params import get_params_extras
 T = ta.TypeVar('T')
 
 
+##
+
+
+_CONFER_PARAMS: tuple[str, ...] = (
+    'frozen',
+    'kw_only',
+)
+
+_CONFER_PARAMS_EXTRAS: tuple[str, ...] = (
+    '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:
@@ -44,22 +67,13 @@ def confer_kwargs(
             if ck in kwargs:
                 continue
 
-            if ck in (
-                    'frozen',
-                    'kw_only',
-            ):
+            if ck in _CONFER_PARAMS:
                 confer_kwarg(out, ck, getattr(get_params(base), ck))
 
-            elif ck in (
-                    'cache_hash',
-                    'generic_init',
-                    'reorder',
-            ):
+            elif ck in _CONFER_PARAMS_EXTRAS:
                 confer_kwarg(out, ck, getattr(get_params_extras(base), ck))
 
-            elif ck in (
-                    'confer',
-            ):
+            elif ck in _CONFER_METACLASS_PARAMS:
                 confer_kwarg(out, ck, getattr(bmp, ck))
 
             else:
@@ -68,6 +82,9 @@ def confer_kwargs(
     return out
 
 
+##
+
+
 class DataMeta(abc.ABCMeta):
     def __new__(
             mcls,
@@ -76,25 +93,21 @@ class DataMeta(abc.ABCMeta):
             namespace,
             *,
 
-            # confer=frozenset(),
+            abstract=False,
+            sealed=False,
+            final=False,
 
             metadata=None,
             **kwargs,
     ):
-        cls = lang.super_meta(
-            super(),
-            mcls,
-            name,
-            bases,
-            namespace,
-        )
-
         ckw = confer_kwargs(bases, kwargs)
         nkw = {**kwargs, **ckw}
 
-        mcp = MetaclassParams(
-            confer=nkw.pop('confer', frozenset()),
-        )
+        mcp = MetaclassParams(**{
+            mpa: nkw.pop(mpa)
+            for mpa in _CONFER_METACLASS_PARAMS
+            if mpa in nkw
+        })
 
         mmd = {
             MetaclassParams: mcp,
@@ -104,13 +117,74 @@ class DataMeta(abc.ABCMeta):
         else:
             metadata = mmd
 
+        #
+
+        xbs: list[type] = []
+
+        if any(get_metaclass_params(b).abstract_immediate_subclasses 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, 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)
 
 
+##
+
+
 # @ta.dataclass_transform(field_specifiers=(field,))  # FIXME: ctor
 class Data(
     eq=False,
     order=False,
+    confer=frozenset([
+        'confer',
+        'final_subclasses',
+    ]),
     metaclass=DataMeta,
 ):
     def __init__(self, *args, **kwargs):
@@ -132,24 +206,33 @@ class Frozen(
     eq=False,
     order=False,
     confer=frozenset([
+        *get_metaclass_params(Data).confer,
         'frozen',
-        'cache_hash',
-        'confer',
         '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([
-        'frozen',
-        'cache_hash',
+        *get_metaclass_params(Frozen).confer,
         'generic_init',
-        'confer',
     ]),
 ):
     v: T

omlish/dataclasses/impl/overrides.py

@@ -0,0 +1,53 @@
+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

@@ -91,6 +91,7 @@ class ParamsExtras(lang.Final):
     reorder: bool = False
     cache_hash: bool = False
     generic_init: bool = False
+    override: bool = False
 
 
 DEFAULT_PARAMS_EXTRAS = ParamsExtras()
@@ -110,6 +111,8 @@ def get_params_extras(obj: ta.Any) -> ParamsExtras:
 @dc.dataclass(frozen=True)
 class MetaclassParams:
     confer: frozenset[str] = frozenset()
+    final_subclasses: bool = False
+    abstract_immediate_subclasses: bool = False
 
 
 DEFAULT_METACLASS_PARAMS = MetaclassParams()

omlish/dataclasses/impl/reflect.py

@@ -30,8 +30,20 @@ from .utils import Namespace
 MISSING = dc.MISSING
 
 
-class ClassInfo:
+##
+
+
+def get_cls_annotations(cls: type) -> ta.Mapping[str, ta.Any]:
+    # 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)
+
+
+##
 
+
+class ClassInfo:
     def __init__(self, cls: type, *, _constructing: bool = False) -> None:
         check.isinstance(cls, type)
         self._constructing = _constructing
@@ -53,10 +65,7 @@ class ClassInfo:
 
     @cached.property
     def cls_annotations(self) -> ta.Mapping[str, ta.Any]:
-        # 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(self._cls)
+        return get_cls_annotations(self._cls)
 
     ##
 
@@ -157,6 +166,9 @@ 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()
 
 

omlish/dataclasses/impl/simple.py

@@ -1,53 +1,11 @@
 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.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, 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: