ipython 9.7.0__tar.gz → 9.8.0__tar.gz

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/completer.py

@@ -85,9 +85,9 @@ You will find that the following are experimental:
 
 We welcome any feedback on these new API, and we also encourage you to try this
 module in debug mode (start IPython with ``--Completer.debug=True``) in order
-to have extra logging information if :any:`jedi` is crashing, or if current
+to have extra logging information if :mod:`jedi` is crashing, or if current
 IPython completer pending deprecations are returning results not yet handled
-by :any:`jedi`
+by :mod:`jedi`
 
 Using Jedi for tab completion allow snippets like the following to work without
 having to execute any code:
@@ -99,7 +99,7 @@ Tab completion will be able to infer that ``myvar[1]`` is a real number without
 executing almost any code unlike the deprecated :any:`IPCompleter.greedy`
 option.
 
-Be sure to update :any:`jedi` to the latest stable version or to try the
+Be sure to update :mod:`jedi` to the latest stable version or to try the
 current development version to get better completions.
 
 Matchers
@@ -149,7 +149,7 @@ More precisely, the API allows to omit ``matcher_api_version`` for v1 Matchers,
 and requires a literal ``2`` for v2 Matchers.
 
 Once the API stabilises future versions may relax the requirement for specifying
-``matcher_api_version`` by switching to :any:`functools.singledispatch`, therefore
+``matcher_api_version`` by switching to :func:`functools.singledispatch`, therefore
 please do not rely on the presence of ``matcher_api_version`` for any purposes.
 
 Suppression of competing matchers
@@ -201,17 +201,14 @@ from dataclasses import dataclass
 from functools import cached_property, partial
 from types import SimpleNamespace
 from typing import (
-    Iterable,
-    Iterator,
     Union,
     Any,
-    Sequence,
     Optional,
     TYPE_CHECKING,
-    Sized,
     TypeVar,
     Literal,
 )
+from collections.abc import Iterable, Iterator, Sequence, Sized
 
 from IPython.core.guarded_eval import (
     guarded_eval,
@@ -247,7 +244,8 @@ import __main__
 from typing import cast
 
 if sys.version_info < (3, 12):
-    from typing_extensions import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
+    from typing_extensions import TypedDict, Protocol
+    from typing import NotRequired, TypeAlias, TypeGuard
 else:
     from typing import TypedDict, NotRequired, Protocol, TypeAlias, TypeGuard
 
@@ -489,7 +487,7 @@ class Completion:
         It will also raise unless use in proper context manager.
 
     This act as a middle ground :any:`Completion` object between the
-    :any:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
+    :class:`jedi.api.classes.Completion` object and the Prompt Toolkit completion
     object. While Jedi need a lot of information about evaluator and how the
     code should be ran/inspected, PromptToolkit (and other frontend) mostly
     need user facing information.
@@ -860,7 +858,7 @@ def rectify_completions(text: str, completions: _IC, *, _debug: bool = False) ->
 
     Notes
     -----
-    :any:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
+    :class:`jedi.api.classes.Completion` s returned by Jedi may not have the same start and end, though
     the Jupyter Protocol requires them to behave like so. This will readjust
     the completion to have the same ``start`` and ``end`` by padding both
     extremities with surrounding text.
@@ -990,9 +988,9 @@ class Completer(Configurable):
           no item/attribute evaluation, no access to locals/globals,
           no evaluation of any operations or comparisons.
         - ``limited``: access to all namespaces, evaluation of hard-coded methods
-          (for example: :any:`dict.keys`, :any:`object.__getattr__`,
-          :any:`object.__getitem__`) on allow-listed objects (for example:
-          :any:`dict`, :any:`list`, :any:`tuple`, ``pandas.Series``),
+          (for example: :py:meth:`dict.keys`, :py:meth:`object.__getattr__`,
+          :py:meth:`object.__getitem__`) on allow-listed objects (for example:
+          :py:class:`dict`, :py:class:`list`, :py:class:`tuple`, ``pandas.Series``),
         - ``unsafe``: evaluation of all methods and function calls but not of
           syntax with side-effects like `del x`,
         - ``dangerous``: completely arbitrary evaluation; does not support auto-import.
@@ -1352,6 +1350,8 @@ class Completer(Configurable):
             assert res is not None
             if len(res.body) != 1:
                 continue
+            if not isinstance(res.body[0], ast.Expr):
+                continue
             expr = res.body[0].value
             if isinstance(expr, ast.Tuple) and not code[-1] == ")":
                 # we skip implicit tuple, like when trimming `fun(a,b`<completion>
@@ -1538,9 +1538,9 @@ def match_dict_keys(
         # All checks passed!
         return True
 
-    filtered_key_is_final: dict[Union[str, bytes, int, float], _DictKeyState] = (
-        defaultdict(lambda: _DictKeyState.BASELINE)
-    )
+    filtered_key_is_final: dict[
+        Union[str, bytes, int, float], _DictKeyState
+    ] = defaultdict(lambda: _DictKeyState.BASELINE)
 
     for k in keys:
         # If at least one of the matches is not final, mark as undetermined.
@@ -2211,6 +2211,17 @@ class IPCompleter(Completer):
         #  starts with `/home/`, `C:\`, etc)
 
         text = context.token
+        code_until_cursor = self._extract_code(context.text_until_cursor)
+        completion_type = self._determine_completion_context(code_until_cursor)
+        in_cli_context = self._is_completing_in_cli_context(code_until_cursor)
+        if (
+            completion_type == self._CompletionContextType.ATTRIBUTE
+            and not in_cli_context
+        ):
+            return {
+                "completions": [],
+                "suppress": False,
+            }
 
         # chars that require escaping with backslash - i.e. chars
         # that readline treats incorrectly as delimiters, but we
@@ -2480,8 +2491,9 @@ class IPCompleter(Completer):
         )
         return {
             "completions": matches,
-            # static analysis should not suppress other matchers
-            "suppress": {_get_matcher_id(self.file_matcher)} if matches else False,
+            # static analysis should not suppress other matcher
+            # NOTE: file_matcher is automatically suppressed on attribute completions
+            "suppress": False,
         }
 
     def _jedi_matches(
@@ -2597,12 +2609,47 @@ class IPCompleter(Completer):
             return self._CompletionContextType.GLOBAL
 
         # Handle all other attribute matches np.ran, d[0].k, (a,b).count
-        chain_match = re.search(r".*(.+\.(?:[a-zA-Z]\w*)?)$", line)
+        chain_match = re.search(r".*(.+(?<!\s)\.(?:[a-zA-Z]\w*)?)$", line)
         if chain_match:
             return self._CompletionContextType.ATTRIBUTE
 
         return self._CompletionContextType.GLOBAL
 
+    def _is_completing_in_cli_context(self, text: str) -> bool:
+        """
+        Determine if we are completing in a CLI alias, line magic, or bang expression context.
+        """
+        stripped = text.lstrip()
+        if stripped.startswith("!") or stripped.startswith("%"):
+            return True
+        # Check for CLI aliases
+        try:
+            tokens = stripped.split(None, 1)
+            if not tokens:
+                return False
+            first_token = tokens[0]
+
+            # Must have arguments after the command for this to apply
+            if len(tokens) < 2:
+                return False
+
+            # Check if first token is a known alias
+            if not any(
+                alias[0] == first_token for alias in self.shell.alias_manager.aliases
+            ):
+                return False
+
+            try:
+                if first_token in self.shell.user_ns:
+                    # There's a variable defined, so the alias is overshadowed
+                    return False
+            except (AttributeError, KeyError):
+                pass
+
+            return True
+        except Exception:
+            return False
+
     def _is_in_string_or_comment(self, text):
         """
         Determine if the cursor is inside a string or comment.
@@ -2724,7 +2771,11 @@ class IPCompleter(Completer):
         """Match attributes or global python names"""
         text = context.text_until_cursor
         text = self._extract_code(text)
-        completion_type = self._determine_completion_context(text)
+        in_cli_context = self._is_completing_in_cli_context(text)
+        if in_cli_context:
+            completion_type = self._CompletionContextType.GLOBAL
+        else:
+            completion_type = self._determine_completion_context(text)
         if completion_type == self._CompletionContextType.ATTRIBUTE:
             try:
                 matches, fragment = self._attr_matches(
@@ -2744,8 +2795,6 @@ class IPCompleter(Completer):
                 matches = _convert_matcher_v1_result_to_v2(
                     matches, type="attribute", fragment=fragment
                 )
-                if matches["completions"]:
-                    matches["suppress"] = {_get_matcher_id(self.file_matcher)}
                 return matches
             except NameError:
                 # catches <undefined attributes>.<tab>
@@ -3256,7 +3305,7 @@ class IPCompleter(Completer):
 
         .. note::
 
-            If ``IPCompleter.debug`` is :any:`True` will yield a ``--jedi/ipython--``
+            If ``IPCompleter.debug`` is :py:data:`True` will yield a ``--jedi/ipython--``
             fake Completion token to distinguish completion returned by Jedi
             and usual IPython completion.
 

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/debugger.py

@@ -275,6 +275,10 @@ class Pdb(OldPdb):
 
         # `kwargs` ensures full compatibility with stdlib's `pdb.Pdb`.
         OldPdb.__init__(self, completekey, stdin, stdout, **kwargs)
+        # Python 3.15+ should define this, so no need to initialize
+        # this avoids some getattr(self, 'curframe')
+        if sys.version_info < (3, 15):
+            self.curframe = None
 
         # IPython changes...
         self.shell = get_ipython()
@@ -609,7 +613,7 @@ class Pdb(OldPdb):
         So if frame is self.current_frame we instead return self.curframe_locals
 
         """
-        if frame is getattr(self, "curframe", None):
+        if frame is self.curframe:
             return self.curframe_locals
         else:
             return frame.f_locals
@@ -728,6 +732,7 @@ class Pdb(OldPdb):
 
         new_line, err = self.parser.format2(line, "str")
         if not err:
+            assert new_line is not None
             line = new_line
 
         bp = None

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/display_functions.py

@@ -137,7 +137,7 @@ def display(
     -------
     handle: DisplayHandle
         Returns a handle on updatable displays for use with :func:`update_display`,
-        if `display_id` is given. Returns :any:`None` if no `display_id` is given
+        if `display_id` is given. Returns :py:data:`None` if no `display_id` is given
         (default).
 
     Examples

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/displayhook.py

@@ -63,7 +63,7 @@ class DisplayHook(Configurable):
 
     @property
     def prompt_count(self):
-        return self.shell.execution_count
+        return self.shell.execution_count - 1
 
     #-------------------------------------------------------------------------
     # Methods used in __call__. Override these methods to modify the behavior
@@ -127,7 +127,7 @@ class DisplayHook(Configurable):
         """
         # Use write, not print which adds an extra space.
         sys.stdout.write(self.shell.separate_out)
-        outprompt = 'Out[{}]: '.format(self.shell.execution_count)
+        outprompt = 'Out[{}]: '.format(self.shell.execution_count - 1)
         if self.do_full_cache:
             sys.stdout.write(outprompt)
 

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/displaypub.py

@@ -149,7 +149,7 @@ class DisplayPublisher(Configurable):
 
         outputs = self.shell.history_manager.outputs
 
-        target_execution_count = self.shell.execution_count
+        target_execution_count = self.shell.execution_count - 1
         if self._in_post_execute:
             # We're in post_execute, so this is likely a matplotlib flush
             # Use execution_count - 1 to associate with the cell that created the plot

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/doctb.py

@@ -3,7 +3,8 @@ import linecache
 import sys
 from collections.abc import Sequence
 from types import TracebackType
-from typing import Any, Callable, Optional
+from typing import Any, Optional
+from collections.abc import Callable
 
 import stack_data
 from pygments.formatters.terminal256 import Terminal256Formatter

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/events.py

@@ -13,6 +13,13 @@ events and the arguments which will be passed to them.
    This API is experimental in IPython 2.0, and may be revised in future versions.
 """
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Iterable
+
+if TYPE_CHECKING:
+    from IPython.core.interactiveshell import InteractiveShell
+
 
 class EventManager:
     """Manage a collection of events and a sequence of callbacks for each.
@@ -25,7 +32,12 @@ class EventManager:
        This API is experimental in IPython 2.0, and may be revised in future versions.
     """
 
-    def __init__(self, shell, available_events, print_on_error=True):
+    def __init__(
+        self,
+        shell: InteractiveShell,
+        available_events: Iterable[str],
+        print_on_error: bool = True,
+    ) -> None:
         """Initialise the :class:`CallbackManager`.
 
         Parameters
@@ -38,10 +50,12 @@ class EventManager:
             A boolean flag to set whether the EventManager will print a warning which a event errors.
         """
         self.shell = shell
-        self.callbacks = {n:[] for n in available_events}
+        self.callbacks: dict[str, list[Callable[..., Any]]] = {
+            n: [] for n in available_events
+        }
         self.print_on_error = print_on_error
     
-    def register(self, event, function):
+    def register(self, event: str, function: Callable[..., Any]) -> None:
         """Register a new event callback.
 
         Parameters
@@ -64,14 +78,14 @@ class EventManager:
         if function not in self.callbacks[event]:
             self.callbacks[event].append(function)
     
-    def unregister(self, event, function):
+    def unregister(self, event: str, function: Callable[..., Any]) -> None:
         """Remove a callback from the given event."""
         if function in self.callbacks[event]:
             return self.callbacks[event].remove(function)
 
         raise ValueError('Function {!r} is not registered as a {} callback'.format(function, event))
 
-    def trigger(self, event, *args, **kwargs):
+    def trigger(self, event: str, *args: Any, **kwargs: Any) -> None:
         """Call callbacks for ``event``.
 
         Any additional arguments are passed to all callbacks registered for this
@@ -90,9 +104,9 @@ class EventManager:
                 self.shell.showtraceback()
 
 # event_name -> prototype mapping
-available_events = {}
+available_events: dict[str, Callable[..., Any]] = {}
 
-def _define_event(callback_function):
+def _define_event(callback_function: Callable[..., Any]) -> Callable[..., Any]:
     available_events[callback_function.__name__] = callback_function
     return callback_function
 
@@ -104,7 +118,7 @@ def _define_event(callback_function):
 # ------------------------------------------------------------------------------
 
 @_define_event
-def pre_execute():
+def pre_execute() -> None:
     """Fires before code is executed in response to user/frontend action.
 
     This includes comm and widget messages and silent execution, as well as user
@@ -113,7 +127,7 @@ def pre_execute():
     pass
 
 @_define_event
-def pre_run_cell(info):
+def pre_run_cell(info: Any) -> None:
     """Fires before user-entered code runs.
 
     Parameters
@@ -124,7 +138,7 @@ def pre_run_cell(info):
     pass
 
 @_define_event
-def post_execute():
+def post_execute() -> None:
     """Fires after code is executed in response to user/frontend action.
 
     This includes comm and widget messages and silent execution, as well as user
@@ -133,7 +147,7 @@ def post_execute():
     pass
 
 @_define_event
-def post_run_cell(result):
+def post_run_cell(result: Any) -> None:
     """Fires after user-entered code runs.
 
     Parameters
@@ -144,7 +158,7 @@ def post_run_cell(result):
     pass
 
 @_define_event
-def shell_initialized(ip):
+def shell_initialized(ip: InteractiveShell) -> None:
     """Fires after initialisation of :class:`~IPython.core.interactiveshell.InteractiveShell`.
 
     This is before extensions and startup scripts are loaded, so it can only be

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/formatters.py

@@ -366,7 +366,7 @@ class BaseFormatter(Configurable):
     dictionaries is through the :meth:`for_type` and :meth:`for_type_by_name`
     methods.
 
-    If no function/callable is found to compute the format data, ``None`` is
+    If no function/callable is found to compute the format data, :py:data:`None` is
     returned and this format type is not used.
     """
 

{ipython-9.7.0 → ipython-9.8.0}/IPython/core/guarded_eval.py

@@ -3,19 +3,18 @@ from inspect import isclass, signature, Signature, getmodule
 from typing import (
     Annotated,
     AnyStr,
-    Callable,
     Literal,
     NamedTuple,
     NewType,
     Optional,
     Protocol,
-    Sequence,
     TypeGuard,
     Union,
     get_args,
     get_origin,
     is_typeddict,
 )
+from collections.abc import Callable, Sequence
 import ast
 import builtins
 import collections
@@ -30,8 +29,8 @@ from types import MethodDescriptorType, ModuleType, MethodType
 
 from IPython.utils.decorators import undoc
 
-
-from typing import Self, LiteralString
+import types
+from typing import Self, LiteralString, get_type_hints
 
 if sys.version_info < (3, 12):
     from typing_extensions import TypeAliasType
@@ -41,17 +40,20 @@ else:
 
 @undoc
 class HasGetItem(Protocol):
-    def __getitem__(self, key) -> None: ...
+    def __getitem__(self, key) -> None:
+        ...
 
 
 @undoc
 class InstancesHaveGetItem(Protocol):
-    def __call__(self, *args, **kwargs) -> HasGetItem: ...
+    def __call__(self, *args, **kwargs) -> HasGetItem:
+        ...
 
 
 @undoc
 class HasGetAttr(Protocol):
-    def __getattr__(self, key) -> None: ...
+    def __getattr__(self, key) -> None:
+        ...
 
 
 @undoc
@@ -391,7 +393,7 @@ class EvaluationContext:
     #: Useful for evaluating ``:-1, 'col'`` in ``df[:-1, 'col']``.
     in_subscript: bool = False
     #: Auto import method
-    auto_import: Callable[list[str], ModuleType] | None = None
+    auto_import: Callable[[Sequence[str]], ModuleType] | None = None
     #: Overrides for evaluation policy
     policy_overrides: dict = field(default_factory=dict)
     #: Transient local namespace used to store mocks
@@ -400,6 +402,9 @@ class EvaluationContext:
     class_transients: dict | None = None
     #: Instance variable name used in the method definition
     instance_arg_name: str | None = None
+    #: Currently associated value
+    #: Useful for adding items to _Duck on annotated assignment
+    current_value: ast.AST | None = None
 
     def replace(self, /, **changes):
         """Return a new copy of the context, with specified changes"""
@@ -496,6 +501,8 @@ UNARY_OP_DUNDERS: dict[type[ast.unaryop], tuple[str, ...]] = {
     ast.Not: ("__not__",),
 }
 
+GENERIC_CONTAINER_TYPES = (dict, list, set, tuple, frozenset)
+
 
 class ImpersonatingDuck:
     """A dummy class used to create objects of other classes without calling their ``__init__``"""
@@ -561,6 +568,30 @@ def _validate_policy_overrides(
     return all_good
 
 
+def _is_type_annotation(obj) -> bool:
+    """
+    Returns True if obj is a type annotation, False otherwise.
+    """
+    if isinstance(obj, type):
+        return True
+    if isinstance(obj, types.GenericAlias):
+        return True
+    if hasattr(types, "UnionType") and isinstance(obj, types.UnionType):
+        return True
+    if isinstance(obj, (typing._SpecialForm, typing._BaseGenericAlias)):
+        return True
+    if isinstance(obj, typing.TypeVar):
+        return True
+    # Types that support __class_getitem__
+    if isinstance(obj, type) and hasattr(obj, "__class_getitem__"):
+        return True
+    # Fallback: check if get_origin returns something
+    if hasattr(typing, "get_origin") and get_origin(obj) is not None:
+        return True
+
+    return False
+
+
 def _handle_assign(node: ast.Assign, context: EvaluationContext):
     value = eval_node(node.value, context)
     transient_locals = context.transient_locals
@@ -658,6 +689,41 @@ def _handle_assign(node: ast.Assign, context: EvaluationContext):
     return None
 
 
+def _handle_annassign(node, context):
+    context_with_value = context.replace(current_value=getattr(node, "value", None))
+    annotation_result = eval_node(node.annotation, context_with_value)
+    if _is_type_annotation(annotation_result):
+        annotation_value = _resolve_annotation(annotation_result, context)
+        # Use Value for generic types
+        use_value = (
+            isinstance(annotation_value, GENERIC_CONTAINER_TYPES) and node.value is not None
+        )
+    else:
+        annotation_value = annotation_result
+        use_value = False
+
+    # LOCAL VARIABLE
+    if getattr(node, "simple", False) and isinstance(node.target, ast.Name):
+        name = node.target.id
+        if use_value:
+            return _handle_assign(
+                ast.Assign(targets=[node.target], value=node.value), context
+            )
+        context.transient_locals[name] = annotation_value
+        return None
+
+    # INSTANCE ATTRIBUTE
+    if _is_instance_attribute_assignment(node.target, context):
+        attr = node.target.attr
+        if use_value:
+            return _handle_assign(
+                ast.Assign(targets=[node.target], value=node.value), context
+            )
+        context.class_transients[attr] = annotation_value
+        return None
+
+    return None
+
 def _extract_args_and_kwargs(node: ast.Call, context: EvaluationContext):
     args = [eval_node(arg, context) for arg in node.args]
     kwargs = {
@@ -766,9 +832,12 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
 
         if is_property:
             if return_type is not None:
-                context.transient_locals[node.name] = _resolve_annotation(
-                    return_type, context
-                )
+                if _is_type_annotation(return_type):
+                    context.transient_locals[node.name] = _resolve_annotation(
+                        return_type, context
+                    )
+                else:
+                    context.transient_locals[node.name] = return_type
             else:
                 return_value = _infer_return_value(node, func_context)
                 context.transient_locals[node.name] = return_value
@@ -779,7 +848,10 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
             pass
 
         if return_type is not None:
-            dummy_function.__annotations__["return"] = return_type
+            if _is_type_annotation(return_type):
+                dummy_function.__annotations__["return"] = return_type
+            else:
+                dummy_function.__inferred_return__ = return_type
         else:
             inferred_return = _infer_return_value(node, func_context)
             if inferred_return is not None:
@@ -900,14 +972,7 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
     if isinstance(node, ast.Assign):
         return _handle_assign(node, context)
     if isinstance(node, ast.AnnAssign):
-        if node.simple:
-            value = _resolve_annotation(eval_node(node.annotation, context), context)
-            context.transient_locals[node.target.id] = value
-        # Handle non-simple annotated assignments only for self.x: type = value
-        if _is_instance_attribute_assignment(node.target, context):
-            value = _resolve_annotation(eval_node(node.annotation, context), context)
-            context.class_transients[node.target.attr] = value
-        return None
+        return _handle_annassign(node, context)
     if isinstance(node, ast.Expression):
         return eval_node(node.body, context)
     if isinstance(node, ast.Expr):
@@ -924,6 +989,29 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
     if isinstance(node, ast.BinOp):
         left = eval_node(node.left, context)
         right = eval_node(node.right, context)
+        if (
+            isinstance(node.op, ast.BitOr)
+            and _is_type_annotation(left)
+            and _is_type_annotation(right)
+        ):
+            left_duck = (
+                _Duck(dict.fromkeys(dir(left)))
+                if policy.can_call(left.__dir__)
+                else _Duck()
+            )
+            right_duck = (
+                _Duck(dict.fromkeys(dir(right)))
+                if policy.can_call(right.__dir__)
+                else _Duck()
+            )
+            value_node = context.current_value
+            if value_node is not None and isinstance(value_node, ast.Dict):
+                if dict in [left, right]:
+                    return _merge_values(
+                        [left_duck, right_duck, ast.literal_eval(value_node)],
+                        policy=get_policy(context),
+                    )
+            return _merge_values([left_duck, right_duck], policy=get_policy(context))
         dunders = _find_dunder(node.op, BINARY_OP_DUNDERS)
         if dunders:
             if policy.can_operate(dunders, left, right):
@@ -1033,6 +1121,22 @@ def eval_node(node: Union[ast.AST, None], context: EvaluationContext):
         value = eval_node(node.value, context)
         if policy.can_get_attr(value, node.attr):
             return getattr(value, node.attr)
+        try:
+            cls = (
+                value if isinstance(value, type) else getattr(value, "__class__", None)
+            )
+            if cls is not None:
+                resolved_hints = get_type_hints(
+                    cls,
+                    globalns=(context.globals or {}),
+                    localns=(context.locals or {}),
+                )
+                if node.attr in resolved_hints:
+                    annotated = resolved_hints[node.attr]
+                    return _resolve_annotation(annotated, context)
+        except Exception:
+            # Fall through to the guard rejection
+            pass
         raise GuardRejection(
             "Attribute access (`__getattr__`) for",
             type(value),  # not joined to avoid calling `repr`