from copy import copy

from inspect import isclass, signature, Signature, getmodule

from typing import (

Annotated,

AnyStr,

Literal,

NamedTuple,

NewType,

Optional,

Protocol,

TypeGuard,

Union,

get_args,

get_origin,

is_typeddict,

)

from collections.abc import Callable, Sequence

import ast

import builtins

import collections

import dataclasses

import operator

import sys

import typing

import warnings

from functools import cached_property

from dataclasses import dataclass, field

from types import MethodDescriptorType, ModuleType, MethodType

from IPython.utils.decorators import undoc

import types

from typing import Self, LiteralString, get_type_hints

if sys.version_info < (3, 12):

from typing_extensions import TypeAliasType

else:

from typing import TypeAliasType

@undoc

class HasGetItem(Protocol):

def __getitem__(self, key) -> None:

...

@undoc

class InstancesHaveGetItem(Protocol):

def __call__(self, *args, **kwargs) -> HasGetItem:

...

@undoc

class HasGetAttr(Protocol):

def __getattr__(self, key) -> None:

...

@undoc

class DoesNotHaveGetAttr(Protocol):

pass

# By default `__getattr__` is not explicitly implemented on most objects

MayHaveGetattr = Union[HasGetAttr, DoesNotHaveGetAttr]

def _unbind_method(func: Callable) -> Union[Callable, None]:

"""Get unbound method for given bound method.

Returns None if cannot get unbound method, or method is already unbound.

"""

owner = getattr(func, "__self__", None)

owner_class = type(owner)

name = getattr(func, "__name__", None)

instance_dict_overrides = getattr(owner, "__dict__", None)

if (

owner is not None

and name

and (

not instance_dict_overrides

or (instance_dict_overrides and name not in instance_dict_overrides)

)

):

return getattr(owner_class, name)

return None

@undoc

@dataclass

class EvaluationPolicy:

"""Definition of evaluation policy."""

allow_locals_access: bool = False

allow_globals_access: bool = False

allow_item_access: bool = False

allow_attr_access: bool = False

allow_builtins_access: bool = False

allow_all_operations: bool = False

allow_any_calls: bool = False

allow_auto_import: bool = False

allowed_calls: set[Callable] = field(default_factory=set)

def can_get_item(self, value, item):

return self.allow_item_access

def can_get_attr(self, value, attr):

return self.allow_attr_access

def can_operate(self, dunders: tuple[str, ...], a, b=None):

if self.allow_all_operations:

return True

def can_call(self, func):

if self.allow_any_calls:

return True

if func in self.allowed_calls:

return True

owner_method = _unbind_method(func)

if owner_method and owner_method in self.allowed_calls:

return True

def _get_external(module_name: str, access_path: Sequence[str]):

"""Get value from external module given a dotted access path.

Only gets value if the module is already imported.

Raises:

* `KeyError` if module is removed not found, and

* `AttributeError` if access path does not match an exported object

"""

try:

member_type = sys.modules[module_name]

# standard module

for attr in access_path:

member_type = getattr(member_type, attr)

return member_type

except (KeyError, AttributeError):

# handle modules in namespace packages

module_path = ".".join([module_name, *access_path])

if module_path in sys.modules:

return sys.modules[module_path]

raise

def _has_original_dunder_external(

value,

module_name: str,

access_path: Sequence[str],

method_name: str,

):

if module_name not in sys.modules:

full_module_path = ".".join([module_name, *access_path])

if full_module_path not in sys.modules:

# LBYLB as it is faster

return False

try:

member_type = _get_external(module_name, access_path)

value_type = type(value)

if type(value) == member_type:

return True

if isinstance(member_type, ModuleType):

value_module = getmodule(value_type)

if not value_module or not value_module.__name__:

return False

if (

value_module.__name__ == member_type.__name__

or value_module.__name__.startswith(member_type.__name__ + ".")

):

return True

if method_name == "__getattribute__":

# we have to short-circuit here due to an unresolved issue in

# `isinstance` implementation: https://bugs.python.org/issue32683

return False

if not isinstance(member_type, ModuleType) and isinstance(value, member_type):

method = getattr(value_type, method_name, None)

member_method = getattr(member_type, method_name, None)

if member_method == method:

return True

if isinstance(member_type, ModuleType):

method = getattr(value_type, method_name, None)

for base_class in value_type.__mro__[1:]:

base_module = getmodule(base_class)

if base_module and (

base_module.__name__ == member_type.__name__

or base_module.__name__.startswith(member_type.__name__ + ".")

):

# Check if the method comes from this trusted base class

base_method = getattr(base_class, method_name, None)

if base_method is not None and base_method == method:

return True

except (AttributeError, KeyError):

return False

def _has_original_dunder(

value, allowed_types, allowed_methods, allowed_external, method_name

):

# note: Python ignores `__getattr__`/`__getitem__` on instances,

# we only need to check at class level

value_type = type(value)

# strict type check passes → no need to check method

if value_type in allowed_types:

return True

method = getattr(value_type, method_name, None)

if method is None:

return None

if method in allowed_methods:

return True

for module_name, *access_path in allowed_external:

if _has_original_dunder_external(value, module_name, access_path, method_name):

return True

return False

def _coerce_path_to_tuples(

allow_list: set[tuple[str, ...] | str],

) -> set[tuple[str, ...]]:

"""Replace dotted paths on the provided allow-list with tuples."""

return {

path if isinstance(path, tuple) else tuple(path.split("."))

for path in allow_list

}

@undoc

@dataclass

class SelectivePolicy(EvaluationPolicy):

allowed_getitem: set[InstancesHaveGetItem] = field(default_factory=set)

allowed_getitem_external: set[tuple[str, ...] | str] = field(default_factory=set)

allowed_getattr: set[MayHaveGetattr] = field(default_factory=set)

allowed_getattr_external: set[tuple[str, ...] | str] = field(default_factory=set)

allowed_operations: set = field(default_factory=set)

allowed_operations_external: set[tuple[str, ...] | str] = field(default_factory=set)

allow_getitem_on_types: bool = field(default_factory=bool)

_operation_methods_cache: dict[str, set[Callable]] = field(

default_factory=dict, init=False

)

def can_get_attr(self, value, attr):

allowed_getattr_external = _coerce_path_to_tuples(self.allowed_getattr_external)

has_original_attribute = _has_original_dunder(

value,

allowed_types=self.allowed_getattr,

allowed_methods=self._getattribute_methods,

allowed_external=allowed_getattr_external,

method_name="__getattribute__",

)

has_original_attr = _has_original_dunder(

value,

allowed_types=self.allowed_getattr,

allowed_methods=self._getattr_methods,

allowed_external=allowed_getattr_external,

method_name="__getattr__",

)

accept = False

# Many objects do not have `__getattr__`, this is fine.

if has_original_attr is None and has_original_attribute:

accept = True

else:

# Accept objects without modifications to `__getattr__` and `__getattribute__`

accept = has_original_attr and has_original_attribute

if accept:

# We still need to check for overridden properties.

value_class = type(value)

if not hasattr(value_class, attr):

return True

class_attr_val = getattr(value_class, attr)

is_property = isinstance(class_attr_val, property)

if not is_property:

return True

# Properties in allowed types are ok (although we do not include any

# properties in our default allow list currently).

if type(value) in self.allowed_getattr:

return True # pragma: no cover

# Properties in subclasses of allowed types may be ok if not changed

for module_name, *access_path in allowed_getattr_external:

try:

external_class = _get_external(module_name, access_path)

external_class_attr_val = getattr(external_class, attr)

except (KeyError, AttributeError):

return False # pragma: no cover

return class_attr_val == external_class_attr_val

return False

def can_get_item(self, value, item):

"""Allow accessing `__getiitem__` of allow-listed instances unless it was not modified."""

allowed_getitem_external = _coerce_path_to_tuples(self.allowed_getitem_external)

if self.allow_getitem_on_types:

# e.g. Union[str, int] or Literal[True, 1]

if isinstance(value, (typing._SpecialForm, typing._BaseGenericAlias)):

return True

# PEP 560 e.g. list[str]

if isinstance(value, type) and hasattr(value, "__class_getitem__"):

return True

return _has_original_dunder(

value,

allowed_types=self.allowed_getitem,

allowed_methods=self._getitem_methods,

allowed_external=allowed_getitem_external,

method_name="__getitem__",

)

def can_operate(self, dunders: tuple[str, ...], a, b=None):

allowed_operations_external = _coerce_path_to_tuples(

self.allowed_operations_external

)

objects = [a]

if b is not None:

objects.append(b)

return all(

[

_has_original_dunder(

obj,

allowed_types=self.allowed_operations,

allowed_methods=self._operator_dunder_methods(dunder),

allowed_external=allowed_operations_external,

method_name=dunder,

)

for dunder in dunders

for obj in objects

]

)

def _operator_dunder_methods(self, dunder: str) -> set[Callable]:

if dunder not in self._operation_methods_cache:

self._operation_methods_cache[dunder] = self._safe_get_methods(

self.allowed_operations, dunder

)

return self._operation_methods_cache[dunder]

@cached_property

def _getitem_methods(self) -> set[Callable]:

return self._safe_get_methods(self.allowed_getitem, "__getitem__")

@cached_property

def _getattr_methods(self) -> set[Callable]:

return self._safe_get_methods(self.allowed_getattr, "__getattr__")

@cached_property

def _getattribute_methods(self) -> set[Callable]:

return self._safe_get_methods(self.allowed_getattr, "__getattribute__")

def _safe_get_methods(self, classes, name) -> set[Callable]:

return {

method

for class_ in classes

for method in [getattr(class_, name, None)]

if method

}

class _DummyNamedTuple(NamedTuple):

"""Used internally to retrieve methods of named tuple instance."""

EvaluationPolicyName = Literal["forbidden", "minimal", "limited", "unsafe", "dangerous"]

@dataclass

class EvaluationContext:

#: Local namespace

locals: dict

#: Global namespace

globals: dict

#: Evaluation policy identifier

evaluation: EvaluationPolicyName = "forbidden"

#: Whether the evaluation of code takes place inside of a subscript.

#: Useful for evaluating ``:-1, 'col'`` in ``df[:-1, 'col']``.

in_subscript: bool = False

#: Auto import method

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

transient_locals: dict = field(default_factory=dict)

#: Transients of class level

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"""

return dataclasses.replace(self, **changes)

class _IdentitySubscript:

"""Returns the key itself when item is requested via subscript."""

def __getitem__(self, key):

return key

IDENTITY_SUBSCRIPT = _IdentitySubscript()

SUBSCRIPT_MARKER = "__SUBSCRIPT_SENTINEL__"

UNKNOWN_SIGNATURE = Signature()

NOT_EVALUATED = object()

class GuardRejection(Exception):

"""Exception raised when guard rejects evaluation attempt."""

pass

def guarded_eval(code: str, context: EvaluationContext):

"""Evaluate provided code in the evaluation context.

If evaluation policy given by context is set to ``forbidden``

no evaluation will be performed; if it is set to ``dangerous``

standard :func:`eval` will be used; finally, for any other,

policy :func:`eval_node` will be called on parsed AST.

"""

locals_ = context.locals

if context.evaluation == "forbidden":

raise GuardRejection("Forbidden mode")

# note: not using `ast.literal_eval` as it does not implement

# getitem at all, for example it fails on simple `[0][1]`

if context.in_subscript:

# syntactic sugar for ellipsis (:) is only available in subscripts

# so we need to trick the ast parser into thinking that we have

# a subscript, but we need to be able to later recognise that we did

# it so we can ignore the actual __getitem__ operation

if not code:

return tuple()

locals_ = locals_.copy()

locals_[SUBSCRIPT_MARKER] = IDENTITY_SUBSCRIPT

code = SUBSCRIPT_MARKER + "[" + code + "]"

context = context.replace(locals=locals_)

if context.evaluation == "dangerous":

return eval(code, context.globals, context.locals)

node = ast.parse(code, mode="exec")

return eval_node(node, context)

BINARY_OP_DUNDERS: dict[type[ast.operator], tuple[str]] = {

ast.Add: ("__add__",),

ast.Sub: ("__sub__",),

ast.Mult: ("__mul__",),

ast.Div: ("__truediv__",),

ast.FloorDiv: ("__floordiv__",),

ast.Mod: ("__mod__",),

ast.Pow: ("__pow__",),

ast.LShift: ("__lshift__",),

ast.RShift: ("__rshift__",),

ast.BitOr: ("__or__",),

ast.BitXor: ("__xor__",),

ast.BitAnd: ("__and__",),

ast.MatMult: ("__matmul__",),

}

COMP_OP_DUNDERS: dict[type[ast.cmpop], tuple[str, ...]] = {

ast.Eq: ("__eq__",),

ast.NotEq: ("__ne__", "__eq__"),

ast.Lt: ("__lt__", "__gt__"),

ast.LtE: ("__le__", "__ge__"),

ast.Gt: ("__gt__", "__lt__"),

ast.GtE: ("__ge__", "__le__"),

ast.In: ("__contains__",),

# Note: ast.Is, ast.IsNot, ast.NotIn are handled specially

}

UNARY_OP_DUNDERS: dict[type[ast.unaryop], tuple[str, ...]] = {

ast.USub: ("__neg__",),

ast.UAdd: ("__pos__",),

# we have to check both __inv__ and __invert__!

ast.Invert: ("__invert__", "__inv__"),

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__``"""

# no-op: override __class__ to impersonate

class _Duck:

"""A dummy class used to create objects pretending to have given attributes"""

def __init__(self, attributes: Optional[dict] = None, items: Optional[dict] = None):

self.attributes = attributes if attributes is not None else {}

self.items = items if items is not None else {}

def __getattr__(self, attr: str):

return self.attributes[attr]

def __hasattr__(self, attr: str):

return attr in self.attributes

def __dir__(self):

return [*dir(super), *self.attributes]

def __getitem__(self, key: str):

return self.items[key]

def __hasitem__(self, key: str):

return self.items[key]

def _ipython_key_completions_(self):

return self.items.keys()

def _find_dunder(node_op, dunders) -> Union[tuple[str, ...], None]:

dunder = None

for op, candidate_dunder in dunders.items():

if isinstance(node_op, op):

dunder = candidate_dunder

return dunder

def get_policy(context: EvaluationContext) -> EvaluationPolicy:

policy = copy(EVALUATION_POLICIES[context.evaluation])

for key, value in context.policy_overrides.items():

if hasattr(policy, key):

setattr(policy, key, value)

return policy

def _validate_policy_overrides(

policy_name: EvaluationPolicyName, policy_overrides: dict

) -> bool:

policy = EVALUATION_POLICIES[policy_name]

all_good = True

for key, value in policy_overrides.items():

if not hasattr(policy, key):

warnings.warn(

f"Override {key!r} is not valid with {policy_name!r} evaluation policy"

)

all_good = False

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

policy = get_policy(context)

class_transients = context.class_transients

for target in node.targets:

if isinstance(target, (ast.Tuple, ast.List)):

# Handle unpacking assignment

values = list(value)

targets = target.elts

starred = [i for i, t in enumerate(targets) if isinstance(t, ast.Starred)]

# Unified handling: treat no starred as starred at end

star_or_last_idx = starred[0] if starred else len(targets)

# Before starred

for i in range(star_or_last_idx):

# Check for self.x assignment

if _is_instance_attribute_assignment(targets[i], context):

class_transients[targets[i].attr] = values[i]

else:

transient_locals[targets[i].id] = values[i]

# Starred if exists

if starred:

end = len(values) - (len(targets) - star_or_last_idx - 1)

if _is_instance_attribute_assignment(

targets[star_or_last_idx], context

):

class_transients[targets[star_or_last_idx].attr] = values[

star_or_last_idx:end

]

else:

transient_locals[targets[star_or_last_idx].value.id] = values[

star_or_last_idx:end

]

# After starred

for i in range(star_or_last_idx + 1, len(targets)):

if _is_instance_attribute_assignment(targets[i], context):

class_transients[targets[i].attr] = values[

len(values) - (len(targets) - i)

]

else:

transient_locals[targets[i].id] = values[

len(values) - (len(targets) - i)

]

elif isinstance(target, ast.Subscript):

if isinstance(target.value, ast.Name):

name = target.value.id

container = transient_locals.get(name)

if container is None:

container = context.locals.get(name)

if container is None:

container = context.globals.get(name)

if container is None:

raise NameError(

f"{name} not found in locals, globals, nor builtins"

)

storage_dict = transient_locals

storage_key = name

elif isinstance(

target.value, ast.Attribute

) and _is_instance_attribute_assignment(target.value, context):

attr = target.value.attr

container = class_transients.get(attr, None)

if container is None:

raise NameError(f"{attr} not found in class transients")

storage_dict = class_transients

storage_key = attr

else:

return

key = eval_node(target.slice, context)

attributes = (

dict.fromkeys(dir(container))

if policy.can_call(container.__dir__)

else {}

)

items = {}

if policy.can_get_item(container, None):

try:

items = dict(container.items())

except Exception:

pass

items[key] = value

duck_container = _Duck(attributes=attributes, items=items)

storage_dict[storage_key] = duck_container

elif _is_instance_attribute_assignment(target, context):

class_transients[target.attr] = value

else:

transient_locals[target.id] = value

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 = {

k: v

for kw in node.keywords

for k, v in (

{kw.arg: eval_node(kw.value, context)}

if kw.arg

else eval_node(kw.value, context)

).items()

}

return args, kwargs

def _is_instance_attribute_assignment(

target: ast.AST, context: EvaluationContext

) -> bool:

"""Return True if target is an attribute access on the instance argument."""

return (

context.class_transients is not None

and context.instance_arg_name is not None

and isinstance(target, ast.Attribute)

and isinstance(getattr(target, "value", None), ast.Name)

and getattr(target.value, "id", None) == context.instance_arg_name

)

def _get_coroutine_attributes() -> dict[str, Optional[object]]:

async def _dummy():

return None

coro = _dummy()

try:

return {attr: getattr(coro, attr, None) for attr in dir(coro)}

finally:

coro.close()

def eval_node(node: Union[ast.AST, None], context: EvaluationContext):

"""Evaluate AST node in provided context.

Applies evaluation restrictions defined in the context. Currently does not support evaluation of functions with keyword arguments.

Does not evaluate actions that always have side effects:

- class definitions (``class sth: ...``)

- function definitions (``def sth: ...``)

- variable assignments (``x = 1``)

- augmented assignments (``x += 1``)

- deletions (``del x``)

Does not evaluate operations which do not return values:

- assertions (``assert x``)

- pass (``pass``)

- imports (``import x``)

- control flow:

- conditionals (``if x:``) except for ternary IfExp (``a if x else b``)

- loops (``for`` and ``while``)

- exception handling

The purpose of this function is to guard against unwanted side-effects;

it does not give guarantees on protection from malicious code execution.

"""

policy = get_policy(context)

if node is None:

return None

if isinstance(node, (ast.Interactive, ast.Module)):

result = None

for child_node in node.body:

result = eval_node(child_node, context)

return result

if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):

is_async = isinstance(node, ast.AsyncFunctionDef)

func_locals = context.transient_locals.copy()

func_context = context.replace(transient_locals=func_locals)

is_property = False

is_static = False

is_classmethod = False

for decorator_node in node.decorator_list:

try:

decorator = eval_node(decorator_node, context)

except NameError:

# if the decorator is not yet defined this is fine

# especialy because we don't handle imports yet

continue

if decorator is property:

is_property = True

elif decorator is staticmethod:

is_static = True

elif decorator is classmethod:

is_classmethod = True

if func_context.class_transients is not None:

if not is_static and not is_classmethod:

func_context.instance_arg_name = (

node.args.args[0].arg if node.args.args else None

)

return_type = eval_node(node.returns, context=context)

for child_node in node.body:

eval_node(child_node, func_context)

if is_property:

if return_type is not None:

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

return None

def dummy_function(*args, **kwargs):

pass

if return_type is not None:

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:

dummy_function.__inferred_return__ = inferred_return

dummy_function.__name__ = node.name

dummy_function.__node__ = node

dummy_function.__is_async__ = is_async

context.transient_locals[node.name] = dummy_function

return None

if isinstance(node, ast.Lambda):

def dummy_function(*args, **kwargs):

pass

dummy_function.__inferred_return__ = eval_node(node.body, context)

return dummy_function

if isinstance(node, ast.ClassDef):

# TODO support class decorators?

class_locals = {}

outer_locals = context.locals.copy()

outer_locals.update(context.transient_locals)

class_context = context.replace(

transient_locals=class_locals, locals=outer_locals

)

class_context.class_transients = class_locals

for child_node in node.body:

eval_node(child_node, class_context)

bases = tuple([eval_node(base, context) for base in node.bases])

dummy_class = type(node.name, bases, class_locals)

context.transient_locals[node.name] = dummy_class

return None

if isinstance(node, ast.Await):

value = eval_node(node.value, context)

if hasattr(value, "__awaited_type__"):

return value.__awaited_type__

return value

if isinstance(node, ast.While):

loop_locals = context.transient_locals.copy()

loop_context = context.replace(transient_locals=loop_locals)

result = None

for stmt in node.body:

result = eval_node(stmt, loop_context)

policy = get_policy(context)

merged_locals = _merge_dicts_by_key(

[loop_locals, context.transient_locals.copy()], policy

)

context.transient_locals.update(merged_locals)

return result

if isinstance(node, ast.For):

try:

iterable = eval_node(node.iter, context)

except Exception:

iterable = None

sample = None

if iterable is not None:

try:

if policy.can_call(getattr(iterable, "__iter__", None)):

sample = next(iter(iterable))

except Exception:

sample = None

loop_locals = context.transient_locals.copy()

loop_context = context.replace(transient_locals=loop_locals)

if sample is not None:

try:

fake_assign = ast.Assign(

targets=[node.target], value=ast.Constant(value=sample)

)

_handle_assign(fake_assign, loop_context)

except Exception:

pass

result = None

for stmt in node.body:

result = eval_node(stmt, loop_context)

policy = get_policy(context)

merged_locals = _merge_dicts_by_key(

[loop_locals, context.transient_locals.copy()], policy

)

context.transient_locals.update(merged_locals)

return result

if isinstance(node, ast.If):

branches = []

current = node

result = None

while True:

branch_locals = context.transient_locals.copy()

branch_context = context.replace(transient_locals=branch_locals)

for stmt in current.body:

result = eval_node(stmt, branch_context)

branches.append(branch_locals)

if not current.orelse:

break

elif len(current.orelse) == 1 and isinstance(current.orelse[0], ast.If):

# It's an elif - continue loop

current = current.orelse[0]

else:

# It's an else block - process and break

else_locals = context.transient_locals.copy()

else_context = context.replace(transient_locals=else_locals)

for stmt in current.orelse:

result = eval_node(stmt, else_context)

branches.append(else_locals)

break

branches.append(context.transient_locals.copy())

policy = get_policy(context)

merged_locals = _merge_dicts_by_key(branches, policy)

context.transient_locals.update(merged_locals)

return result

if isinstance(node, ast.Assign):

return _handle_assign(node, context)

if isinstance(node, ast.AnnAssign):

return _handle_annassign(node, context)

if isinstance(node, ast.Expression):

return eval_node(node.body, context)

if isinstance(node, ast.Expr):

return eval_node(node.value, context)

if isinstance(node, ast.Pass):

return None

if isinstance(node, ast.Import):

# TODO: populate transient_locals

return None

if isinstance(node, (ast.AugAssign, ast.Delete)):

return None

if isinstance(node, (ast.Global, ast.Nonlocal)):

return None

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()