omlish 0.0.0.dev266__tar.gz → 0.0.0.dev267__tar.gz

{omlish-0.0.0.dev266/omlish.egg-info → omlish-0.0.0.dev267}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev266
+Version: 0.0.0.dev267
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev266'
-__revision__ = '965387f5aa0862e8b1e30cbd03e24adb0a3e87bc'
+__version__ = '0.0.0.dev267'
+__revision__ = '9dca65827e8e4dae7ca1296a78c7a4d88a946259'
 
 
 #

omlish-0.0.0.dev267/omlish/collections/kv/transformed.py

@@ -0,0 +1,126 @@
+import typing as ta
+
+from ... import check
+from .base import Kv
+from .base import MutableKv
+from .wrappers import WrapperKv
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+# 'Above' the wrapper
+KA = ta.TypeVar('KA')
+VA = ta.TypeVar('VA')
+
+# 'Below' the wrapper
+KB = ta.TypeVar('KB')
+VB = ta.TypeVar('VB')
+
+
+##
+
+
+class KeyTransformedKv(WrapperKv[KA, V], ta.Generic[KA, KB, V]):
+    def __init__(
+            self,
+            u: Kv[KB, V],
+            *,
+            a_to_b: ta.Callable[[KA], KB] | None = None,
+            b_to_a: ta.Callable[[KB], KA] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._u = u
+        self._a_to_b = a_to_b
+        self._b_to_a = b_to_a
+
+    def underlying(self) -> ta.Sequence[Kv]:
+        return [self._u]
+
+    def __getitem__(self, k: KA, /) -> V:
+        fn = check.not_none(self._a_to_b)
+        return self._u[fn(k)]
+
+    def __len__(self) -> int:
+        return len(self._u)
+
+    def items(self) -> ta.Iterator[tuple[KA, V]]:
+        fn = check.not_none(self._b_to_a)
+        return ((fn(k), v) for k, v in self._u.items())
+
+
+class KeyTransformedMutableKey(KeyTransformedKv[KA, KB, V], MutableKv[KA, V], ta.Generic[KA, KB, V]):
+    def __init__(
+            self,
+            u: MutableKv[KB, V],
+            *,
+            a_to_b: ta.Callable[[KA], KB] | None = None,
+            b_to_a: ta.Callable[[KB], KA] | None = None,
+    ) -> None:
+        super().__init__(
+            u,
+            a_to_b=a_to_b,
+            b_to_a=b_to_a,
+        )
+
+    _u: MutableKv[KB, V]
+
+    def __setitem__(self, k: KA, v: V, /) -> None:
+        fn = check.not_none(self._a_to_b)
+        self._u[fn(k)] = v
+
+    def __delitem__(self, k: KA, /) -> None:
+        fn = check.not_none(self._a_to_b)
+        del self._u[fn(k)]
+
+
+##
+
+
+class ValueTransformedKv(WrapperKv[K, VA], ta.Generic[K, VA, VB]):
+    def __init__(
+            self,
+            u: Kv[K, VB],
+            b_to_a: ta.Callable[[VB], VA] | None = None,
+    ) -> None:
+        super().__init__()
+
+        self._u = u
+        self._b_to_a = b_to_a
+
+    def underlying(self) -> ta.Sequence[Kv]:
+        return [self._u]
+
+    def __getitem__(self, k: K, /) -> VA:
+        fn = check.not_none(self._b_to_a)
+        return fn(self._u[k])
+
+    def __len__(self) -> int:
+        return len(self._u)
+
+    def items(self) -> ta.Iterator[tuple[K, VA]]:
+        fn = check.not_none(self._b_to_a)
+        return ((k, fn(v)) for k, v in self._u.items())
+
+
+class ValueTransformedMutableKv(ValueTransformedKv[K, VA, VB], MutableKv[K, VA], ta.Generic[K, VA, VB]):
+    def __init__(
+            self,
+            u: MutableKv[K, VB],
+            *,
+            b_to_a: ta.Callable[[VB], VA] | None = None,
+            a_to_b: ta.Callable[[VA], VB] | None = None,
+    ) -> None:
+        super().__init__(u, b_to_a)
+
+        self._a_to_b = a_to_b
+
+    _u: MutableKv[K, VB]
+
+    def __setitem__(self, k: K, v: VA, /) -> None:
+        fn = check.not_none(self._a_to_b)
+        self._u[k] = fn(v)
+
+    def __delitem__(self, k: K, /) -> None:
+        del self._u[k]

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267}/omlish/dataclasses/impl/init.py

@@ -147,7 +147,7 @@ class InitBuilder:
             body_lines.append(f'if not {cn}({cas}): __dataclass_raise_validation_error__({self._self_name}, {cn})')
 
         inits = self._info.merged_metadata.get(Init, [])
-        mro_dct = lang.build_mro_dict(self._info.cls)
+        mro_dct = lang.mro_dict(self._info.cls)
         mro_v_ids = set(map(id, mro_dct.values()))
         props_by_fget_id = {id(v.fget): v for v in mro_dct.values() if isinstance(v, property) and v.fget is not None}
         for i, obj in enumerate(inits):

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267}/omlish/dispatch/methods.py

@@ -78,7 +78,7 @@ class Method:
     def build_attr_dispatcher(self, instance_cls: type, owner_cls: type | None = None) -> Dispatcher[str]:
         disp: Dispatcher[str] = Dispatcher()
 
-        mro_dct = lang.build_mro_dict(instance_cls, owner_cls)
+        mro_dct = lang.mro_dict(instance_cls, owner_cls)
         seen: ta.Mapping[ta.Any, str] = {}
         for nam, att in mro_dct.items():
             try:

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267}/omlish/lang/__init__.py

@@ -140,6 +140,8 @@ from .functions import (  # noqa
     isinstance_of,
     issubclass_of,
     maybe_call,
+    new_function,
+    new_function_kwargs,
     opt_coalesce,
     opt_fn,
     opt_kw,
@@ -203,10 +205,11 @@ from .objects import (  # noqa
     anon_object,
     arg_repr,
     attr_repr,
-    build_mro_dict,
     can_weakref,
     deep_subclasses,
     dir_dict,
+    mro_dict,
+    mro_owner_dict,
     new_type,
     opt_repr,
     super_meta,

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267}/omlish/lang/classes/restrict.py

@@ -3,7 +3,6 @@ import functools
 import typing as ta
 
 from .abstract import Abstract
-from .abstract import is_abstract
 
 
 ##
@@ -25,7 +24,6 @@ class Final(Abstract):
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
-        abstracts: set[ta.Any] = set()
         for base in cls.__bases__:
             if base is Abstract:
                 raise FinalTypeError(base)
@@ -33,16 +31,6 @@ class Final(Abstract):
                 continue
             elif Final in base.__mro__:
                 raise FinalTypeError(base)
-            else:
-                abstracts.update(getattr(base, '__abstractmethods__', []))
-
-        for a in abstracts:
-            try:
-                v = cls.__dict__[a]
-            except KeyError:
-                raise FinalTypeError(a) from None
-            if is_abstract(v):
-                raise FinalTypeError(a)
 
 
 ##

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267}/omlish/lang/functions.py

@@ -1,6 +1,7 @@
 import dataclasses as dc
 import functools
 import time
+import types
 import typing as ta
 
 
@@ -239,3 +240,46 @@ def opt_coalesce(*vs: T | None) -> T | None:
 
 def opt_kw(**kwargs: ta.Any) -> dict[str, ta.Any]:
     return {k: v for k, v in kwargs.items() if v is not None}
+
+
+##
+
+
+def new_function(
+        # a code object
+        code: types.CodeType,
+
+        # the globals dictionary
+        globals: dict,  # noqa
+
+        # a string that overrides the name from the code object
+        name: str | None = None,
+
+        # a tuple that specifies the default argument values
+        argdefs: tuple | None = None,
+
+        # a tuple that supplies the bindings for free variables
+        closure: tuple | None = None,
+
+        # # a dictionary that specifies the default keyword argument values
+        # kwdefaults: dict | None = None,
+) -> types.FunctionType:
+    return types.FunctionType(
+        code=code,
+        globals=globals,
+        name=name,
+        argdefs=argdefs,
+        closure=closure,
+        # kwdefaults=kwdefaults,
+    )
+
+
+def new_function_kwargs(f: types.FunctionType) -> dict[str, ta.Any]:
+    return dict(
+        code=f.__code__,
+        globals=f.__globals__,  # noqa
+        name=f.__name__,
+        argdefs=f.__defaults__,
+        closure=f.__closure__,
+        # kwdefaults=f.__kwdefaults__,
+    )

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267}/omlish/lang/objects.py

@@ -117,12 +117,13 @@ def deep_subclasses(
         todo.extend(reversed(cur.__subclasses__()))
 
 
-def build_mro_dict(
+def mro_owner_dict(
         instance_cls: type,
         owner_cls: type | None = None,
         *,
         bottom_up_key_order: bool = False,
-) -> ta.Mapping[str, ta.Any]:
+        sort_keys: bool = False,
+) -> ta.Mapping[str, tuple[type, ta.Any]]:
     if owner_cls is None:
         owner_cls = instance_cls
 
@@ -132,20 +133,41 @@ def build_mro_dict(
     except ValueError:
         raise TypeError(f'Owner class {owner_cls} not in mro of instance class {instance_cls}') from None
 
-    dct: dict[str, ta.Any] = {}
+    dct: dict[str, tuple[type, ta.Any]] = {}
     if not bottom_up_key_order:
         for cur_cls in mro[:pos + 1][::-1]:
             for k, v in cur_cls.__dict__.items():
                 if k not in dct:
-                    dct[k] = v
+                    dct[k] = (cur_cls, v)
 
     else:
         for cur_cls in mro[:pos + 1]:
-            dct.update(cur_cls.__dict__)
+            dct.update({k: (cur_cls, v) for k, v in cur_cls.__dict__.items()})
+
+    if sort_keys:
+        dct = dict(sorted(dct.items(), key=lambda t: t[0]))
 
     return dct
 
 
+def mro_dict(
+        instance_cls: type,
+        owner_cls: type | None = None,
+        *,
+        bottom_up_key_order: bool = False,
+        sort_keys: bool = False,
+) -> ta.Mapping[str, ta.Any]:
+    return {
+        k: v
+        for k, (o, v) in mro_owner_dict(
+            instance_cls,
+            owner_cls,
+            bottom_up_key_order=bottom_up_key_order,
+            sort_keys=sort_keys,
+        ).items()
+    }
+
+
 def dir_dict(o: ta.Any) -> dict[str, ta.Any]:
     return {
         a: getattr(o, a)

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev266
+Version: 0.0.0.dev267
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev266 → omlish-0.0.0.dev267}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '>=3.12'
-version = '0.0.0.dev266'
+version = '0.0.0.dev267'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev266/omlish/collections/kv/transformed.py

@@ -1,123 +0,0 @@
-import typing as ta
-
-from ... import check
-from .base import Kv
-from .base import MutableKv
-from .wrappers import WrapperKv
-
-
-K = ta.TypeVar('K')
-V = ta.TypeVar('V')
-
-KF = ta.TypeVar('KF')
-KT = ta.TypeVar('KT')
-VF = ta.TypeVar('VF')
-VT = ta.TypeVar('VT')
-
-
-##
-
-
-class KeyTransformedKv(WrapperKv[KT, V], ta.Generic[KT, KF, V]):
-    def __init__(
-            self,
-            u: Kv[KF, V],
-            *,
-            t_to_f: ta.Callable[[KT], KF] | None = None,
-            f_to_t: ta.Callable[[KF], KT] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._u = u
-        self._t_to_f = t_to_f
-        self._f_to_t = f_to_t
-
-    def underlying(self) -> ta.Sequence[Kv]:
-        return [self._u]
-
-    def __getitem__(self, k: KT, /) -> V:
-        fn = check.not_none(self._t_to_f)
-        return self._u[fn(k)]
-
-    def __len__(self) -> int:
-        return len(self._u)
-
-    def items(self) -> ta.Iterator[tuple[KT, V]]:
-        fn = check.not_none(self._f_to_t)
-        return ((fn(k), v) for k, v in self._u.items())
-
-
-class KeyTransformedMutableKey(KeyTransformedKv[KT, KF, V], MutableKv[KT, V], ta.Generic[KT, KF, V]):
-    def __init__(
-            self,
-            u: MutableKv[KF, V],
-            *,
-            t_to_f: ta.Callable[[KT], KF] | None = None,
-            f_to_t: ta.Callable[[KF], KT] | None = None,
-    ) -> None:
-        super().__init__(
-            u,
-            t_to_f=t_to_f,
-            f_to_t=f_to_t,
-        )
-
-    _u: MutableKv[KF, V]
-
-    def __setitem__(self, k: KT, v: V, /) -> None:
-        fn = check.not_none(self._t_to_f)
-        self._u[fn(k)] = v
-
-    def __delitem__(self, k: KT, /) -> None:
-        fn = check.not_none(self._t_to_f)
-        del self._u[fn(k)]
-
-
-##
-
-
-class ValueTransformedKv(WrapperKv[K, VT], ta.Generic[K, VT, VF]):
-    def __init__(
-            self,
-            u: Kv[K, VF],
-            f_to_t: ta.Callable[[VF], VT] | None = None,
-    ) -> None:
-        super().__init__()
-
-        self._u = u
-        self._f_to_t = f_to_t
-
-    def underlying(self) -> ta.Sequence[Kv]:
-        return [self._u]
-
-    def __getitem__(self, k: K, /) -> VT:
-        fn = check.not_none(self._f_to_t)
-        return fn(self._u[k])
-
-    def __len__(self) -> int:
-        return len(self._u)
-
-    def items(self) -> ta.Iterator[tuple[K, VT]]:
-        fn = check.not_none(self._f_to_t)
-        return ((k, fn(v)) for k, v in self._u.items())
-
-
-class ValueTransformedMutableKv(ValueTransformedKv[K, VT, VF], MutableKv[K, VT], ta.Generic[K, VT, VF]):
-    def __init__(
-            self,
-            u: MutableKv[K, VF],
-            *,
-            f_to_t: ta.Callable[[VF], VT] | None = None,
-            t_to_f: ta.Callable[[VT], VF] | None = None,
-    ) -> None:
-        super().__init__(u, f_to_t)
-
-        self._t_to_f = t_to_f
-
-    _u: MutableKv[K, VF]
-
-    def __setitem__(self, k: K, v: VT, /) -> None:
-        fn = check.not_none(self._t_to_f)
-        self._u[k] = fn(v)
-
-    def __delitem__(self, k: K, /) -> None:
-        del self._u[k]