mode-streaming 0.5.0__tar.gz → 0.5.2__tar.gz

{mode_streaming-0.5.0 → mode_streaming-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mode-streaming
-Version: 0.5.0
+Version: 0.5.2
 Summary: AsyncIO Service-based programming
 Author-email: Ask Solem Hoel <ask@robinhood.com>
 Maintainer-email: William Barnhart <williambbarnhart@gmail.com>

{mode_streaming-0.5.0 → mode_streaming-0.5.2}/mode/utils/objects.py

@@ -28,7 +28,6 @@ from typing import (
     cast,
     get_args,
     get_origin,
-    get_type_hints,
 )
 
 try:
@@ -39,20 +38,39 @@ except ImportError:
         return t
 
 
-try:
-    from typing import _type_check  # type: ignore
-except ImportError:
-
-    def _type_check(arg, msg, is_argument=True, module=None):  # type: ignore
-        return arg
-
-
 def _is_class_var(typ):
     # Works for typing.ClassVar and types.GenericAlias (Python 3.9+)
     origin = getattr(typ, "__origin__", None)
     return origin is ClassVar
 
 
+if sys.version_info >= (3, 10):
+    from inspect import get_annotations as _own_annotations
+else:
+
+    def _own_annotations(
+        cls: type,
+        *,
+        globals: Optional[dict] = None,
+        locals: Optional[dict] = None,
+        eval_str: bool = False,
+    ) -> dict:
+        """Backport of :func:`inspect.get_annotations` for Python 3.9.
+
+        Returns only the annotations declared directly in ``cls.__dict__``,
+        never inherited ones -- matching the 3.10+ stdlib function this
+        shadows, which is what makes it safe to use per-class inside a
+        bounded MRO walk (see ``local_annotations`` below).
+        """
+        ann = cls.__dict__.get("__annotations__", {})
+        if eval_str:
+            ann = {
+                k: (eval(v, globals, locals) if isinstance(v, str) else v)  # noqa: S307
+                for k, v in ann.items()
+            }
+        return dict(ann)
+
+
 def _get_globalns(cls):
     # Get the global namespace for a class
     module = sys.modules.get(cls.__module__)
@@ -348,11 +366,18 @@ def annotations(
                 )
             )
 
-    # Normalize all field types for forward refs
-    normalized_fields = {
-        k: _normalize_forwardref(v) for k, v in fields.items()
-    }
-    return normalized_fields, defaults
+    # NOTE: Return the resolved field types as-is. `_resolve_refs`/`eval_type`
+    # above already turned string/ForwardRef annotations into real types, so
+    # nothing further is needed here. Do NOT run `_normalize_forwardref` over
+    # the result: it rewrites any type whose ``__qualname__`` contains
+    # "<locals>" (i.e. every class defined inside a function) down to a bare
+    # ``__name__`` *string*, destroying the actual class object. Callers such
+    # as faust.Record rely on identity of the returned types (e.g. matching a
+    # field type against a custom coercion mapping), which silently breaks
+    # when the type is replaced by its name string. `_normalize_forwardref`
+    # remains available as a comparison helper for callers/tests that want a
+    # canonical, hashable-by-name form.
+    return fields, defaults
 
 
 def local_annotations(
@@ -364,9 +389,31 @@ def local_annotations(
     globalns: Optional[dict[str, Any]] = None,
     localns: Optional[dict[str, Any]] = None,
 ) -> Iterable[tuple[str, type]]:
-    d = get_type_hints(
-        cls, globalns if globalns is not None else _get_globalns(cls), localns
-    )
+    # NOTE: Must only consider annotations defined directly on `cls`, not
+    # inherited ones. `annotations()` (the caller) already walks the MRO
+    # itself via `iter_mro_reversed(cls, stop=stop)` and calls
+    # `local_annotations` once per class in that bounded range, so callers
+    # can exclude base classes at/above `stop` (e.g. faust.Record excludes
+    # its internal ModelT/Model bases this way). Using
+    # `typing.get_type_hints(cls, ...)` here defeats that: it always merges
+    # annotations from the *entire* real MRO regardless of `stop`, so a
+    # non-ClassVar annotation on an excluded base (e.g.
+    # `ModelT.__evaluated_fields__`) would leak back in as if it were a
+    # field of every subclass.
+    #
+    # Plain `cls.__annotations__` attribute access is *not* safe for this
+    # either: on Python < 3.10 it falls back to an inherited base's
+    # `__annotations__` via normal MRO lookup when `cls` itself has none of
+    # its own (re-introducing the same kind of leak), and on Python 3.14+
+    # (PEP 649, deferred evaluation of annotations) direct `__annotations__`
+    # access on a class can behave unreliably -- the stdlib explicitly
+    # recommends `inspect.get_annotations()` instead, which reads only
+    # `cls.__dict__["__annotations__"]` (own annotations, no MRO fallback)
+    # and is written to handle PEP 649 correctly. `_own_annotations` here is
+    # that function, with a same-behavior backport for 3.9. String/ForwardRef
+    # annotations are still resolved below, per value, via
+    # `_resolve_refs`/`eval_type`.
+    d = _own_annotations(cls)
     return _resolve_refs(
         d,
         globalns if globalns is not None else _get_globalns(cls),
@@ -413,39 +460,48 @@ def eval_type(
     """
     invalid_types = invalid_types or set()
     alias_types = alias_types or {}
+    original_str = typ if isinstance(typ, str) else None
     if isinstance(typ, str):
         typ = ForwardRef(typ)
+    # `typing._eval_type` (imported above as `_eval_type`) already resolves
+    # ForwardRef instances directly -- it is the same stdlib function
+    # `typing.get_type_hints()` itself relies on, so it always matches
+    # whatever internal ForwardRef implementation the running interpreter
+    # has (this previously went through a hand-rolled evaluator here that
+    # poked at ForwardRef's private __forward_evaluated__/__forward_code__/
+    # __forward_value__ attributes as a workaround for Python 3.6/3.7; those
+    # attributes are not part of any stable API and are no longer present at
+    # all on Python 3.14's ForwardRef, which raised AttributeError. mode's
+    # floor is Python 3.9, well past the versions that workaround targeted).
     if isinstance(typ, ForwardRef):
-        typ = _ForwardRef_safe_eval(typ, globalns, localns)
-    typ = _eval_type(typ, globalns, localns)
+        try:
+            typ = _eval_type(typ, globalns, localns)
+        except TypeError:
+            # `_eval_type` runs the forward ref through `typing._type_check`,
+            # which rejects `ClassVar[...]` with "is not valid as type
+            # argument". But a *string* ClassVar annotation is legitimate --
+            # `from __future__ import annotations` stringizes every
+            # annotation, ClassVars included -- and callers (see
+            # `_resolve_refs` + `skip_classvar`) still want to see it so they
+            # can drop it. Evaluate the forward arg directly and accept it
+            # when it is a ClassVar; otherwise re-raise the real error.
+            src = (
+                original_str
+                if original_str is not None
+                else typ.__forward_arg__
+            )
+            evaluated = eval(src, globalns, localns)  # noqa: S307
+            if _is_class_var(evaluated):
+                typ = evaluated
+            else:
+                raise
+    else:
+        typ = _eval_type(typ, globalns, localns)
     if typ in invalid_types:
         raise InvalidAnnotation(typ)
     return alias_types.get(typ, typ)
 
 
-def _ForwardRef_safe_eval(
-    ref: ForwardRef,
-    globalns: Optional[dict[str, Any]] = None,
-    localns: Optional[dict[str, Any]] = None,
-) -> type:
-    # On 3.6/3.7 ForwardRef._evaluate crashes if str references ClassVar
-    if not ref.__forward_evaluated__:
-        if globalns is None and localns is None:
-            globalns = localns = {}
-        elif globalns is None:
-            globalns = localns
-        elif localns is None:
-            localns = globalns
-        val = eval(ref.__forward_code__, globalns, localns)  # noqa: S307
-        if not _is_class_var(val):
-            val = _type_check(
-                val, "Forward references must evaluate to types."
-            )
-        ref.__forward_value__ = val
-        ref.__forward_evaluated__ = True
-    return ref.__forward_value__
-
-
 def iter_mro_reversed(cls: type, stop: type) -> Iterable[type]:
     """Iterate over superclasses, in reverse Method Resolution Order.
 

{mode_streaming-0.5.0 → mode_streaming-0.5.2}/mode_streaming.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mode-streaming
-Version: 0.5.0
+Version: 0.5.2
 Summary: AsyncIO Service-based programming
 Author-email: Ask Solem Hoel <ask@robinhood.com>
 Maintainer-email: William Barnhart <williambbarnhart@gmail.com>

{mode_streaming-0.5.0 → mode_streaming-0.5.2}/mode_streaming.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.0",
+  "tag": "0.5.2",
   "distance": 0,
-  "node": "gea836e7025a4ac52dcf644871e1b20c3c43710f9",
+  "node": "g95118563cf82e6445e255bcf2fa7beeb1b23b5d3",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-07-19"

{mode_streaming-0.5.0 → mode_streaming-0.5.2}/tests/unit/utils/test_objects.py

@@ -251,6 +251,62 @@ def test_annotations__no_local_ns_raises():
         annotations(X, globalns=None, localns=None)
 
 
+def test_annotations__stop_excludes_base_above_stop():
+    # Regression test: a non-ClassVar annotation on a base class *above*
+    # `stop` must not leak into the fields of a subclass, even though
+    # Python's typing.get_type_hints() (which local_annotations() must NOT
+    # use directly) would normally merge annotations across the whole real
+    # MRO regardless of any `stop` boundary.
+    class Base:
+        # Deliberately not ClassVar, mirroring faust ModelT.__evaluated_fields__.
+        internal: int = 0
+
+    class Middle(Base):
+        pass
+
+    class Leaf(Middle):
+        foo: int
+
+    fields, _ = annotations(
+        Leaf, stop=Middle, globalns=globals(), localns=locals()
+    )
+
+    assert "internal" not in fields
+    assert fields == {"foo": int}
+
+
+def test_annotations__preserves_function_local_class_identity():
+    # Regression test: a field annotated with a class defined inside a
+    # function (``__qualname__`` contains "<locals>") must be returned as the
+    # actual class object, not rewritten to its bare name string. Callers
+    # such as faust.Record match a field's resolved type by identity against
+    # a coercion mapping, which silently breaks if the type is replaced by a
+    # string.
+    class Local:
+        value: int
+
+    class Holder:
+        item: Local
+
+    fields, _ = annotations(Holder, globalns=globals(), localns=locals())
+
+    assert fields["item"] is Local
+    assert not isinstance(fields["item"], str)
+
+
+def test_eval_type__string_classvar_is_not_rejected():
+    # Regression test: a *string* ClassVar annotation (as produced by
+    # `from __future__ import annotations`) must not raise. Passing the
+    # forward ref straight to typing._eval_type runs typing._type_check,
+    # which rejects ClassVar[...] with "is not valid as type argument".
+    from typing import ClassVar as _ClassVar
+
+    result = eval_type(
+        "ClassVar[int]", globalns={"ClassVar": _ClassVar}, localns={}
+    )
+    assert result == _ClassVar[int]
+
+
 @pytest.mark.parametrize(
     "input,expected",
     [