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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mode-streaming
-Version: 0.5.0
+Version: 0.5.1
 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.1}/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__)
@@ -364,9 +382,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),
@@ -415,37 +455,22 @@ def eval_type(
     alias_types = alias_types or {}
     if isinstance(typ, str):
         typ = ForwardRef(typ)
-    if isinstance(typ, ForwardRef):
-        typ = _ForwardRef_safe_eval(typ, globalns, localns)
+    # `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).
     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.1}/mode_streaming.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mode-streaming
-Version: 0.5.0
+Version: 0.5.1
 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.1}/mode_streaming.egg-info/scm_version.json

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

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

@@ -251,6 +251,30 @@ 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}
+
+
 @pytest.mark.parametrize(
     "input,expected",
     [