omlish 0.0.0.dev328__tar.gz → 0.0.0.dev330__tar.gz

{omlish-0.0.0.dev328/omlish.egg-info → omlish-0.0.0.dev330}/PKG-INFO

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

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev328'
-__revision__ = '80b9ed17dd2aefd7dd86d4aa2f14fac4281cf8d6'
+__version__ = '0.0.0.dev330'
+__revision__ = '735d13c7ae2ba542d490b72a443ebcf36f1d5119'
 
 
 #

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/lang/cached/function.py

@@ -331,13 +331,23 @@ class _DescriptorCachedFunction(_CachedFunction[T]):
             raise RuntimeError
         obj = type(instance)
 
-        desc: _DescriptorCachedFunction = object.__getattribute__(obj, name)
+        desc: _DescriptorCachedFunction
+        for bc in obj.__mro__[:-1]:
+            try:
+                desc = bc.__dict__[name]
+            except KeyError:
+                continue
+            break
+        else:
+            raise AttributeError(name)
+
         if not isinstance(desc, cls):
             raise TypeError(desc)
-        if (desc._instance is not None or desc._owner is not None):
+
+        if (desc._instance is not None or desc._owner is not None):  # noqa
             raise RuntimeError
 
-        return desc._bind(
+        return desc._bind(  # noqa
             instance,
             owner,
             values=values,

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/marshal/__init__.py

@@ -119,6 +119,7 @@ from .polymorphism.metadata import (  # noqa
     Polymorphism,
     TypeTagging,
     WrapperTypeTagging,
+    polymorphism_from_impls,
     polymorphism_from_subclasses,
 )
 

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/marshal/polymorphism/metadata.py

@@ -105,25 +105,14 @@ class Polymorphism:
         return self._impls
 
 
-def polymorphism_from_subclasses(
+def polymorphism_from_impls(
         ty: type,
+        impls: ta.Iterable[type],
         *,
         naming: Naming | None = None,
         strip_suffix: bool | ta.Literal['auto'] = False,
 ) -> Polymorphism:
-    seen: set[type] = set()
-    todo: list[type] = [ty]
-    impls: set[type] = set()
-    while todo:
-        cur = todo.pop()
-        seen.add(cur)
-
-        todo.extend(nxt for nxt in cur.__subclasses__() if nxt not in seen)
-
-        if lang.is_abstract_class(cur):
-            continue
-
-        impls.add(cur)
+    impls = set(impls)
 
     if strip_suffix == 'auto':
         strip_suffix = all(c.__name__.endswith(ty.__name__) for c in impls)
@@ -144,3 +133,17 @@ def polymorphism_from_subclasses(
         )
 
     return Polymorphism(ty, dct.values())
+
+
+def polymorphism_from_subclasses(
+        ty: type,
+        *,
+        naming: Naming | None = None,
+        strip_suffix: bool | ta.Literal['auto'] = False,
+) -> Polymorphism:
+    return polymorphism_from_impls(
+        ty,
+        lang.deep_subclasses(ty, concrete_only=True),
+        naming=naming,
+        strip_suffix=strip_suffix,
+    )

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/reflect/ops.py

@@ -6,6 +6,7 @@ from .types import Generic
 from .types import NewType
 from .types import Type
 from .types import Union
+from .types import get_type_var_bound
 from .types import type_
 
 
@@ -52,20 +53,33 @@ def get_underlying(nt: NewType) -> Type:
     return type_(nt.obj.__supertype__)  # noqa
 
 
-def get_concrete_type(ty: Type) -> type | None:
-    if isinstance(ty, type):
-        return ty
+def get_concrete_type(
+        ty: Type,
+        *,
+        use_type_var_bound: bool = False,
+) -> type | None:
+    def rec(cur: Type) -> type | None:
+        if isinstance(cur, type):
+            return cur
 
-    if isinstance(ty, Generic):
-        return ty.cls
+        if isinstance(cur, Generic):
+            return cur.cls
 
-    if isinstance(ty, NewType):
-        return get_concrete_type(get_underlying(ty))
+        if isinstance(cur, NewType):
+            return rec(get_underlying(cur))
 
-    if isinstance(ty, (Union, ta.TypeVar, Any)):
-        return None
+        if isinstance(cur, ta.TypeVar):
+            if use_type_var_bound is not None and (tvb := get_type_var_bound(cur)) is not None:
+                return rec(type_(tvb))
 
-    raise TypeError(ty)
+            return None
+
+        if isinstance(cur, (Union, Any)):
+            return None
+
+        raise TypeError(cur)
+
+    return rec(ty)
 
 
 def to_annotation(ty: Type) -> ta.Any:

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/reflect/subst.py

@@ -43,13 +43,14 @@ def replace_type_vars(
             args = tuple(rec(a) for a in cur.args)
             if update_aliases:
                 obj = cur.obj
-                if (ops := get_params(obj)):
-                    nargs = [to_annotation(rpl[p]) for p in ops]
-                    if ta.get_origin(obj) is ta.Generic:
-                        # FIXME: None? filter_typing_generic in get_generic_bases?
-                        pass
-                    else:
-                        obj = cur.obj[*nargs]
+                if (og := ta.get_origin(obj)) is ta.Generic:
+                    # FIXME: None? filter_typing_generic in get_generic_bases?
+                    pass
+                elif (ops := get_params(og)):
+                    if len(ops) != len(args):
+                        raise RuntimeError
+                    nargs = [to_annotation(a) for a in args]
+                    obj = og[*nargs]
             else:
                 obj = None
             return dc.replace(cur, args=args, obj=obj)
@@ -84,7 +85,8 @@ class GenericSubstitution:
         if (cty := get_concrete_type(ty)) is not None:
             rpl = get_type_var_replacements(ty)
             ret: list[Type] = []
-            for b in types.get_original_bases(cty):
+            obs = types.get_original_bases(cty)
+            for b in obs:
                 bty = type_(b)
                 if isinstance(bty, Generic) and isinstance(b, type):
                     # FIXME: throws away relative types, but can't use original vars as they're class-contextual

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/typedvalues/accessor.py

@@ -14,7 +14,7 @@ from .values import UniqueTypedValue  # noqa
 
 T = ta.TypeVar('T')
 
-TypedValueT = ta.TypeVar('TypedValueT', bound='TypedValue')
+TypedValueT0 = ta.TypeVar('TypedValueT0', bound='TypedValue')
 TypedValueU = ta.TypeVar('TypedValueU', bound='TypedValue')
 
 UniqueTypedValueU = ta.TypeVar('UniqueTypedValueU', bound='UniqueTypedValue')
@@ -27,7 +27,7 @@ class _NOT_SET(lang.Marker):  # noqa
     pass
 
 
-class TypedValuesAccessor(lang.Abstract, ta.Generic[TypedValueT]):
+class TypedValuesAccessor(lang.Abstract, ta.Sequence[TypedValueT0]):
     def __iter__(self):
         raise TypeError(
             'TypedValuesAccessor does not implement __iter__ - it is reserved for implementation by subclasses.',
@@ -36,7 +36,7 @@ class TypedValuesAccessor(lang.Abstract, ta.Generic[TypedValueT]):
     #
 
     @ta.final
-    def __contains__(self, cls: type[TypedValueU]) -> bool:
+    def __contains__(self, cls: type[TypedValueU]) -> bool:  # type: ignore[override]
         return self._typed_value_contains(cls)
 
     @abc.abstractmethod
@@ -45,8 +45,8 @@ class TypedValuesAccessor(lang.Abstract, ta.Generic[TypedValueT]):
 
     #
 
-    @ta.overload
-    def __getitem__(self, idx: int) -> TypedValueT:
+    @ta.overload  # type: ignore[override]
+    def __getitem__(self, idx: int) -> TypedValueT0:
         ...
 
     @ta.overload

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/typedvalues/generic.py

@@ -22,10 +22,6 @@ class TypedValueGeneric(lang.Abstract, ta.Generic[TypedValueT]):
             return
 
         g_mro = rfl.ALIAS_UPDATING_GENERIC_SUBSTITUTION.generic_mro(cls)
-        g_tvg = check.single(
-            gb
-            for gb in g_mro
-            if isinstance(gb, rfl.Generic) and gb.cls is TypedValueGeneric
-        )
+        g_tvg = check.single(gb for gb in g_mro if isinstance(gb, rfl.Generic) and gb.cls is TypedValueGeneric)
         tvt = check.single(g_tvg.args)
         cls._typed_value_type = tvt

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/typedvalues/holder.py

@@ -8,20 +8,20 @@ from .generic import TypedValueGeneric
 from .values import TypedValue
 
 
-TypedValueT = ta.TypeVar('TypedValueT', bound=TypedValue)
+TypedValueT1 = ta.TypeVar('TypedValueT1', bound=TypedValue)
 
 
 ##
 
 
 class TypedValueHolder(
-    TypedValuesAccessor[TypedValueT],
-    TypedValueGeneric[TypedValueT],
+    TypedValuesAccessor[TypedValueT1],
+    TypedValueGeneric[TypedValueT1],
     lang.Abstract,
 ):
     @property
     @abc.abstractmethod
-    def _typed_values(self) -> TypedValues[TypedValueT] | None:
+    def _typed_values(self) -> TypedValues[TypedValueT1] | None:
         raise NotImplementedError
 
     #

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/omlish/typedvalues/marshal.py

@@ -81,12 +81,18 @@ def _build_typed_values_impls(rty: rfl.Type) -> msh.Impls:
     gty = check.isinstance(rty, rfl.Generic)
     check.is_(gty.cls, TypedValues)
 
-    tv_cls_set = reflect_typed_values_impls(check.single(gty.args))
-
-    tv_impls: list[msh.Impl] = []
-    for tv_cls in tv_cls_set:
-        tv_impls.extend(_build_typed_value_poly(tv_cls).impls)
+    tv_cls_set = reflect_typed_values_impls(
+        check.single(gty.args),
+        find_abstract_subclasses=True,
+    )
 
+    tv_impls: list[msh.Impl] = [
+        msh.Impl(
+            tv_cls,
+            msh.translate_name(tv_cls.__name__, msh.Naming.SNAKE),
+        )
+        for tv_cls in tv_cls_set
+    ]
     return msh.Impls(tv_impls)
 
 

omlish-0.0.0.dev330/omlish/typedvalues/reflect.py

@@ -0,0 +1,44 @@
+import typing as ta
+
+from .. import check
+from .. import lang
+from .. import reflect as rfl
+from .values import TypedValue
+
+
+##
+
+
+def reflect_typed_values_impls(
+        *rtys: rfl.Type,
+        find_abstract_subclasses: bool = False,
+) -> set[type[TypedValue]]:
+    tv_cls_set: set[type[TypedValue]] = set()
+
+    todo = list(rtys)
+    seen = set()
+    while todo:
+        cur = todo.pop()
+        if cur in seen:
+            continue
+        seen.add(cur)
+
+        if isinstance(cur, rfl.Union):
+            todo.extend(cur.args)
+
+        elif isinstance(cur, ta.TypeVar):
+            todo.append(rfl.type_(rfl.get_type_var_bound(cur)))
+
+        elif isinstance(cur, type):
+            cur = check.issubclass(check.isinstance(cur, type), TypedValue)
+
+            if find_abstract_subclasses and lang.is_abstract_class(cur):
+                todo.extend(lang.deep_subclasses(cur, concrete_only=True))
+
+            else:
+                tv_cls_set.add(cur)
+
+        else:
+            raise TypeError(cur)
+
+    return tv_cls_set

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev328 → omlish-0.0.0.dev330}/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.dev328'
+version = '0.0.0.dev330'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev328/omlish/typedvalues/reflect.py

@@ -1,29 +0,0 @@
-import typing as ta
-
-from .. import check
-from .. import reflect as rfl
-from .values import TypedValue
-
-
-##
-
-
-def reflect_typed_values_impls(rty: rfl.Type) -> set[type[TypedValue]]:
-    tv_cls_set: set[type[TypedValue]] = set()
-
-    todo = [rty]
-    seen = set()
-    while todo:
-        cur = todo.pop()
-        if cur in seen:
-            continue
-        seen.add(cur)
-
-        if isinstance(cur, rfl.Union):
-            todo.extend(cur.args)
-        elif isinstance(cur, ta.TypeVar):
-            todo.append(rfl.type_(rfl.get_type_var_bound(cur)))
-        else:
-            tv_cls_set.add(check.issubclass(check.isinstance(cur, type), TypedValue))
-
-    return tv_cls_set