ommlds 0.0.0.dev500__py3-none-any.whl → 0.0.0.dev501__py3-none-any.whl

ommlds/minichain/backends/impls/openai/format.py

@@ -145,7 +145,7 @@ def build_mc_ai_delta(delta: pt.ChatCompletionChunkChoiceDelta) -> AiDelta:
         )
 
     else:
-        raise ValueError(delta)
+        return ContentAiDelta('')
 
 
 ##

ommlds/minichain/chat/messages.py

@@ -41,7 +41,7 @@ class Message(  # noqa
     def replace(self, **kwargs: ta.Any) -> ta.Self:
         if (n := dc.replace_is_not(self, **kwargs)) is self:
             return self
-        return n.update_metadata(MessageOriginal(self), discard=[MessageOriginal], override=True)
+        return n.with_metadata(MessageOriginal(self), discard=[MessageOriginal], override=True)
 
 
 Chat: ta.TypeAlias = ta.Sequence[Message]

ommlds/minichain/chat/stream/joining.py

@@ -22,8 +22,9 @@ class AiDeltaJoiner:
     def __init__(self) -> None:
         super().__init__()
 
-        self._deltas: list[AiDelta] = []
-        self._messages: list[AnyAiMessage] = []
+        self._all: list[AiDelta] = []
+        self._queue: list[AiDelta] = []
+        self._out: list[AnyAiMessage] = []
 
     def _build_joined(self, deltas: ta.Sequence[AiDelta]) -> AnyAiMessage:
         dty = check.single(set(map(type, check.not_empty(deltas))))
@@ -43,6 +44,9 @@ class AiDeltaJoiner:
 
             ra = ''.join(filter(None, (td.raw_args for td in tds)))
 
+            if not ra:
+                ra = '{}'
+
             return ToolUseMessage(ToolUse(
                 id=tds[0].id,
                 name=check.non_empty_str(tds[0].name),
@@ -53,19 +57,39 @@ class AiDeltaJoiner:
         else:
             raise TypeError(dty)
 
-    def _maybe_join(self) -> None:
-        if not self._deltas:
+    def _join(self) -> None:
+        if not self._queue:
             return
 
-        self._messages.append(self._build_joined(self._deltas))
-        self._deltas.clear()
+        self._out.append(self._build_joined(self._queue))
+        self._queue.clear()
+
+    def _should_join(self, *, new: AiDelta | None = None) -> bool:
+        if not self._queue:
+            return False
+
+        if new is not None and type(self._queue[0]) is not type(new):
+            return True
+
+        if (
+                isinstance(d0 := self._queue[0], PartialToolUseAiDelta) and
+                isinstance(new, PartialToolUseAiDelta) and
+                d0.id is not None and
+                new.id is not None and
+                d0.id != new.id
+        ):
+            return True
+
+        return False
 
     def _add_one(self, d: AiDelta) -> None:
-        if self._deltas and type(self._deltas[0]) is not type(d):
-            self._maybe_join()
+        if self._should_join(new=d):
+            self._join()
+
+        self._all.append(d)
 
         if isinstance(d, ToolUseAiDelta):
-            self._messages.append(ToolUseMessage(ToolUse(
+            self._out.append(ToolUseMessage(ToolUse(
                 id=d.id,
                 name=check.not_none(d.name),
                 args=d.args or {},
@@ -73,13 +97,13 @@ class AiDeltaJoiner:
             )))
 
         else:
-            self._deltas.append(d)
+            self._queue.append(d)
 
     def add(self, deltas: AiDeltas) -> None:
         for d in deltas:
             self._add_one(d)
 
     def build(self) -> AiChat:
-        self._maybe_join()
+        self._join()
 
-        return list(self._messages)
+        return list(self._out)

ommlds/minichain/chat/transforms/metadata.py

@@ -26,7 +26,7 @@ class UuidAddingMessageTransform(MessageTransform):
 
     def transform_message(self, m: Message) -> Chat:
         if Uuid not in m.metadata:
-            m = m.update_metadata(Uuid(self.uuid_factory()))
+            m = m.with_metadata(Uuid(self.uuid_factory()))
         return [m]
 
 
@@ -36,7 +36,7 @@ class CreatedAtAddingMessageTransform(MessageTransform):
 
     def transform_message(self, m: Message) -> Chat:
         if CreatedAt not in m.metadata:
-            m = m.update_metadata(CreatedAt(self.clock()))
+            m = m.with_metadata(CreatedAt(self.clock()))
         return [m]
 
 
@@ -54,6 +54,6 @@ class OriginAddingMessageTransform(MessageTransform):
 
     def transform_message(self, m: Message) -> Chat:
         return [
-            o.update_metadata(TransformedMessageOrigin(m)) if TransformedMessageOrigin not in o.metadata else m
+            o.with_metadata(TransformedMessageOrigin(m)) if TransformedMessageOrigin not in o.metadata else m
             for o in self.child.transform_message(m)
         ]

ommlds/minichain/content/standard.py

@@ -29,4 +29,4 @@ class StandardContent(  # noqa
     def replace(self, **kwargs: ta.Any) -> ta.Self:
         if (n := dc.replace_is_not(self, **kwargs)) is self:
             return self
-        return n.update_metadata(ContentOriginal(self), discard=[ContentOriginal], override=True)
+        return n.with_metadata(ContentOriginal(self), discard=[ContentOriginal], override=True)

ommlds/minichain/content/transform/json.py

@@ -52,4 +52,4 @@ class JsonContentRenderer(ContentTransform[None]):
             case _:
                 raise ValueError(self._code)
 
-        return nc.update_metadata(ContentOriginal(c))
+        return nc.with_metadata(ContentOriginal(c))

ommlds/minichain/content/transform/metadata.py

@@ -9,7 +9,7 @@ from ..visitors import ContentTransform
 
 class OriginalMetadataStrippingContentTransform(ContentTransform[None]):
     def visit_standard_content(self, c: StandardContent, ctx: None) -> StandardContent:
-        return c.discard_metadata(ContentOriginal)
+        return c.with_metadata(discard=[ContentOriginal])
 
 
 def strip_content_original_metadata(c: Content) -> Content:

ommlds/minichain/content/transform/standard.py

@@ -26,7 +26,7 @@ class LiftToStandardContentTransform(ContentTransform[None]):
         self._sequence_mode = sequence_mode
 
     def visit_str(self, s: str, ctx: None) -> Content:
-        return TextContent(s).update_metadata(ContentOriginal(s))
+        return TextContent(s).with_metadata(ContentOriginal(s))
 
     def visit_sequence(self, c: ta.Sequence[Content], ctx: None) -> Content:
         cc = check.isinstance(super().visit_sequence(c, ctx), collections.abc.Sequence)
@@ -40,4 +40,4 @@ class LiftToStandardContentTransform(ContentTransform[None]):
             case _:
                 raise ValueError(self._sequence_mode)
 
-        return nc.update_metadata(ContentOriginal(c))
+        return nc.with_metadata(ContentOriginal(c))

ommlds/minichain/content/transform/strings.py

@@ -20,7 +20,7 @@ class StringFnContentTransform(ContentTransform[None]):
     fn: ta.Callable[[str], str]
 
     def visit_str(self, c: str, ctx: None) -> TextContent:
-        return TextContent(self.fn(c)).update_metadata(ContentOriginal(c))
+        return TextContent(self.fn(c)).with_metadata(ContentOriginal(c))
 
     def visit_text_content(self, c: TextContent, ctx: None) -> TextContent:
         return c.replace(s=self.fn(c.s))

ommlds/minichain/content/transform/templates.py

@@ -22,4 +22,4 @@ class TemplateContentMaterializer(ContentTransform[None]):
 
     def visit_template_content(self, c: TemplateContent, ctx: None) -> Content:
         s = c.t.render(check.not_none(self._templater_context))
-        return TextContent(s).update_metadata(ContentOriginal(c))
+        return TextContent(s).with_metadata(ContentOriginal(c))

ommlds/minichain/metadata.py

@@ -25,9 +25,9 @@ MetadataT = ta.TypeVar('MetadataT', bound=Metadata)
 
 
 class MetadataContainer(
-    tv.TypedValueGeneric[MetadataT],
     lang.Abstract,
     lang.PackageSealed,
+    ta.Generic[MetadataT],
 ):
     @property
     @abc.abstractmethod
@@ -35,7 +35,12 @@ class MetadataContainer(
         raise NotImplementedError
 
     @abc.abstractmethod
-    def update_metadata(self, *mds: MetadataT, override: bool = False) -> ta.Self:
+    def with_metadata(
+            self,
+            *add: MetadataT,
+            discard: ta.Iterable[type] | None = None,
+            override: bool = False,
+    ) -> ta.Self:
         raise NotImplementedError
 
 
@@ -66,30 +71,22 @@ class MetadataContainerDataclass(  # noqa
     def metadata(self) -> tv.TypedValues[MetadataT]:
         return check.isinstance(getattr(self, '_metadata'), tv.TypedValues)
 
-    def discard_metadata(self, *tys: type) -> ta.Self:
-        nmd = (md := self.metadata).discard(*tys)
-
-        if nmd is md:
-            return self
-
-        return dc.replace(self, _metadata=nmd)  # type: ignore[call-arg]  # noqa
-
-    def update_metadata(
+    def with_metadata(
             self,
-            *mds: MetadataT,
+            *add: MetadataT,
             discard: ta.Iterable[type] | None = None,
             override: bool = False,
     ) -> ta.Self:
-        nmd = (md := self.metadata).update(
-            *mds,
+        new = (old := self.metadata).update(
+            *add,
             discard=discard,
             override=override,
         )
 
-        if nmd is md:
+        if new is old:
             return self
 
-        return dc.replace(self, _metadata=nmd)  # type: ignore[call-arg]  # noqa
+        return dc.replace(self, _metadata=new)  # type: ignore[call-arg]  # noqa
 
 
 ##

ommlds/minichain/services/__init__.py

@@ -1,4 +1,153 @@
 # ruff: noqa: I001
+"""
+The core service abstraction. In general, Services are intended to encapsulate non-trivial, resourceful, effectful
+operations, which are likely to have various implementations, each having their own specific capabilities in addition
+to their common interface, and where wrapping, adapting, and transforming them in a uniform manner is desirable.
+
+For example:
+ - A ChatService is passed a Request with a Chat value and returns a Response with an AiChat value.
+ - A ChatChoicesService is passed a Request with a Chat and returns a Response with a list of AiChoices.
+ - A ChatChoicesServiceChatService is a simple adapter taking a ChatChoicesService which it will invoke with its given
+   Request, expect a single AiChoice value in that Response, and return that single AiChat as its Response - thus acting
+   as a ChatService.
+   - Thus, all chat backends that return choices can be adapted to code expecting a single chat as output.
+ - A ChatStreamService is passed a Request with a Chat value and returns a Response with a value from which AiDeltas
+   may be streamed.
+ - A ChatChoicesStreamService is passed a Request with a Chat value and returns a Response with a value from which
+   AiChoicesDeltas may be streamed.
+ - A ChatChoicesStreamServiceChatChoicesService is an adapter taking a ChatChoicesStreamService and aggregating the
+   AiChoicesDeltas into joined, non-delta AiChoices.
+   - This may then be wrapped in a ChatChoicesServiceChatService to act as a ChatService.
+   - In practice however there are usually dedicated streaming and non-streaming implementations if possible as
+     non-streaming will usually have less overhead.
+ - An OpenaiChatChoicesService can act as a ChatChoicesService, and will accept all generic ChatOptions, in addition to
+   any OpenaiChatOptions inapplicable to any other backend. It may also produce all generic ChatOutputs, in addition to
+   OpenaiChatOutputs that will not be produced by other backends.
+ - Beyond chat, a VectorSearchService is passed a Request with a VectorSearch value and returns a Response with a
+   VectorHits value.
+ - A RetryService wraps any other Service and will attempt to re-invoke it on failure.
+ - A FirstInWinsService wraps any number of other Services and will return the first non-error Response it receives.
+
+The service abstraction consists of 3 interrelated generic types:
+ - Request, an immutable final generic class containing a single value and any number of options.
+ - Response, an immutable final generic class containing a single value and any number of outputs.
+ - Service, a generic protocol consisting of a single method `invoke`, taking a request and returning a response.
+
+There are 2 related abstract base classes in the parent package:
+ - Option, a non-generic abstract class representing a service option.
+ - Output, a non-generic abstract class representing a service output.
+
+The purpose of this arrangement is to provide the following:
+ - There is only one method - `Service.invoke` - to deal with.
+ - There is no base `Service` class - service types are distinguished only by the requests they accept and responses
+   they return.
+ - It facilitates a clear, introspectable, generally type-safe means for handling 'less-specific' and 'more-specific'
+   service types.
+ - It facilitates generic wrapper and transformation machinery.
+
+The variance of the type parameters of the 3 classes is central:
+ - `Request[V_co, OptionT_co]`
+ - `Response[V_co, OutputT_contra]`
+ - `Service[RequestT_contra, ResponseT_co]`
+
+And to understand this, it's important to understand how Option and Output subtypes are intended to be arranged:
+ - These types are *not* intended to form a deep type hierarchy:
+   - A RemoteChatOption is *not* intended to inherit from a ChatOption: a ChatOption (be it a base class or union alias)
+     represents an option that *any* ChatService can accept, whereas a RemoteChatOption represents an option that *only*
+     applies to a RemoteChatService.
+   - If RemoteChatOption inherited from a base ChatOption, then it would have to apply to *all* ChatService
+     implementations.
+   - For example: were ApiKey to inherit from ChatOption, then it would have to apply to all ChatServices, including
+     LocalChatService, which has no concept of an api key.
+ - Similarly, a RemoteChatOutput is *not* intended to inherit from a ChatOutput: a ChatOutput represents an output that
+   *any* ChatService can produce, whereas a RemoteChatOutput represents an output that *only* applies to a
+   RemoteChatService.
+ - These 2 types are intended to form flat, disjoint, unrelated families of subtypes, and Request and Response are
+   intended to be parameterized by the unions of all such families they may contain.
+ - Because of this, one's visual intuition regarding types and subtypes may be reversed: `int` is effectively a subtype
+   of `int | str` despite `int` being a visually shorter, less complex type.
+   - `int` is a *MORE SPECIFIC* / *STRICT SUBSET* subtype of `int | str`, the *LESS SPECIFIC* / *STRICT SUPERSET*
+     supertype.
+
+Regarding type variance:
+ - Service has the classic setup of contravariant input and covariant output:
+   - A RemoteChatService *is a* ChatService.
+   - A RemoteChatService may accept less specific requests than a ChatService.
+   - A RemoteChatService may return more specific responses than a ChatService.
+ - Request is covariant on its options:
+   - Recall, a RemoteChatOption *is not a* ChatOption.
+   - A ChatRequest *is a* RemoteChatRequest as it will not contain options RemoteChatService cannot accept.
+ - Response is contravariant on its outputs:
+   - Recall, a RemoteChatOutput *is not a* ChatOutput.
+   - A RemoteChatResponse *is a* ChatResponse even though it may contain additional output variants not produced by
+     every ChatService.
+   - Code that calls a ChatService and is given a ChatResponse must be prepared to handle (usually by simply ignoring)
+     outputs not necessarily produced by a base ChatService.
+
+Below is a representative illustration of these types and their relationships. Note how:
+ - There is no subclassing of Request, Response, or Service - just type aliasing.
+ - There is no deep, shared subclassing of Option or Output.
+ - The type args passed to Request and Response are unions of all the Option and Output subtypes they may contain.
+   - These unions are kept in pluralized type aliases for convenience.
+ - There is no base ChatOption or ChatOutput class - were there, it would not be included in the base classes of any
+   local or remote only option or output.
+ - The local and remote sections take different but equivalent approaches:
+   - There are no base LocalChatOption or LocalChatOutput classes, but there *are* base RemoteChatOption and
+     RemoteChatOutput classes.
+   - Without any common base classes (besides the lowest level Output and Option classes), the local section treats them
+     as each distinct and bespoke, and the pluralized LocalChatOptions and LocalChatOutputs type aliases aggregate them
+     by explicitly listing them.
+   - With the common RemoteChatOption and RemoteChatOutput base classes, the remote section treats them as a related
+     family that any 'RemoteChat'-like service should accept and produce.
+
+```
+# Common chat
+
+class MaxTokens(Option, tv.UniqueScalarTypedValue[int]): pass
+class Temperature(Option, tv.UniqueScalarTypedValue[float]): pass
+
+ChatOptions: ta.TypeAlias = MaxTokens | Temperature
+ChatRequest: ta.TypeAlias = Request[Chat, ChatOptions]
+
+class TokenUsage(Output, tv.UniqueScalarTypedValue[int]): pass
+class ElapsedTime(Output, tv.UniqueScalarTypedValue[float]): pass
+
+ChatOutput: ta.TypeAlias = TokenUsage | ElapsedTime
+ChatResponse: ta.TypeAlias = Response[Message, ChatOutput]
+
+ChatService: ta.TypeAlias = Service[ChatRequest, ChatResponse]
+
+# Local chat
+
+class ModelPath(Option, tv.ScalarTypedValue[str]): pass
+
+LocalChatOptions: ta.TypeAlias = ChatOptions | ModelPath
+LocalChatRequest: ta.TypeAlias = Request[Chat, LocalChatOptions]
+
+class LogPath(Output, tv.ScalarTypedValue[str]): pass
+
+LocalChatOutputs: ta.TypeAlias = ChatOutput | LogPath
+LocalChatResponse: ta.TypeAlias = Response[Message, LocalChatOutputs]
+
+LocalChatService: ta.TypeAlias = Service[LocalChatRequest, LocalChatResponse]
+
+# Remote chat
+
+class RemoteChatOption(Option, lang.Abstract): pass
+class ApiKey(RemoteChatOption, tv.ScalarTypedValue[str]): pass
+
+RemoteChatOptions: ta.TypeAlias = ChatOptions | RemoteChatOption
+RemoteChatRequest: ta.TypeAlias = Request[Chat, RemoteChatOptions]
+
+class RemoteChatOutput(Output, lang.Abstract): pass
+class BilledCostInUsd(RemoteChatOutput, tv.UniqueScalarTypedValue[float]): pass
+
+RemoteChatOutputs: ta.TypeAlias = ChatOutput | RemoteChatOutput
+RemoteChatResponse: ta.TypeAlias = Response[Message, RemoteChatOutputs]
+
+RemoteChatService: ta.TypeAlias = Service[RemoteChatRequest, RemoteChatResponse]
+```
+"""
 
 
 from .facades import (  # noqa
@@ -8,10 +157,16 @@ from .facades import (  # noqa
 )
 
 from .requests import (  # noqa
+    RequestMetadata,
+    RequestMetadatas,
+
     Request,
 )
 
 from .responses import (  # noqa
+    ResponseMetadata,
+    ResponseMetadatas,
+
     Response,
 )
 

ommlds/minichain/services/_marshal.py

@@ -1,3 +1,8 @@
+"""
+FIXME:
+ - everything lol
+ - can this just do what metadata does
+"""
 import typing as ta
 
 from omlish import check
@@ -22,10 +27,21 @@ def _is_rr_rty(rty: rfl.Type) -> bool:
     )
 
 
-def _get_tv_fld(rty: rfl.Type) -> dc.Field:
+class _RrFlds(ta.NamedTuple):
+    v: dc.Field
+    tv: dc.Field
+    md: dc.Field
+
+
+def _get_rr_flds(rty: rfl.Type) -> _RrFlds:
     flds = col.make_map_by(lambda f: f.name, dc.fields(check.not_none(rfl.get_concrete_type(rty))), strict=True)
-    flds.pop('v')
-    return check.single(flds.values())
+    v_fld = flds.pop('v')
+    md_fld = flds.pop('_metadata')
+    return _RrFlds(
+        v=v_fld,
+        tv=check.single(flds.values()),
+        md=md_fld,
+    )
 
 
 ##
@@ -34,7 +50,7 @@ def _get_tv_fld(rty: rfl.Type) -> dc.Field:
 @dc.dataclass(frozen=True)
 class _RequestResponseMarshaler(msh.Marshaler):
     rty: rfl.Type
-    tv_fld: dc.Field
+    rr_flds: _RrFlds
     v_m: msh.Marshaler | None
 
     def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
@@ -51,9 +67,14 @@ class _RequestResponseMarshaler(msh.Marshaler):
         else:
             v_v = self.v_m.marshal(ctx, o.v)
 
+        md_fmd = self.rr_flds.md.metadata[msh.FieldMetadata]
+        md_m = md_fmd.marshaler_factory.make_marshaler(ctx.marshal_factory_context, self.rr_flds.md.type)()  # FIXME
+        md_v = md_m.marshal(ctx, o._metadata)  # noqa
+
         return {
             'v': v_v,
-            **({lang.strip_prefix(self.tv_fld.name, '_'): tv_v} if tv_v else {}),
+            **({lang.strip_prefix(self.rr_flds.tv.name, '_'): tv_v} if tv_v else {}),
+            **({'metadata': md_v} if md_v else {}),
         }
 
 
@@ -76,7 +97,7 @@ class _RequestResponseMarshalerFactory(msh.MarshalerFactory):
                 v_m = ctx.make_marshaler(v_rty)
             return _RequestResponseMarshaler(
                 rty,
-                _get_tv_fld(rty),
+                _get_rr_flds(rty),
                 v_m,
             )
 
@@ -89,9 +110,10 @@ class _RequestResponseMarshalerFactory(msh.MarshalerFactory):
 @dc.dataclass(frozen=True)
 class _RequestResponseUnmarshaler(msh.Unmarshaler):
     rty: rfl.Type
-    tv_fld: dc.Field
+    rr_flds: _RrFlds
     v_u: msh.Unmarshaler
     tv_u: msh.Unmarshaler
+    md_u: msh.Unmarshaler
 
     def unmarshal(self, ctx: msh.UnmarshalContext, v: msh.Value) -> ta.Any:
         dct = dict(check.isinstance(v, ta.Mapping))
@@ -99,9 +121,14 @@ class _RequestResponseUnmarshaler(msh.Unmarshaler):
         v_v = dct.pop('v')
         v = self.v_u.unmarshal(ctx, v_v)
 
+        if md_v := dct.pop('metadata', None):
+            md = self.md_u.unmarshal(ctx, md_v)
+        else:
+            md = []
+
         tvs: ta.Any
         if dct:
-            tv_vs = dct.pop(lang.strip_prefix(self.tv_fld.name, '_'))
+            tv_vs = dct.pop(lang.strip_prefix(self.rr_flds.tv.name, '_'))
             tvs = self.tv_u.unmarshal(ctx, tv_vs)
         else:
             tvs = []
@@ -109,7 +136,7 @@ class _RequestResponseUnmarshaler(msh.Unmarshaler):
         check.empty(dct)
 
         cty = rfl.get_concrete_type(self.rty)
-        return cty(v, tvs)  # type: ignore
+        return cty(v, tvs, _metadata=md)  # type: ignore
 
 
 class _RequestResponseUnmarshalerFactory(msh.UnmarshalerFactory):
@@ -123,15 +150,24 @@ class _RequestResponseUnmarshalerFactory(msh.UnmarshalerFactory):
             else:
                 # FIXME: ...
                 raise TypeError(rty)
+
+            rr_flds = _get_rr_flds(rty)
+
             tv_types_set = check.isinstance(tv_rty, rfl.Union).args
             tv_ta = tv.TypedValues[ta.Union[*tv_types_set]]  # type: ignore
             tv_u = ctx.make_unmarshaler(tv_ta)
+
             v_u = ctx.make_unmarshaler(v_rty)
+
+            md_fmd = rr_flds.md.metadata[msh.FieldMetadata]
+            md_u = md_fmd.unmarshaler_factory.make_unmarshaler(ctx, rr_flds.md.type)()  # FIXME
+
             return _RequestResponseUnmarshaler(
                 rty,
-                _get_tv_fld(rty),
+                _get_rr_flds(rty),
                 v_u,
                 tv_u,
+                md_u,
             )
 
         return inner

ommlds/minichain/services/_origclasses.py

@@ -43,3 +43,14 @@ class _OrigClassCapture:
         """Enforces that __orig_class__ has only been set once."""
 
         return check.single(object.__getattribute__(self, '__captured_orig_classes__'))
+
+
+def confer_orig_class(src, dst):
+    if src is not dst:
+        try:
+            oc = src.__orig_class__
+        except AttributeError:
+            pass
+        else:
+            dst.__orig_class__ = oc
+    return dst

ommlds/minichain/services/_typedvalues.py

@@ -45,14 +45,19 @@ class _TypedValues(
     lang.Abstract,
     ta.Generic[TypedValueT],
 ):
-    __typed_values_class__: ta.ClassVar[type[tv.TypedValue]]
+    """
+    The reason this is so complicated compared to any other TypedValues field (like metadata) is that the real set of
+    TypedValue types it accepts is known only via __orig_class__.
+    """
+
+    __typed_values_base__: ta.ClassVar[type[tv.TypedValue]]
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
         tvt = _get_typed_values_type_arg(cls)
         tvct = rfl.get_concrete_type(tvt, use_type_var_bound=True)
-        cls.__typed_values_class__ = check.issubclass(check.isinstance(tvct, type), tv.TypedValue)
+        cls.__typed_values_base__ = check.issubclass(check.isinstance(tvct, type), tv.TypedValue)
 
     #
 
@@ -77,7 +82,7 @@ class _TypedValues(
 
         tv_types_set = frozenset(tv.reflect_typed_values_impls(tvt))
         tv_types = tuple(sorted(
-            [check.issubclass(c, self.__typed_values_class__) for c in tv_types_set],
+            [check.issubclass(c, self.__typed_values_base__) for c in tv_types_set],
             key=lambda c: c.__qualname__,
         ))