omlish 0.0.0.dev337__tar.gz → 0.0.0.dev339__tar.gz

{omlish-0.0.0.dev337/omlish.egg-info → omlish-0.0.0.dev339}/PKG-INFO

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

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev337'
-__revision__ = '6f1500f0f97a2650c7df1a7127e2688a0ef300cf'
+__version__ = '0.0.0.dev339'
+__revision__ = '0d8d4714d9a9ea7145586e0bce55833b86e980bd'
 
 
 #

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/lang/__init__.py

@@ -61,12 +61,21 @@ from .classes.abstract import (  # noqa
     unabstract_class,
 )
 
+from .classes.bindable import (  # noqa
+    BindableClass,
+)
+
 from .classes.namespaces import (  # noqa
     GenericNamespaceMeta,
     Namespace,
     NamespaceMeta,
 )
 
+from .classes.protocols import (  # noqa
+    ProtocolForbiddenAsBaseClass,
+    ProtocolForbiddenAsBaseClassTypeError,
+)
+
 from .classes.restrict import (  # noqa
     AnySensitive,
     Final,

omlish-0.0.0.dev339/omlish/lang/classes/bindable.py

@@ -0,0 +1,41 @@
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class _ClassOrInstanceMethod:
+    def __init__(self, func):
+        super().__init__()
+
+        self.__func__ = func
+
+    def __get__(self, instance, owner=None):
+        return self.__func__.__get__(instance if instance is not None else owner)
+
+
+class BindableClass(ta.Generic[T]):
+    # FIXME: apparently can't have TypeVars in ClassVars, but could stick in a @classmethod (which gets transformed)...
+    _bound: ta.ClassVar[type[T] | None] = None  # type: ignore[misc]
+
+    def __init__(self, *, _bound):
+        super().__init__()
+
+        setattr(self, '_bound', _bound)
+
+    def __class_getitem__(cls, *args, **kwargs):
+        if cls is BindableClass:
+            return super().__class_getitem__(*args, **kwargs)  # type: ignore[misc]
+
+        [bind_cls] = args
+        return cls(_bound=bind_cls)
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        for k, v in cls.__dict__.items():
+            if isinstance(v, classmethod):
+                setattr(cls, k, _ClassOrInstanceMethod(v.__func__))

omlish-0.0.0.dev339/omlish/lang/classes/protocols.py

@@ -0,0 +1,26 @@
+import typing as ta
+
+
+##
+
+
+class ProtocolForbiddenAsBaseClass(ta.Protocol):
+    pass
+
+
+class ProtocolForbiddenAsBaseClassTypeError(TypeError):
+    pass
+
+
+def _ProtocolForbiddenAsBaseClass__init_subclass__(cls: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    if ta.Protocol not in cls.__mro__:
+        raise TypeError(f'Class {cls} must be a Protocol')
+
+    super(ProtocolForbiddenAsBaseClass, cls).__init_subclass__(**kwargs)  # noqa
+
+    # TODO: ta.Protocol not in cls.__bases__ ?
+    if not cls.__dict__['_is_protocol']:
+        raise ProtocolForbiddenAsBaseClassTypeError(cls)
+
+
+setattr(ProtocolForbiddenAsBaseClass, '__init_subclass__', classmethod(_ProtocolForbiddenAsBaseClass__init_subclass__))

omlish-0.0.0.dev339/omlish/marshal/composite/special.py

@@ -0,0 +1,33 @@
+import collections.abc
+
+from ... import check
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactoryMatchClass
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactoryMatchClass
+from .iterables import DEFAULT_ITERABLE_CONCRETE_TYPES
+from .iterables import IterableMarshaler
+from .iterables import IterableUnmarshaler
+
+
+##
+
+
+class SequenceNotStrMarshalerFactory(MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Protocol) and rty.cls is lang.SequenceNotStr)
+    def _build_generic(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        gty = check.isinstance(rty, rfl.Protocol)
+        return IterableMarshaler(ctx.make(check.single(gty.args)))
+
+
+class SequenceNotStrUnmarshalerFactory(UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Protocol) and rty.cls is lang.SequenceNotStr)
+    def _build_generic(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        gty = check.isinstance(rty, rfl.Protocol)
+        cty = DEFAULT_ITERABLE_CONCRETE_TYPES[collections.abc.Sequence]  # type: ignore[type-abstract]
+        return IterableUnmarshaler(cty, ctx.make(check.single(gty.args)))

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/marshal/standard.py

@@ -18,6 +18,8 @@ from .composite.newtypes import NewtypeMarshalerFactory
 from .composite.newtypes import NewtypeUnmarshalerFactory
 from .composite.optionals import OptionalMarshalerFactory
 from .composite.optionals import OptionalUnmarshalerFactory
+from .composite.special import SequenceNotStrMarshalerFactory
+from .composite.special import SequenceNotStrUnmarshalerFactory
 from .objects.dataclasses import DataclassMarshalerFactory
 from .objects.dataclasses import DataclassUnmarshalerFactory
 from .objects.namedtuples import NamedtupleMarshalerFactory
@@ -58,6 +60,7 @@ STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     DATETIME_MARSHALER_FACTORY,
     MaybeMarshalerFactory(),
     MappingMarshalerFactory(),
+    SequenceNotStrMarshalerFactory(),
     IterableMarshalerFactory(),
     ANY_MARSHALER_FACTORY,
 ]
@@ -91,6 +94,7 @@ STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     DATETIME_UNMARSHALER_FACTORY,
     MaybeUnmarshalerFactory(),
     MappingUnmarshalerFactory(),
+    SequenceNotStrUnmarshalerFactory(),
     IterableUnmarshalerFactory(),
     ANY_UNMARSHALER_FACTORY,
 ]

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/reflect/__init__.py

@@ -28,8 +28,10 @@ from .types import (  # noqa
     Any,
     DEFAULT_REFLECTOR,
     Generic,
+    GenericLike,
     Literal,
     NewType,
+    Protocol,
     ReflectTypeError,
     Reflector,
     TYPES,

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/reflect/ops.py

@@ -1,9 +1,12 @@
+import dataclasses as dc
 import typing as ta
 
 from .types import Annotated
 from .types import Any
 from .types import Generic
+from .types import GenericLike
 from .types import NewType
+from .types import Protocol
 from .types import Type
 from .types import Union
 from .types import get_type_var_bound
@@ -15,13 +18,13 @@ def strip_objs(ty: Type) -> Type:
         return ty
 
     if isinstance(ty, Union):
-        return Union(frozenset(map(strip_objs, ty.args)))
+        return dc.replace(ty, args=frozenset(map(strip_objs, ty.args)))
 
-    if isinstance(ty, Generic):
-        return Generic(ty.cls, tuple(map(strip_objs, ty.args)), ty.params, None)
+    if isinstance(ty, GenericLike):
+        return dc.replace(ty, args=tuple(map(strip_objs, ty.args)), obj=None)
 
     if isinstance(ty, Annotated):
-        return Annotated(strip_objs(ty.ty), ty.md, None)
+        return dc.replace(ty, ty=strip_objs(ty.ty), obj=None)
 
     raise TypeError(ty)
 
@@ -31,10 +34,10 @@ def strip_annotations(ty: Type) -> Type:
         return ty
 
     if isinstance(ty, Union):
-        return Union(frozenset(map(strip_annotations, ty.args)))
+        return dc.replace(ty, args=frozenset(map(strip_annotations, ty.args)))
 
-    if isinstance(ty, Generic):
-        return Generic(ty.cls, tuple(map(strip_annotations, ty.args)), ty.params, ty.obj)
+    if isinstance(ty, GenericLike):
+        return dc.replace(ty, args=tuple(map(strip_annotations, ty.args)))
 
     if isinstance(ty, Annotated):
         return strip_annotations(ty.ty)
@@ -74,7 +77,7 @@ def get_concrete_type(
 
             return None
 
-        if isinstance(cur, (Union, Any)):
+        if isinstance(cur, (Union, Any, Protocol)):
             return None
 
         raise TypeError(cur)
@@ -89,6 +92,9 @@ def to_annotation(ty: Type) -> ta.Any:
     if isinstance(ty, Union):
         return ta.Union[*tuple(to_annotation(e) for e in ty.args)]
 
+    if isinstance(ty, Protocol):
+        return ta.Protocol[*ty.params]
+
     if isinstance(ty, (type, ta.TypeVar, NewType)):
         return ty
 

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/reflect/types.py

@@ -3,6 +3,7 @@ TODO:
  - visitor / transformer
  - uniform collection isinstance - items() for mappings, iter() for other
  - also check instance type in isinstance not just items lol
+TODO:
  - ta.Generic in mro causing trouble - omit? no longer 1:1
  - cache this shit, esp generic_mro shit
   - cache __hash__ in Generic/Union
@@ -22,6 +23,7 @@ _AnnotatedAlias = ta._AnnotatedAlias  # type: ignore  # noqa
 _CallableGenericAlias = ta._CallableGenericAlias  # type: ignore  # noqa
 _GenericAlias = ta._GenericAlias  # type: ignore  # noqa
 _LiteralGenericAlias = ta._LiteralGenericAlias  # type: ignore  # noqa
+_ProtocolMeta = ta._ProtocolMeta  # noqa
 _SpecialGenericAlias = ta._SpecialGenericAlias  # type: ignore  # noqa
 _UnionGenericAlias = ta._UnionGenericAlias   # type: ignore  # noqa
 
@@ -29,6 +31,16 @@ _UnionGenericAlias = ta._UnionGenericAlias   # type: ignore  # noqa
 ##
 
 
+_Protocol = getattr(ta, 'Protocol')
+_Generic = getattr(ta, 'Generic')
+
+if not isinstance(_Protocol, type) or not issubclass(_Protocol, _Generic):
+    raise TypeError(f'typing.Protocol is not a proper typing.Generic subtype')
+
+
+##
+
+
 @dc.dataclass(frozen=True)
 class _Special:
     name: str
@@ -95,6 +107,10 @@ def get_params(obj: ta.Any) -> tuple[ta.TypeVar, ...]:
     raise TypeError(obj)
 
 
+def _is_immediate_protocol(obj: ta.Any) -> bool:
+    return isinstance(obj, _ProtocolMeta) and obj.__dict__['_is_protocol']
+
+
 def is_union_type(cls: ta.Any) -> bool:
     if hasattr(ta, 'UnionType'):
         return ta.get_origin(cls) in {ta.Union, getattr(ta, 'UnionType')}
@@ -163,22 +179,30 @@ class Union(TypeInfo):
 #
 
 
+GenericLikeCls = ta.TypeVar('GenericLikeCls')
+
+
 @dc.dataclass(frozen=True)
-class Generic(TypeInfo):
-    cls: type
-    args: tuple[Type, ...]                                                # map[int, V] = (int, V) | map[T, T] = (T, T)
+class GenericLike(TypeInfo, abc.ABC, ta.Generic[GenericLikeCls]):
+    cls: GenericLikeCls
 
-    params: tuple[ta.TypeVar, ...] = dc.field(compare=False, repr=False)  # map[int, V] = (_0, _1) | map[T, T] = (_0, _1)  # noqa
-    # params2: tuple[ta.TypeVar, ...]                                     # map[int, V] = (V,)     | map[T, T] = (T,)
+    # args and params are the same length - params maps to the generic origin's params:
+    # args   : map[int, V] = (int, V) | map[T, T] = (T, T)
+    # params : map[int, V] = (_0, _1) | map[T, T] = (_0, _1)
+    args: tuple[Type, ...]
+    params: tuple[ta.TypeVar, ...] = dc.field(compare=False, repr=False)
 
     obj: ta.Any = dc.field(compare=False, repr=False)
 
-    # def __post_init__(self) -> None:
-    #     if not isinstance(self.cls, type):
-    #         raise TypeError(self.cls)
+    def __post_init__(self) -> None:
+        if not isinstance(self.cls, type):
+            raise ReflectTypeError(f'GenericLike {self.cls=} must be a type')
+        if len(self.args) != len(self.params):
+            raise ReflectTypeError(f'GenericLike {self.args=} must be same length as {self.params=}')
 
-    def full_eq(self, other: 'Generic') -> bool:
+    def full_eq(self, other: 'GenericLike') -> bool:
         return (
+            type(self) is type(other) and
             self.cls == other.cls and
             self.args == other.args and
             self.params == other.params and
@@ -186,6 +210,18 @@ class Generic(TypeInfo):
         )
 
 
+@dc.dataclass(frozen=True)
+class Generic(GenericLike[type]):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class Protocol(GenericLike[ta.Any]):
+    # cls will still be a type - it will be the topmost _is_protocol=True class.
+    # it may however be ta.Protocol, which *is* a type, but not according to mypy.
+    pass
+
+
 #
 
 
@@ -311,9 +347,13 @@ class Reflector:
                 return None
 
             origin = ta.get_origin(obj)
+
             args = ta.get_args(obj)
 
-            if oty is _CallableGenericAlias:
+            if origin is ta.Protocol:
+                params = get_params(obj)
+
+            elif oty is _CallableGenericAlias:
                 p, r = args
                 if p is Ellipsis or isinstance(p, ta.ParamSpec):
                     raise ReflectTypeError(f'Callable argument not yet supported for {obj=}')
@@ -332,6 +372,27 @@ class Reflector:
             if len(args) != len(params):
                 raise ReflectTypeError(f'Mismatched {args=} and {params=} for {obj=}')
 
+            if not isinstance(origin, type):
+                raise ReflectTypeError(f'Generic origin {origin!r} is not a type')
+
+            if origin is ta.Protocol:
+                if args != params:
+                    raise ReflectTypeError(f'Protocol argument not yet supported for {args=}, {params=}')
+                return Protocol(
+                    ta.Protocol,
+                    args,
+                    params,
+                    obj,
+                )
+
+            if _is_immediate_protocol(origin):
+                return Protocol(
+                    origin,
+                    args,
+                    params,
+                    obj,
+                )
+
             return Generic(
                 origin,
                 tuple(self.type(a) for a in args),
@@ -346,6 +407,15 @@ class Reflector:
             if check_only:
                 return None
 
+            if _is_immediate_protocol(obj):
+                params = get_params(obj)
+                return Protocol(
+                    obj,
+                    params,
+                    params,
+                    obj,
+                )
+
             if issubclass(obj, ta.Generic):  # type: ignore
                 params = get_params(obj)
                 if params:

omlish-0.0.0.dev339/omlish/testing/pytest/plugins/switches/__init__.py

@@ -0,0 +1 @@
+from .plugin import SwitchesPlugin  # noqa

omlish-0.0.0.dev337/omlish/testing/pytest/plugins/switches.py → omlish-0.0.0.dev339/omlish/testing/pytest/plugins/switches/plugin.py

@@ -3,17 +3,20 @@ TODO:
  - inheritance
  - dynamic registration
  - dynamic switching (skip docker if not running, skip online if not online, ...)
+ - probably make IF_SINGLE understand parametErization
 """
 import dataclasses as dc
-import enum
 import typing as ta
 
 import pytest
 
-from .... import check
-from .... import collections as col
-from ....docker import all as docker
-from ._registry import register
+from ..... import check
+from ..... import collections as col
+from .._registry import register
+from .switches import SWITCHES
+from .switches import SWITCHES_BY_NAME
+from .switches import Switch
+from .switches import SwitchState
 
 
 Configable: ta.TypeAlias = pytest.FixtureRequest | pytest.Config
@@ -22,80 +25,6 @@ Configable: ta.TypeAlias = pytest.FixtureRequest | pytest.Config
 ##
 
 
-class SwitchState(enum.Enum):
-    ENABLED = enum.auto()
-    DISABLED = enum.auto()
-    ONLY = enum.auto()
-    IF_SINGLE = enum.auto()
-
-
-@dc.dataclass(frozen=True, eq=False)
-class Switch:
-    name: str
-    _default_state: SwitchState | ta.Callable[[pytest.Session], SwitchState]
-
-    _: dc.KW_ONLY
-
-    add_marks: ta.Sequence[ta.Any] | None = None
-
-    def default_state(self, session: pytest.Session) -> SwitchState:
-        if isinstance(e := self._default_state, SwitchState):
-            return e
-        elif callable(e):
-            return check.isinstance(e(session), SwitchState)
-        else:
-            raise TypeError(e)
-
-    @property
-    def attr(self) -> str:
-        return self.name.replace('-', '_')
-
-
-SWITCHES: ta.Sequence[Switch] = [
-    Switch(
-        'name',
-        lambda _: SwitchState.ENABLED if docker.has_cli() else SwitchState.DISABLED,
-    ),
-
-    Switch(
-        'docker-guest',
-        lambda _: SwitchState.ENABLED if docker.is_likely_in_docker() else SwitchState.DISABLED,
-    ),
-
-    Switch(
-        'online',
-        SwitchState.ENABLED,
-    ),
-
-    Switch(
-        'integration',
-        SwitchState.ENABLED,
-    ),
-
-    Switch(
-        'high-mem',
-        SwitchState.ENABLED,
-        add_marks=[
-            # https://pytest-xdist.readthedocs.io/en/latest/distribution.html
-            pytest.mark.xdist_group('high-mem'),
-            pytest.mark.gc_collect_after(),
-        ],
-    ),
-
-    Switch(
-        'slow',
-        SwitchState.IF_SINGLE,
-    ),
-]
-
-
-SWITCHES_BY_NAME: ta.Mapping[str, Switch] = col.make_map_by(lambda sw: sw.name, SWITCHES, strict=True)
-SWITCHES_BY_ATTR: ta.Mapping[str, Switch] = col.make_map_by(lambda sw: sw.attr, SWITCHES, strict=True)
-
-
-##
-
-
 SWITCH_STATE_OPT_PREFIXES: ta.Mapping[SwitchState, str] = {
     SwitchState.ENABLED: '--',
     SwitchState.DISABLED: '--no-',
@@ -193,6 +122,7 @@ class SwitchesPlugin:
     def pytest_sessionstart(self, session):
         session.stash[self._states_key] = self._States(session)
 
+    @pytest.hookimpl(tryfirst=True)
     def pytest_collection_modifyitems(self, config, items):
         def process_item(item):
             state: SwitchesPlugin._States = item.session.stash[self._states_key]

omlish-0.0.0.dev339/omlish/testing/pytest/plugins/switches/switches.py

@@ -0,0 +1,89 @@
+import dataclasses as dc
+import enum
+import typing as ta
+
+import pytest
+
+from ..... import check
+from ..... import collections as col
+from .....docker import all as docker
+
+
+##
+
+
+class SwitchState(enum.Enum):
+    ENABLED = enum.auto()
+    DISABLED = enum.auto()
+    ONLY = enum.auto()
+    IF_SINGLE = enum.auto()
+
+
+@dc.dataclass(frozen=True, eq=False)
+class Switch:
+    name: str
+    _default_state: SwitchState | ta.Callable[[pytest.Session], SwitchState]
+
+    _: dc.KW_ONLY
+
+    add_marks: ta.Sequence[ta.Any] | None = None
+
+    def default_state(self, session: pytest.Session) -> SwitchState:
+        if isinstance(e := self._default_state, SwitchState):
+            return e
+        elif callable(e):
+            return check.isinstance(e(session), SwitchState)
+        else:
+            raise TypeError(e)
+
+    @property
+    def attr(self) -> str:
+        return self.name.replace('-', '_')
+
+
+##
+
+
+SWITCHES: ta.Sequence[Switch] = [
+    Switch(
+        'name',
+        lambda _: SwitchState.ENABLED if docker.has_cli() else SwitchState.DISABLED,
+    ),
+
+    Switch(
+        'docker-guest',
+        lambda _: SwitchState.ENABLED if docker.is_likely_in_docker() else SwitchState.DISABLED,
+    ),
+
+    Switch(
+        'online',
+        SwitchState.ENABLED,
+    ),
+
+    Switch(
+        'integration',
+        SwitchState.ENABLED,
+    ),
+
+    Switch(
+        'high-mem',
+        SwitchState.ENABLED,
+        add_marks=[
+            # https://pytest-xdist.readthedocs.io/en/latest/distribution.html
+            pytest.mark.xdist_group('high-mem'),
+            pytest.mark.gc_collect_after(),
+        ],
+    ),
+
+    Switch(
+        'slow',
+        SwitchState.IF_SINGLE,
+    ),
+]
+
+
+##
+
+
+SWITCHES_BY_NAME: ta.Mapping[str, Switch] = col.make_map_by(lambda sw: sw.name, SWITCHES, strict=True)
+SWITCHES_BY_ATTR: ta.Mapping[str, Switch] = col.make_map_by(lambda sw: sw.attr, SWITCHES, strict=True)

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/testing/pytest/skip.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - if_not_single? switches does this
+"""
 import shutil
 import sys
 import sysconfig
@@ -11,8 +15,9 @@ from ... import lang
 ##
 
 
-def if_cant_import(module: str, *args, **kwargs):
-    return pytest.mark.skipif(not lang.can_import(module, *args, **kwargs), reason=f'requires import {module}')
+def if_cant_import(*modules: str, **kwargs):
+    missing = [m for m in modules if not lang.can_import(m, **kwargs)]
+    return pytest.mark.skipif(bool(missing), reason=f'requires import {", ".join(missing)}')
 
 
 def if_not_on_path(exe: str):
@@ -27,11 +32,5 @@ def if_not_platform(*platforms: str):
     return pytest.mark.skipif(sys.platform not in platforms, reason=f'requires platform in {platforms}')
 
 
-def if_not_single():
-    # FIXME
-    # [resolve_collection_argument(a) for a in session.config.args]
-    raise NotImplementedError
-
-
 def if_nogil():
     return pytest.mark.skipif(sysconfig.get_config_var('Py_GIL_DISABLED'), reason='requires gil build')

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/typedvalues/__init__.py

@@ -22,6 +22,10 @@ from .holder import (  # noqa
     TypedValueHolder,
 )
 
+from .of_ import (  # noqa
+    of,
+)
+
 from .reflect import (  # noqa
     reflect_typed_values_impls,
 )

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/typedvalues/accessor.py

@@ -27,7 +27,11 @@ class _NOT_SET(lang.Marker):  # noqa
     pass
 
 
-class TypedValuesAccessor(lang.Abstract, ta.Sequence[TypedValueT0]):
+class TypedValuesAccessor(
+    lang.Abstract,
+    ta.Sequence[TypedValueT0],
+    ta.Generic[TypedValueT0],
+):
     def __iter__(self):
         raise TypeError(
             'TypedValuesAccessor does not implement __iter__ - it is reserved for implementation by subclasses.',

{omlish-0.0.0.dev337 → omlish-0.0.0.dev339}/omlish/typedvalues/collection.py

@@ -10,6 +10,7 @@ from .values import UniqueTypedValue
 
 
 TypedValueT = ta.TypeVar('TypedValueT', bound='TypedValue')
+TypedValueU = ta.TypeVar('TypedValueU', bound='TypedValue')
 
 UniqueTypedValueT = ta.TypeVar('UniqueTypedValueT', bound='UniqueTypedValue')