angr 9.2.102__py3-none-win_amd64.whl → 9.2.103__py3-none-win_amd64.whl

angr/knowledge_plugins/cfg/cfg_model.py

@@ -1,7 +1,8 @@
 # pylint:disable=no-member
 import pickle
 import logging
-from typing import Optional, List, Dict, Tuple, DefaultDict, Callable, TYPE_CHECKING, Set
+from typing import Optional, DefaultDict, TYPE_CHECKING
+from collections.abc import Callable
 from collections import defaultdict
 import bisect
 import string
@@ -65,20 +66,20 @@ class CFGModel(Serializable):
         self.graph = networkx.DiGraph()
 
         # Jump tables
-        self.jump_tables: Dict[int, IndirectJump] = {}
+        self.jump_tables: dict[int, IndirectJump] = {}
 
         # Memory references
         # A mapping between address and the actual data in memory
-        self.memory_data: Dict[int, MemoryData] = {}
+        self.memory_data: dict[int, MemoryData] = {}
         # A mapping between address of the instruction that's referencing the memory data and the memory data itself
-        self.insn_addr_to_memory_data: Dict[int, MemoryData] = {}
+        self.insn_addr_to_memory_data: dict[int, MemoryData] = {}
 
         # Lists of CFGNodes indexed by the address of each block. Don't serialize
-        self._nodes_by_addr: DefaultDict[int, List[CFGNode]] = defaultdict(list)
+        self._nodes_by_addr: DefaultDict[int, list[CFGNode]] = defaultdict(list)
         # CFGNodes dict indexed by block ID. Don't serialize
-        self._nodes: Dict[int, CFGNode] = {}
+        self._nodes: dict[int, CFGNode] = {}
         # addresses of CFGNodes to speed up get_any_node(..., anyaddr=True). Don't serialize
-        self._node_addrs: List[int] = []
+        self._node_addrs: list[int] = []
 
         self.normalized = False
 
@@ -273,8 +274,8 @@ class CFGModel(Serializable):
         return None
 
     def get_any_node(
-        self, addr: int, is_syscall: Optional[bool] = None, anyaddr: bool = False, force_fastpath: bool = False
-    ) -> Optional[CFGNode]:
+        self, addr: int, is_syscall: bool | None = None, anyaddr: bool = False, force_fastpath: bool = False
+    ) -> CFGNode | None:
         """
         Get an arbitrary CFGNode (without considering their contexts) from our graph.
 
@@ -333,7 +334,7 @@ class CFGModel(Serializable):
 
         return None
 
-    def get_all_nodes(self, addr: int, is_syscall: bool = None, anyaddr: bool = False) -> List[CFGNode]:
+    def get_all_nodes(self, addr: int, is_syscall: bool = None, anyaddr: bool = False) -> list[CFGNode]:
         """
         Get all CFGNodes whose address is the specified one.
 
@@ -352,7 +353,7 @@ class CFGModel(Serializable):
 
         return results
 
-    def get_all_nodes_intersecting_region(self, addr: int, size: int = 1) -> Set[CFGNode]:
+    def get_all_nodes_intersecting_region(self, addr: int, size: int = 1) -> set[CFGNode]:
         """
         Get all CFGNodes that intersect the given region.
 
@@ -373,8 +374,8 @@ class CFGModel(Serializable):
         return self.graph.nodes()
 
     def get_predecessors(
-        self, cfgnode: CFGNode, excluding_fakeret: bool = True, jumpkind: Optional[str] = None
-    ) -> List[CFGNode]:
+        self, cfgnode: CFGNode, excluding_fakeret: bool = True, jumpkind: str | None = None
+    ) -> list[CFGNode]:
         """
         Get predecessors of a node in the control flow graph.
 
@@ -409,8 +410,8 @@ class CFGModel(Serializable):
         return predecessors
 
     def get_successors(
-        self, node: CFGNode, excluding_fakeret: bool = True, jumpkind: Optional[str] = None
-    ) -> List[CFGNode]:
+        self, node: CFGNode, excluding_fakeret: bool = True, jumpkind: str | None = None
+    ) -> list[CFGNode]:
         """
         Get successors of a node in the control flow graph.
 
@@ -467,7 +468,7 @@ class CFGModel(Serializable):
 
     def get_predecessors_and_jumpkinds(
         self, node: CFGNode, excluding_fakeret: bool = True
-    ) -> List[Tuple[CFGNode, str]]:
+    ) -> list[tuple[CFGNode, str]]:
         """
         Get a list of tuples where the first element is the predecessor of the CFG node and the second element is the
         jumpkind of the predecessor.
@@ -540,9 +541,7 @@ class CFGModel(Serializable):
     # Memory data
     #
 
-    def add_memory_data(
-        self, data_addr: int, data_type: Optional[MemoryDataSort], data_size: Optional[int] = None
-    ) -> bool:
+    def add_memory_data(self, data_addr: int, data_type: MemoryDataSort | None, data_size: int | None = None) -> bool:
         """
         Add a MemoryData entry to self.memory_data.
 
@@ -563,11 +562,11 @@ class CFGModel(Serializable):
 
     def tidy_data_references(
         self,
-        memory_data_addrs: Optional[List[int]] = None,
-        exec_mem_regions: Optional[List[Tuple[int, int]]] = None,
+        memory_data_addrs: list[int] | None = None,
+        exec_mem_regions: list[tuple[int, int]] | None = None,
         xrefs: Optional["XRefManager"] = None,
         seg_list: Optional["SegmentList"] = None,
-        data_type_guessing_handlers: Optional[List[Callable]] = None,
+        data_type_guessing_handlers: list[Callable] | None = None,
     ) -> bool:
         """
         Go through all data references (or the ones as specified by memory_data_addrs) and determine their sizes and
@@ -748,8 +747,8 @@ class CFGModel(Serializable):
         content_holder=None,
         xrefs: Optional["XRefManager"] = None,
         seg_list: Optional["SegmentList"] = None,
-        data_type_guessing_handlers: Optional[List[Callable]] = None,
-        extra_memory_regions: Optional[List[Tuple[int, int]]] = None,
+        data_type_guessing_handlers: list[Callable] | None = None,
+        extra_memory_regions: list[tuple[int, int]] | None = None,
     ):
         """
         Make a guess to the data type.
@@ -887,7 +886,7 @@ class CFGModel(Serializable):
         data_addr: int,
         pointer_size: int,
         max_size: int,
-        extra_memory_regions: Optional[List[Tuple[int, int]]] = None,
+        extra_memory_regions: list[tuple[int, int]] | None = None,
     ):
         pointers_count = 0
 
@@ -948,7 +947,7 @@ class CFGModel(Serializable):
     #
 
     @staticmethod
-    def _addr_in_exec_memory_regions(addr: int, exec_mem_regions: List[Tuple[int, int]]) -> bool:
+    def _addr_in_exec_memory_regions(addr: int, exec_mem_regions: list[tuple[int, int]]) -> bool:
         for start, end in exec_mem_regions:
             if start <= addr < end:
                 return True
@@ -968,7 +967,7 @@ class CFGModel(Serializable):
         addr: int,
         size: int = 1,
         kb: Optional["KnowledgeBase"] = None,
-    ) -> Set["Function"]:
+    ) -> set["Function"]:
         """
         Find all functions with nodes intersecting [addr, addr + size).
 

angr/knowledge_plugins/cfg/cfg_node.py

@@ -1,6 +1,6 @@
 import traceback
 import logging
-from typing import TYPE_CHECKING, Union, Optional
+from typing import TYPE_CHECKING, Union
 
 from archinfo.arch_soot import SootAddressDescriptor
 import archinfo
@@ -95,7 +95,7 @@ class CFGNode(Serializable):
         self.function_address = function_address
         self.block_id: Union["angr.analyses.cfg.cfg_job_base.BlockID", int] = block_id
         self.thumb = thumb
-        self.byte_string: Optional[bytes] = byte_string
+        self.byte_string: bytes | None = byte_string
 
         self._name = None
         if name is not None:

angr/knowledge_plugins/cfg/indirect_jump.py

@@ -1,5 +1,3 @@
-from typing import List, Optional
-
 from ...serializable import Serializable
 
 
@@ -33,13 +31,13 @@ class IndirectJump(Serializable):
         func_addr: int,
         jumpkind: str,
         stmt_idx: int,
-        resolved_targets: Optional[List[int]] = None,
+        resolved_targets: list[int] | None = None,
         jumptable: bool = False,
-        jumptable_addr: Optional[int] = None,
-        jumptable_size: Optional[int] = None,
-        jumptable_entry_size: Optional[int] = None,
-        jumptable_entries: Optional[List[int]] = None,
-        type_: Optional[int] = IndirectJumpType.Unknown,
+        jumptable_addr: int | None = None,
+        jumptable_size: int | None = None,
+        jumptable_entry_size: int | None = None,
+        jumptable_entries: list[int] | None = None,
+        type_: int | None = IndirectJumpType.Unknown,
     ):
         self.addr = addr
         self.ins_addr = ins_addr

angr/knowledge_plugins/cfg/memory_data.py

@@ -1,5 +1,4 @@
 # pylint:disable=no-member
-from typing import Optional
 from ...protos import cfg_pb2
 from ...serializable import Serializable
 
@@ -57,20 +56,20 @@ class MemoryData(Serializable):
         self,
         address: int,
         size: int,
-        sort: Optional[str],  # temporary type
-        pointer_addr: Optional[int] = None,
-        max_size: Optional[int] = None,
-        reference_size: Optional[int] = None,
+        sort: str | None,  # temporary type
+        pointer_addr: int | None = None,
+        max_size: int | None = None,
+        reference_size: int | None = None,
     ):
         self.addr: int = address
         self.size: int = size
         self.reference_size: int = reference_size
-        self.sort: Optional[str] = sort
+        self.sort: str | None = sort
 
-        self.max_size: Optional[int] = max_size
-        self.pointer_addr: Optional[int] = pointer_addr
+        self.max_size: int | None = max_size
+        self.pointer_addr: int | None = pointer_addr
 
-        self.content: Optional[bytes] = None  # temporary annotation
+        self.content: bytes | None = None  # temporary annotation
 
     def __eq__(self, other: "MemoryData"):
         return (

angr/knowledge_plugins/custom_strings.py

@@ -1,5 +1,3 @@
-from typing import Dict
-
 from .plugin import KnowledgeBasePlugin
 
 
@@ -12,7 +10,7 @@ class CustomStrings(KnowledgeBasePlugin):
         super().__init__(kb=kb)
 
         self.string_id = 0
-        self.strings: Dict[int, bytes] = {}
+        self.strings: dict[int, bytes] = {}
 
     def allocate(self, s: bytes) -> int:
         # de-duplication

angr/knowledge_plugins/debug_variables.py

@@ -1,4 +1,4 @@
-from typing import List, TYPE_CHECKING
+from typing import TYPE_CHECKING
 import logging
 
 import claripy
@@ -174,7 +174,7 @@ class DebugVariableManager(KnowledgeBasePlugin):
         return self.add_variable(cle_var, index.start, index.stop)
 
     # Methods similar to the once in VariableManager
-    def add_variable_list(self, vlist: List[Variable], low_pc: int, high_pc: int):
+    def add_variable_list(self, vlist: list[Variable], low_pc: int, high_pc: int):
         """
         Add all variables in a list with the same visibility range
 

angr/knowledge_plugins/functions/function.py

@@ -3,8 +3,7 @@ import logging
 import networkx
 import itertools
 from collections import defaultdict
-from typing import Union, Optional, Iterable, Set
-from typing import Type
+from collections.abc import Iterable
 
 from itanium_demangler import parse
 
@@ -90,9 +89,9 @@ class Function(Serializable):
         addr,
         name=None,
         syscall=None,
-        is_simprocedure: Optional[bool] = None,
+        is_simprocedure: bool | None = None,
         binary_name=None,
-        is_plt: Optional[bool] = None,
+        is_plt: bool | None = None,
         returning=None,
         alignment=False,
     ):
@@ -117,13 +116,13 @@ class Function(Serializable):
         self.normalized = False
 
         # block nodes at whose ends the function returns
-        self._ret_sites: Set[BlockNode] = set()
+        self._ret_sites: set[BlockNode] = set()
         # block nodes at whose ends the function jumps out to another function (jumps outside)
-        self._jumpout_sites: Set[BlockNode] = set()
+        self._jumpout_sites: set[BlockNode] = set()
         # block nodes at whose ends the function calls out to another non-returning function
-        self._callout_sites: Set[BlockNode] = set()
+        self._callout_sites: set[BlockNode] = set()
         # block nodes that ends the function by returning out to another function (returns outside). This is rare.
-        self._retout_sites: Set[BlockNode] = set()
+        self._retout_sites: set[BlockNode] = set()
         # block nodes (basic block nodes) at whose ends the function terminates
         # in theory, if everything works fine, endpoints == ret_sites | jumpout_sites | callout_sites
         self._endpoints = defaultdict(set)
@@ -142,10 +141,10 @@ class Function(Serializable):
         self.retaddr_on_stack = False
         self.sp_delta = 0
         # Calling convention
-        self.calling_convention: Optional[SimCC] = None
+        self.calling_convention: SimCC | None = None
         # Function prototype
-        self.prototype: Optional[SimTypeFunction] = None
-        self.prototype_libname: Optional[str] = None
+        self.prototype: SimTypeFunction | None = None
+        self.prototype_libname: str | None = None
         self.is_prototype_guessed: bool = True
         # Whether this function returns or not. `None` means it's not determined yet
         self._returning = None
@@ -173,7 +172,7 @@ class Function(Serializable):
         # Stack offsets of those arguments passed in stack variables
         self._argument_stack_variables = []
 
-        self._project: Optional[Project] = None  # will be initialized upon the first access to self.project
+        self._project: Project | None = None  # will be initialized upon the first access to self.project
 
         self.ran_cca = False  # this is set by CompleteCallingConventions to avoid reprocessing failed functions
 
@@ -254,9 +253,9 @@ class Function(Serializable):
                         arch.name, platform=self.project.simos.name if self.project.simos is not None else None
                     )(arch)
 
-            self.calling_convention: Optional[SimCC] = cc
+            self.calling_convention: SimCC | None = cc
         else:
-            self.calling_convention: Optional[SimCC] = None
+            self.calling_convention: SimCC | None = None
 
     @property
     @deprecated(".is_alignment")
@@ -281,7 +280,7 @@ class Function(Serializable):
         if self._project is None:
             # try to set it from function manager
             if self._function_manager is not None:
-                self._project: Optional[Project] = self._function_manager._kb._project
+                self._project: Project | None = self._function_manager._kb._project
         return self._project
 
     @property
@@ -365,7 +364,7 @@ class Function(Serializable):
 
         return self._local_block_addrs
 
-    def get_block(self, addr: int, size: Optional[int] = None, byte_string: Optional[bytes] = None):
+    def get_block(self, addr: int, size: int | None = None, byte_string: bytes | None = None):
         """
         Getting a block out of the current function.
 
@@ -396,7 +395,7 @@ class Function(Serializable):
     # compatibility
     _get_block = get_block
 
-    def get_block_size(self, addr: int) -> Optional[int]:
+    def get_block_size(self, addr: int) -> int | None:
         return self._block_sizes.get(addr, None)
 
     @property
@@ -587,7 +586,7 @@ class Function(Serializable):
             return False
 
     def __str__(self):
-        s = f"Function {self.name} [{self.addr}]\n"
+        s = f"Function {self.name} [{self.addr:#x}]\n"
         s += "  Syscall: %s\n" % self.is_syscall
         s += "  SP difference: %d\n" % self.sp_delta
         s += "  Has return: %s\n" % self.has_return
@@ -664,7 +663,7 @@ class Function(Serializable):
         return self.addr - self.binary.mapped_base
 
     @property
-    def symbol(self) -> Union[None, Symbol]:
+    def symbol(self) -> None | Symbol:
         """
         :return: the function's Symbol, if any
         """
@@ -1586,7 +1585,7 @@ class Function(Serializable):
                 return ast.__str__()
         return self.name
 
-    def get_unambiguous_name(self, display_name: Optional[str] = None) -> str:
+    def get_unambiguous_name(self, display_name: str | None = None) -> str:
         """
         Get a disambiguated function name.
 
@@ -1614,7 +1613,7 @@ class Function(Serializable):
             n += self.binary_name + separator
         return n + (display_name or self.name)
 
-    def apply_definition(self, definition: str, calling_convention: Optional[Union[SimCC, Type[SimCC]]] = None) -> None:
+    def apply_definition(self, definition: str, calling_convention: SimCC | type[SimCC] | None = None) -> None:
         if not definition.endswith(";"):
             definition += ";"
         func_def = parse_defns(definition, arch=self.project.arch)
@@ -1642,7 +1641,7 @@ class Function(Serializable):
         else:
             raise TypeError("calling_convention has to be one of: [SimCC, type(SimCC), None]")
 
-    def functions_called(self) -> Set["Function"]:
+    def functions_reachable(self) -> set["Function"]:
         """
         :return: The set of all functions that can be reached from the function represented by self.
         """

angr/knowledge_plugins/functions/function_manager.py

@@ -1,5 +1,5 @@
 # pylint:disable=raise-missing-from
-from typing import Dict, Generator, Optional, Set
+from collections.abc import Generator
 import logging
 import collections.abc
 import re
@@ -83,8 +83,8 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
         super().__init__(kb=kb)
         self.function_address_types = self._kb._project.arch.function_address_types
         self.address_types = self._kb._project.arch.address_types
-        self._function_map: Dict[int, Function] = FunctionDict(self, key_types=self.function_address_types)
-        self.function_addrs_set: Set = set()
+        self._function_map: dict[int, Function] = FunctionDict(self, key_types=self.function_address_types)
+        self.function_addrs_set: set = set()
         self.callgraph = networkx.MultiDiGraph()
         self.block_map = {}
 
@@ -411,7 +411,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
         except KeyError:
             return None
 
-    def query(self, query: str) -> Optional[Function]:
+    def query(self, query: str) -> Function | None:
         """
         Query for a function using selectors to disambiguate. Supported variations:
 
@@ -442,7 +442,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
 
         return None
 
-    def function(self, addr=None, name=None, create=False, syscall=False, plt=None) -> Optional[Function]:
+    def function(self, addr=None, name=None, create=False, syscall=False, plt=None) -> Function | None:
         """
         Get a function object from the function manager.
 

angr/knowledge_plugins/indirect_jumps.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from .plugin import KnowledgeBasePlugin
 
 
@@ -22,7 +20,7 @@ class IndirectJumps(KnowledgeBasePlugin, dict):
         for k, v in self.resolved.items():
             o.resolved[k] = v
 
-    def update_resolved_addrs(self, indirect_address: int, resolved_addresses: List[int]):
+    def update_resolved_addrs(self, indirect_address: int, resolved_addresses: list[int]):
         # sanity check on usage
         if indirect_address is None:
             return

angr/knowledge_plugins/key_definitions/atoms.py

@@ -1,4 +1,4 @@
-from typing import Union, Optional
+from typing import Union
 from enum import Enum, auto
 
 import claripy
@@ -65,7 +65,7 @@ class Atom:
 
     @staticmethod
     def from_argument(
-        argument: SimFunctionArgument, arch: Arch, full_reg=False, sp: Optional[int] = None
+        argument: SimFunctionArgument, arch: Arch, full_reg=False, sp: int | None = None
     ) -> Union["Register", "MemoryLocation"]:
         """
         Instanciate an `Atom` from a given argument.
@@ -91,7 +91,7 @@ class Atom:
             raise TypeError("Argument type %s is not yet supported." % type(argument))
 
     @staticmethod
-    def reg(thing: Union[str, RegisterOffset], size: Optional[int] = None, arch: Optional[Arch] = None) -> "Register":
+    def reg(thing: str | RegisterOffset, size: int | None = None, arch: Arch | None = None) -> "Register":
         """
         Create a Register atom.
 
@@ -126,7 +126,7 @@ class Atom:
     register = reg
 
     @staticmethod
-    def mem(addr: Union[SpOffset, HeapAddress, int], size: int, endness: Optional[str] = None) -> "MemoryLocation":
+    def mem(addr: SpOffset | HeapAddress | int, size: int, endness: str | None = None) -> "MemoryLocation":
         """
         Create a MemoryLocation atom,
 
@@ -223,7 +223,7 @@ class Register(Atom):
         "arch",
     )
 
-    def __init__(self, reg_offset: RegisterOffset, size: int, arch: Optional[Arch] = None):
+    def __init__(self, reg_offset: RegisterOffset, size: int, arch: Arch | None = None):
         super().__init__(size)
 
         self.reg_offset = reg_offset
@@ -254,14 +254,14 @@ class MemoryLocation(Atom):
         "endness",
     )
 
-    def __init__(self, addr: Union[SpOffset, HeapAddress, int], size: int, endness: Optional[str] = None):
+    def __init__(self, addr: SpOffset | HeapAddress | int, size: int, endness: str | None = None):
         """
         :param int addr: The address of the beginning memory location slice.
         :param int size: The size of the represented memory location, in bytes.
         """
         super().__init__(size)
 
-        self.addr: Union[SpOffset, int, claripy.ast.BV] = addr
+        self.addr: SpOffset | int | claripy.ast.BV = addr
         self.endness = endness
 
     def __repr__(self):

angr/knowledge_plugins/key_definitions/definition.py

@@ -1,4 +1,4 @@
-from typing import Set, Optional, Literal, Type, TypeVar, Union, Generic
+from typing import Optional, Literal, TypeVar, Generic
 from dataclasses import dataclass
 import logging
 
@@ -25,18 +25,18 @@ class DefinitionMatchPredicate:
     internal class; don't worry about this.
     """
 
-    kind: Union[AtomKind, Type[Atom], None] = None
-    bbl_addr: Optional[int] = None
-    ins_addr: Optional[int] = None
-    variable: Optional[SimVariable] = None
-    variable_manager: Union[VariableManagerInternal, None, Literal[False]] = None
-    stack_offset: Optional[int] = None
-    reg_name: Optional[Union[str, int]] = None
-    heap_offset: Optional[int] = None
-    global_addr: Optional[int] = None
-    tmp_idx: Optional[int] = None
-    const_val: Optional[int] = None
-    extern: Optional[bool] = None
+    kind: AtomKind | type[Atom] | None = None
+    bbl_addr: int | None = None
+    ins_addr: int | None = None
+    variable: SimVariable | None = None
+    variable_manager: VariableManagerInternal | None | Literal[False] = None
+    stack_offset: int | None = None
+    reg_name: str | int | None = None
+    heap_offset: int | None = None
+    global_addr: int | None = None
+    tmp_idx: int | None = None
+    const_val: int | None = None
+    extern: bool | None = None
 
     @staticmethod
     def construct(predicate: Optional["DefinitionMatchPredicate"] = None, **kwargs) -> "DefinitionMatchPredicate":
@@ -159,7 +159,7 @@ class Definition(Generic[A]):
         "_hash",
     )
 
-    def __init__(self, atom: A, codeloc: CodeLocation, dummy: bool = False, tags: Optional[Set[Tag]] = None):
+    def __init__(self, atom: A, codeloc: CodeLocation, dummy: bool = False, tags: set[Tag] | None = None):
         self.atom: A = atom
         self.codeloc: CodeLocation = codeloc
         self.dummy: bool = dummy

angr/knowledge_plugins/key_definitions/environment.py

@@ -1,5 +1,3 @@
-from typing import Dict, Tuple, Union, Set
-
 import claripy
 
 from .undefined import Undefined, UNDEFINED
@@ -16,10 +14,10 @@ class Environment:
 
     __slots__ = ("_environment",)
 
-    def __init__(self, environment: Dict[Union[str, Undefined], Set[claripy.ast.Base]] = None):
-        self._environment: Dict[Union[str, Undefined], Set[claripy.ast.Base]] = environment or {}
+    def __init__(self, environment: dict[str | Undefined, set[claripy.ast.Base]] = None):
+        self._environment: dict[str | Undefined, set[claripy.ast.Base]] = environment or {}
 
-    def get(self, names: Set[str]) -> Tuple[Set[claripy.ast.Base], bool]:
+    def get(self, names: set[str]) -> tuple[set[claripy.ast.Base], bool]:
         """
         :param names: Potential values for the name of the environment variable to get the pointers of.
         :return:
@@ -40,7 +38,7 @@ class Environment:
 
         return pointers, has_unknown
 
-    def set(self, name: Union[str, Undefined], pointers: Set[claripy.ast.Base]):
+    def set(self, name: str | Undefined, pointers: set[claripy.ast.Base]):
         """
         :param name: Name of the environment variable to which we will associate the pointers.
         :param pointers: New addresses where the new values of the environment variable are located.
@@ -59,7 +57,7 @@ class Environment:
         assert isinstance(other, Environment), "Cannot compare Environment with %s" % type(other).__name__
         return self._environment == other._environment
 
-    def merge(self, *others: "Environment") -> Tuple["Environment", bool]:
+    def merge(self, *others: "Environment") -> tuple["Environment", bool]:
         new_env = self._environment
 
         for other in others:

angr/knowledge_plugins/key_definitions/heap_address.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 from .undefined import Undefined
 
 
@@ -8,7 +6,7 @@ class HeapAddress:
     The representation of an address on the heap.
     """
 
-    def __init__(self, value: Union[int, Undefined]):
+    def __init__(self, value: int | Undefined):
         self._value = value
 
     @property

angr/knowledge_plugins/key_definitions/key_definition_manager.py

@@ -1,4 +1,5 @@
-from typing import Dict, Iterable, TYPE_CHECKING
+from typing import TYPE_CHECKING
+from collections.abc import Iterable
 
 from .. import KnowledgeBasePlugin
 from .rd_model import ReachingDefinitionsModel
@@ -39,7 +40,7 @@ class KeyDefinitionManager(KnowledgeBasePlugin):
 
     def __init__(self, kb: "KnowledgeBase"):
         super().__init__(kb=kb)
-        self.model_by_funcaddr: Dict[int, ReachingDefinitionsModel] = {}
+        self.model_by_funcaddr: dict[int, ReachingDefinitionsModel] = {}
 
     def has_model(self, func_addr: int):
         return func_addr in self.model_by_funcaddr