omlish 0.0.0.dev219__py3-none-any.whl → 0.0.0.dev221__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev219'
-__revision__ = '5e741e0670fb75899653bd454587a1cf2add710f'
+__version__ = '0.0.0.dev221'
+__revision__ = '2c4c1480e414176972a21bd34529721b39818ad8'
 
 
 #

omlish/algorithm/all.py

@@ -0,0 +1,13 @@
+from .distribute import (  # noqa
+    distribute_evenly,
+)
+
+from .toposort import (  # noqa
+    mut_toposort,
+    toposort,
+)
+
+from .unify import (  # noqa
+    mut_unify_sets,
+    unify_sets,
+)

omlish/algorithm/distribute.py

@@ -0,0 +1,46 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import collections
+import heapq
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def distribute_evenly(
+        items: ta.Iterable[ta.Tuple[T, float]],
+        n_bins: int,
+) -> ta.List[ta.List[ta.Tuple[T, float]]]:
+    """
+    Distribute items into n bins as evenly as possible in terms of total size.
+     - Sorting ensures larger items are placed first, preventing large leftover gaps in bins.
+     - A min-heap efficiently finds the least loaded bin in O(log n), keeping the distribution balanced.
+     - Each item is placed in the lightest bin, preventing a few bins from getting overloaded early.
+
+    :param items: List of tuples (item, size).
+    :param n_bins: Number of bins.
+    :return: List of n_bins lists, each containing items assigned to that bin.
+    """
+
+    # Sort items by size in descending order
+    items_sorted = sorted(items, key=lambda x: x[1], reverse=True)
+
+    # Min-heap to track bin loads (size, index)
+    bins = [(0, i) for i in range(n_bins)]  # (current size, bin index)
+    heapq.heapify(bins)
+
+    # Allocate items to bins
+    bin_contents = collections.defaultdict(list)
+
+    for item, size in items_sorted:
+        # Get the least loaded bin
+        bin_size, bin_index = heapq.heappop(bins)
+
+        # Assign item to this bin
+        bin_contents[bin_index].append((item, size))
+
+        # Update bin load and push back to heap
+        heapq.heappush(bins, (bin_size + size, bin_index))  # type: ignore
+
+    return [bin_contents[i] for i in range(n_bins)]

omlish/algorithm/toposort.py

@@ -0,0 +1,26 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import functools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def mut_toposort(data: ta.Dict[T, ta.Set[T]]) -> ta.Iterator[ta.Set[T]]:
+    for k, v in data.items():
+        v.discard(k)
+    extra_items_in_deps = functools.reduce(set.union, data.values()) - set(data.keys())
+    data.update({item: set() for item in extra_items_in_deps})
+    while True:
+        ordered = {item for item, dep in data.items() if not dep}
+        if not ordered:
+            break
+        yield ordered
+        data = {item: (dep - ordered) for item, dep in data.items() if item not in ordered}
+    if data:
+        raise ValueError('Cyclic dependencies exist among these items: ' + ' '.join(repr(x) for x in data.items()))
+
+
+def toposort(data: ta.Mapping[T, ta.AbstractSet[T]]) -> ta.Iterator[ta.Set[T]]:
+    return mut_toposort({k: set(v) for k, v in data.items()})

omlish/algorithm/unify.py

@@ -0,0 +1,31 @@
+import itertools
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+def mut_unify_sets(sets: ta.Iterable[set[T]]) -> list[set[T]]:
+    rem: list[set[T]] = list(sets)
+    ret: list[set[T]] = []
+    while rem:
+        cur = rem.pop()
+        while True:
+            moved = False
+            for i in range(len(rem) - 1, -1, -1):
+                if any(e in cur for e in rem[i]):
+                    cur.update(rem.pop(i))
+                    moved = True
+            if not moved:
+                break
+        ret.append(cur)
+    if ret:
+        all_ = set(itertools.chain.from_iterable(ret))
+        num = sum(map(len, ret))
+        if len(all_) != num:
+            raise ValueError('Length mismatch')
+    return ret
+
+
+def unify_sets(sets: ta.Iterable[ta.AbstractSet[T]]) -> list[set[T]]:
+    return mut_unify_sets([set(s) for s in sets])

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/collections/__init__.py

@@ -126,8 +126,6 @@ from .utils import (  # noqa
     make_map_by,
     multi_map,
     multi_map_by,
-    mut_toposort,
     partition,
-    toposort,
     unique,
 )

omlish/collections/utils.py

@@ -1,8 +1,5 @@
-import functools
-import itertools
 import typing as ta
 
-from .. import check
 from .. import lang
 from .exceptions import DuplicateKeyError
 from .identity import IdentityKeyDict
@@ -17,28 +14,6 @@ V = ta.TypeVar('V')
 ##
 
 
-def mut_toposort(data: dict[T, set[T]]) -> ta.Iterator[set[T]]:
-    for k, v in data.items():
-        v.discard(k)
-    extra_items_in_deps = functools.reduce(set.union, data.values()) - set(data.keys())
-    data.update({item: set() for item in extra_items_in_deps})
-    while True:
-        ordered = {item for item, dep in data.items() if not dep}
-        if not ordered:
-            break
-        yield ordered
-        data = {item: (dep - ordered) for item, dep in data.items() if item not in ordered}
-    if data:
-        raise ValueError('Cyclic dependencies exist among these items: ' + ' '.join(repr(x) for x in data.items()))
-
-
-def toposort(data: ta.Mapping[T, ta.AbstractSet[T]]) -> ta.Iterator[set[T]]:
-    return mut_toposort({k: set(v) for k, v in data.items()})
-
-
-##
-
-
 class PartitionResult(ta.NamedTuple, ta.Generic[T]):
     t: list[T]
     f: list[T]
@@ -153,24 +128,3 @@ def key_cmp(fn: ta.Callable[[K, K], int]) -> ta.Callable[[tuple[K, V], tuple[K,
 
 def indexes(it: ta.Iterable[T]) -> dict[T, int]:
     return {e: i for i, e in enumerate(it)}
-
-
-def mut_unify_sets(sets: ta.Iterable[set[T]]) -> list[set[T]]:
-    rem: list[set[T]] = list(sets)
-    ret: list[set[T]] = []
-    while rem:
-        cur = rem.pop()
-        while True:
-            moved = False
-            for i in range(len(rem) - 1, -1, -1):
-                if any(e in cur for e in rem[i]):
-                    cur.update(rem.pop(i))
-                    moved = True
-            if not moved:
-                break
-        ret.append(cur)
-    if ret:
-        all_ = set(itertools.chain.from_iterable(ret))
-        num = sum(map(len, ret))
-        check.equal(len(all_), num)
-    return ret

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()