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

angr/knowledge_plugins/variables/variable_manager.py

@@ -1,4 +1,4 @@
-from typing import Set, List, Tuple, Dict, Union, Optional, Literal, TYPE_CHECKING
+from typing import Literal, TYPE_CHECKING
 import logging
 from collections import defaultdict
 from itertools import count, chain
@@ -74,22 +74,22 @@ class VariableManagerInternal(Serializable):
 
         self.func_addr = func_addr
 
-        self._variables: Set[SimVariable] = OrderedSet()  # all variables that are added to any region
+        self._variables: set[SimVariable] = OrderedSet()  # all variables that are added to any region
         self._global_region = KeyedRegion()
         self._stack_region = KeyedRegion()
         self._register_region = KeyedRegion()
         self._live_variables = {}  # a mapping between addresses of program points and live variable collections
 
-        self._variable_accesses: Dict[SimVariable, Set[VariableAccess]] = defaultdict(set)
-        self._insn_to_variable: Dict[int, Set[Tuple[SimVariable, int]]] = defaultdict(set)
-        self._stmt_to_variable: Dict[Union[Tuple[int, int], Tuple[int, int, int]], Set[Tuple[SimVariable, int]]] = (
+        self._variable_accesses: dict[SimVariable, set[VariableAccess]] = defaultdict(set)
+        self._insn_to_variable: dict[int, set[tuple[SimVariable, int]]] = defaultdict(set)
+        self._stmt_to_variable: dict[tuple[int, int] | tuple[int, int, int], set[tuple[SimVariable, int]]] = (
             defaultdict(set)
         )
-        self._variable_to_stmt: Dict[SimVariable, Set[Union[Tuple[int, int], Tuple[int, int, int]]]] = defaultdict(set)
-        self._atom_to_variable: Dict[
-            Union[Tuple[int, int], Tuple[int, int, int]], Dict[int, Set[Tuple[SimVariable, int]]]
+        self._variable_to_stmt: dict[SimVariable, set[tuple[int, int] | tuple[int, int, int]]] = defaultdict(set)
+        self._atom_to_variable: dict[
+            tuple[int, int] | tuple[int, int, int], dict[int, set[tuple[SimVariable, int]]]
         ] = defaultdict(_defaultdict_set)
-        self._ident_to_variable: Dict[str, SimVariable] = {}
+        self._ident_to_variable: dict[str, SimVariable] = {}
         self._variable_counters = {
             "register": count(),
             "stack": count(),
@@ -98,15 +98,15 @@ class VariableManagerInternal(Serializable):
             "global": count(),
         }
 
-        self._unified_variables: Set[SimVariable] = set()
-        self._variables_to_unified_variables: Dict[SimVariable, SimVariable] = {}
+        self._unified_variables: set[SimVariable] = set()
+        self._variables_to_unified_variables: dict[SimVariable, SimVariable] = {}
 
         self._phi_variables = {}
         self._variables_to_phivars = defaultdict(set)
         self._phi_variables_by_block = defaultdict(set)
 
         self.types = TypesStore(self.manager._kb)
-        self.variable_to_types: Dict[SimVariable, SimType] = {}
+        self.variable_to_types: dict[SimVariable, SimType] = {}
         self.variables_with_manual_types = set()
 
         # optimization
@@ -207,7 +207,7 @@ class VariableManagerInternal(Serializable):
         unified_stack_variables = []
         unified_memory_variables = []
 
-        unified_variable_idents: Set[str] = set()
+        unified_variable_idents: set[str] = set()
         for variable in self._unified_variables:
             unified_variable_idents.add(variable.ident)
             if isinstance(variable, SimRegisterVariable):
@@ -586,15 +586,15 @@ class VariableManagerInternal(Serializable):
 
         return vars_and_offset
 
-    def is_variable_used_at(self, variable: SimVariable, loc: Tuple[int, int]) -> bool:
+    def is_variable_used_at(self, variable: SimVariable, loc: tuple[int, int]) -> bool:
         return loc in self._variable_to_stmt[variable]
 
-    def find_variable_by_stmt(self, block_addr, stmt_idx, sort, block_idx: Optional[int] = None):
+    def find_variable_by_stmt(self, block_addr, stmt_idx, sort, block_idx: int | None = None):
         return next(iter(self.find_variables_by_stmt(block_addr, stmt_idx, sort, block_idx=block_idx)), None)
 
     def find_variables_by_stmt(
-        self, block_addr: int, stmt_idx: int, sort: str, block_idx: Optional[int] = None
-    ) -> List[Tuple[SimVariable, int]]:
+        self, block_addr: int, stmt_idx: int, sort: str, block_idx: int | None = None
+    ) -> list[tuple[SimVariable, int]]:
         key = (block_addr, stmt_idx) if block_idx is None else (block_addr, block_idx, stmt_idx)
 
         if key not in self._stmt_to_variable:
@@ -620,12 +620,12 @@ class VariableManagerInternal(Serializable):
 
         return var_and_offsets
 
-    def find_variable_by_atom(self, block_addr, stmt_idx, atom, block_idx: Optional[int] = None):
+    def find_variable_by_atom(self, block_addr, stmt_idx, atom, block_idx: int | None = None):
         return next(iter(self.find_variables_by_atom(block_addr, stmt_idx, atom, block_idx=block_idx)), None)
 
     def find_variables_by_atom(
-        self, block_addr, stmt_idx, atom, block_idx: Optional[int] = None
-    ) -> Set[Tuple[SimVariable, int]]:
+        self, block_addr, stmt_idx, atom, block_idx: int | None = None
+    ) -> set[tuple[SimVariable, int]]:
         if block_idx is None:
             key = block_addr, stmt_idx
         else:
@@ -640,15 +640,15 @@ class VariableManagerInternal(Serializable):
 
         return self._atom_to_variable[key][atom_hash]
 
-    def find_variables_by_stack_offset(self, offset: int) -> Set[SimVariable]:
+    def find_variables_by_stack_offset(self, offset: int) -> set[SimVariable]:
         return self._stack_region.get_variables_by_offset(offset)
 
-    def find_variables_by_register(self, reg: Union[str, int]) -> Set[SimVariable]:
+    def find_variables_by_register(self, reg: str | int) -> set[SimVariable]:
         if type(reg) is str:
             reg = self.manager._kb._project.arch.registers.get(reg)[0]
         return self._register_region.get_variables_by_offset(reg)
 
-    def get_variable_accesses(self, variable: SimVariable, same_name: bool = False) -> List[VariableAccess]:
+    def get_variable_accesses(self, variable: SimVariable, same_name: bool = False) -> list[VariableAccess]:
         if not same_name:
             if variable in self._variable_accesses:
                 return list(self._variable_accesses[variable])
@@ -670,8 +670,8 @@ class VariableManagerInternal(Serializable):
         return accesses
 
     def get_variables(
-        self, sort: Optional[Literal["stack", "reg"]] = None, collapse_same_ident=False
-    ) -> List[Union[SimStackVariable, SimRegisterVariable]]:
+        self, sort: Literal["stack", "reg"] | None = None, collapse_same_ident=False
+    ) -> list[SimStackVariable | SimRegisterVariable]:
         """
         Get a list of variables.
 
@@ -695,8 +695,8 @@ class VariableManagerInternal(Serializable):
         return variables
 
     def get_unified_variables(
-        self, sort: Optional[Literal["stack", "reg"]] = None
-    ) -> List[Union[SimStackVariable, SimRegisterVariable]]:
+        self, sort: Literal["stack", "reg"] | None = None
+    ) -> list[SimStackVariable | SimRegisterVariable]:
         """
         Get a list of unified variables.
 
@@ -764,7 +764,7 @@ class VariableManagerInternal(Serializable):
             variables[phi] = self._phi_variables[phi]
         return variables
 
-    def get_variables_without_writes(self) -> List[SimVariable]:
+    def get_variables_without_writes(self) -> list[SimVariable]:
         """
         Get all variables that have never been written to.
 
@@ -845,7 +845,7 @@ class VariableManagerInternal(Serializable):
                     var.name = "g_%s" % var.addr
 
     def assign_unified_variable_names(
-        self, labels=None, arg_names: Optional[List[str]] = None, reset: bool = False
+        self, labels=None, arg_names: list[str] | None = None, reset: bool = False
     ) -> None:
         """
         Assign default names to all unified variables.
@@ -918,7 +918,7 @@ class VariableManagerInternal(Serializable):
             var.name = arg_names[idx] if arg_names else f"a{idx}"
             var._hash = None
 
-    def _register_struct_type(self, ty: SimStruct, name: Optional[str] = None) -> TypeRef:
+    def _register_struct_type(self, ty: SimStruct, name: str | None = None) -> TypeRef:
         if not name:
             name = ty.name
         if not name:
@@ -933,7 +933,7 @@ class VariableManagerInternal(Serializable):
         self,
         var: SimVariable,
         ty: SimType,
-        name: Optional[str] = None,
+        name: str | None = None,
         override_bot: bool = True,
         all_unified: bool = False,
         mark_manual: bool = False,
@@ -973,7 +973,7 @@ class VariableManagerInternal(Serializable):
                         if mark_manual:
                             self.variables_with_manual_types.add(other_var)
 
-    def get_variable_type(self, var) -> Optional[SimType]:
+    def get_variable_type(self, var) -> SimType | None:
         return self.variable_to_types.get(var, None)
 
     def remove_types(self):
@@ -985,8 +985,8 @@ class VariableManagerInternal(Serializable):
         Map SSA variables to a unified variable. Fill in self._unified_variables.
         """
 
-        stack_vars: Dict[int, List[SimStackVariable]] = defaultdict(list)
-        reg_vars: Set[SimRegisterVariable] = set()
+        stack_vars: dict[int, list[SimStackVariable]] = defaultdict(list)
+        reg_vars: set[SimRegisterVariable] = set()
 
         # unify stack variables based on their locations
         for v in self.get_variables():
@@ -1060,7 +1060,7 @@ class VariableManagerInternal(Serializable):
         self._unified_variables.add(unified)
         self._variables_to_unified_variables[variable] = unified
 
-    def unified_variable(self, variable: SimVariable) -> Optional[SimVariable]:
+    def unified_variable(self, variable: SimVariable) -> SimVariable | None:
         """
         Return the unified variable for a given SSA variable,
 
@@ -1079,7 +1079,7 @@ class VariableManager(KnowledgeBasePlugin):
     def __init__(self, kb):
         super().__init__(kb=kb)
         self.global_manager = VariableManagerInternal(self)
-        self.function_managers: Dict[int, VariableManagerInternal] = {}
+        self.function_managers: dict[int, VariableManagerInternal] = {}
 
     def __contains__(self, key) -> bool:
         if key == "global":
@@ -1135,7 +1135,7 @@ class VariableManager(KnowledgeBasePlugin):
         for manager in self.function_managers.values():
             manager.assign_variable_names()
 
-    def get_variable_accesses(self, variable: SimVariable, same_name: bool = False) -> List[VariableAccess]:
+    def get_variable_accesses(self, variable: SimVariable, same_name: bool = False) -> list[VariableAccess]:
         """
         Get a list of all references to the given variable.
 
@@ -1158,7 +1158,7 @@ class VariableManager(KnowledgeBasePlugin):
         raise NotImplementedError
 
     @staticmethod
-    def convert_variable_list(vlist: List[Variable], manager: VariableManagerInternal):
+    def convert_variable_list(vlist: list[Variable], manager: VariableManagerInternal):
         for v in vlist:
             simv = None
             if v.type is None:
@@ -1176,7 +1176,7 @@ class VariableManager(KnowledgeBasePlugin):
             simv.name = v.name
             manager.add_variable(v.sort, v.addr, simv)
 
-    def load_from_dwarf(self, cu_list: List[CompilationUnit] = None):
+    def load_from_dwarf(self, cu_list: list[CompilationUnit] = None):
         cu_list = cu_list or self._kb._project.loader.main_object.compilation_units
         if cu_list is None:
             l.warning("no CompilationUnit found")

angr/knowledge_plugins/xrefs/xref.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from ...serializable import Serializable
 from ...protos import primitives_pb2
 from .xref_types import XRefType
@@ -23,22 +21,22 @@ class XRef(Serializable):
 
     def __init__(
         self,
-        ins_addr: Optional[int] = None,
-        block_addr: Optional[int] = None,
-        stmt_idx: Optional[int] = None,
-        insn_op_idx: Optional[int] = None,
+        ins_addr: int | None = None,
+        block_addr: int | None = None,
+        stmt_idx: int | None = None,
+        insn_op_idx: int | None = None,
         memory_data=None,
-        dst: Optional[int] = None,
+        dst: int | None = None,
         xref_type=None,
     ):
         if dst is not None and not isinstance(dst, int):
             raise TypeError("XRefs must be pointing to a constant target. Target %r is not supported." % dst)
 
         # src
-        self.ins_addr: Optional[int] = ins_addr
-        self.insn_op_idx: Optional[int] = insn_op_idx
-        self.block_addr: Optional[int] = block_addr
-        self.stmt_idx: Optional[int] = stmt_idx
+        self.ins_addr: int | None = ins_addr
+        self.insn_op_idx: int | None = insn_op_idx
+        self.block_addr: int | None = block_addr
+        self.stmt_idx: int | None = stmt_idx
 
         # dst
         self.memory_data = memory_data  # optional

angr/knowledge_plugins/xrefs/xref_manager.py

@@ -1,4 +1,3 @@
-from typing import Set, Dict
 import logging
 from collections import defaultdict
 
@@ -15,8 +14,8 @@ class XRefManager(KnowledgeBasePlugin, Serializable):
     def __init__(self, kb):
         super().__init__(kb=kb)
 
-        self.xrefs_by_ins_addr: Dict[int, Set[XRef]] = defaultdict(set)
-        self.xrefs_by_dst: Dict[int, Set[XRef]] = defaultdict(set)
+        self.xrefs_by_ins_addr: dict[int, set[XRef]] = defaultdict(set)
+        self.xrefs_by_dst: dict[int, set[XRef]] = defaultdict(set)
 
     def copy(self):
         xm = XRefManager(self._kb)
@@ -70,7 +69,7 @@ class XRefManager(KnowledgeBasePlugin, Serializable):
             refs = refs.union(self.xrefs_by_dst[addr])
         return refs
 
-    def get_xrefs_by_ins_addr_region(self, start, end) -> Set[XRef]:
+    def get_xrefs_by_ins_addr_region(self, start, end) -> set[XRef]:
         """
         Get a set of XRef objects that originate at a given address region
         bounded by start and end.  Useful for finding references from a basic block or function.

angr/misc/ansi.py

@@ -1,4 +1,3 @@
-from typing import Union
 from enum import Enum, unique
 
 
@@ -37,7 +36,7 @@ BackgroundColor = unique(Enum("BackgroundColor", {i.name: (i.value + 10) for i i
 #
 
 
-def color(c: Union[Color, BackgroundColor], bright: bool):
+def color(c: Color | BackgroundColor, bright: bool):
     """
     Return the ansi prefix using the given code
     Bright may not be used with a BackgroundColor

angr/misc/autoimport.py

@@ -3,7 +3,7 @@ import importlib
 import importlib.machinery
 import importlib.util
 import logging
-from typing import Optional, Callable
+from collections.abc import Callable
 
 
 l = logging.getLogger(name=__name__)
@@ -36,7 +36,7 @@ def auto_import_packages(base_module, base_path, ignore_dirs=(), ignore_files=()
             yield lib_module_name, package
 
 
-def auto_import_modules(base_module, base_path, ignore_files=(), filter_func: Optional[Callable] = None):
+def auto_import_modules(base_module, base_path, ignore_files=(), filter_func: Callable | None = None):
     for proc_file_name in os.listdir(base_path):
         if not proc_file_name.endswith(".py"):
             continue
@@ -65,7 +65,7 @@ def filter_module(mod, type_req=None, subclass_req=None):
         yield name, val
 
 
-def auto_import_source_files(base_path, ignore_files=(), filter_func: Optional[Callable] = None):
+def auto_import_source_files(base_path, ignore_files=(), filter_func: Callable | None = None):
     for proc_file_name in os.listdir(base_path):
         if not proc_file_name.endswith(".py"):
             continue

angr/misc/plugins.py

@@ -1,4 +1,4 @@
-from typing import Type, Dict, Optional, List, TypeVar, Generic
+from typing import TypeVar, Generic
 
 from angr.errors import AngrNoPluginError
 
@@ -26,15 +26,15 @@ class PluginHub(Generic[P]):
 
     def __init__(self):
         super().__init__()
-        self._active_plugins: Dict[str, P] = {}
-        self._active_preset: Optional[PluginPreset] = None
-        self._provided_by_preset: List[int] = []
+        self._active_plugins: dict[str, P] = {}
+        self._active_preset: PluginPreset | None = None
+        self._provided_by_preset: list[int] = []
 
     #
     #   Class methods for registration
     #
 
-    _presets: Dict[str, Type[P]]
+    _presets: dict[str, type[P]]
 
     @classmethod
     def register_default(cls, name, plugin_cls, preset="default"):
@@ -157,7 +157,7 @@ class PluginHub(Generic[P]):
             return self._active_plugins[name]
 
         elif self._active_preset is not None:
-            plugin_cls: Type[P] = self._active_preset.request_plugin(name)
+            plugin_cls: type[P] = self._active_preset.request_plugin(name)
             plugin = self._init_plugin(plugin_cls)
 
             # Remember that this plugin was provided by preset.
@@ -169,7 +169,7 @@ class PluginHub(Generic[P]):
         else:
             raise AngrNoPluginError("No such plugin: %s" % name)
 
-    def _init_plugin(self, plugin_cls: Type[P]) -> P:  # pylint: disable=no-self-use
+    def _init_plugin(self, plugin_cls: type[P]) -> P:  # pylint: disable=no-self-use
         """
         Perform any initialization actions on plugin before it is added to the list of active plugins.
 
@@ -217,7 +217,7 @@ class PluginPreset:
     """
 
     def __init__(self):
-        self._default_plugins: Dict[str, Type[P]] = {}
+        self._default_plugins: dict[str, type[P]] = {}
 
     def activate(self, hub):  # pylint:disable=no-self-use,unused-argument
         """
@@ -243,7 +243,7 @@ class PluginPreset:
         """
         return self._default_plugins.keys()
 
-    def request_plugin(self, name: str) -> Type[P]:
+    def request_plugin(self, name: str) -> type[P]:
         """
         Return the plugin class which is registered under the name ``name``, or raise NoPlugin if
         the name isn't available.

angr/procedures/definitions/__init__.py

@@ -25,8 +25,8 @@ if TYPE_CHECKING:
 
 
 l = logging.getLogger(name=__name__)
-SIM_LIBRARIES: Dict[str, "SimLibrary"] = {}
-SIM_TYPE_COLLECTIONS: Dict[str, "SimTypeCollection"] = {}
+SIM_LIBRARIES: dict[str, "SimLibrary"] = {}
+SIM_TYPE_COLLECTIONS: dict[str, "SimTypeCollection"] = {}
 
 
 class SimTypeCollection:
@@ -35,8 +35,8 @@ class SimTypeCollection:
     """
 
     def __init__(self):
-        self.names: Optional[List[str]] = None
-        self.types: Dict[str, "SimType"] = {}
+        self.names: list[str] | None = None
+        self.types: dict[str, "SimType"] = {}
 
     def set_names(self, *names):
         self.names = names
@@ -98,10 +98,10 @@ class SimLibrary:
     """
 
     def __init__(self):
-        self.type_collection_names: List[str] = []
+        self.type_collection_names: list[str] = []
         self.procedures = {}
         self.non_returning = set()
-        self.prototypes: Dict[str, SimTypeFunction] = {}
+        self.prototypes: dict[str, SimTypeFunction] = {}
         self.default_ccs = {}
         self.names = []
         self.fallback_cc = dict(DEFAULT_CC)
@@ -292,7 +292,7 @@ class SimLibrary:
         self._apply_metadata(proc, arch)
         return proc
 
-    def get_prototype(self, name: str, arch=None) -> Optional[SimTypeFunction]:
+    def get_prototype(self, name: str, arch=None) -> SimTypeFunction | None:
         """
         Get a prototype of the given function name, optionally specialize the prototype to a given architecture.
 
@@ -355,7 +355,7 @@ class SimCppLibrary(SimLibrary):
         return name
 
     @staticmethod
-    def _proto_from_demangled_name(name: str) -> Optional[SimTypeFunction]:
+    def _proto_from_demangled_name(name: str) -> SimTypeFunction | None:
         """
         Attempt to extract arguments and calling convention information for a C++ function whose name was mangled
         according to the Itanium C++ ABI symbol mangling language.
@@ -411,7 +411,7 @@ class SimCppLibrary(SimLibrary):
                     stub.num_args = len(stub.prototype.args)
         return stub
 
-    def get_prototype(self, name: str, arch=None) -> Optional[SimTypeFunction]:
+    def get_prototype(self, name: str, arch=None) -> SimTypeFunction | None:
         """
         Get a prototype of the given function name, optionally specialize the prototype to a given architecture. The
         function name will be demangled first.
@@ -468,10 +468,10 @@ class SimSyscallLibrary(SimLibrary):
 
     def __init__(self):
         super().__init__()
-        self.syscall_number_mapping: Dict[str, Dict[int, str]] = defaultdict(dict)  # keyed by abi
-        self.syscall_name_mapping: Dict[str, Dict[str, int]] = defaultdict(dict)  # keyed by abi
-        self.default_cc_mapping: Dict[str, Type["SimCCSyscall"]] = {}  # keyed by abi
-        self.syscall_prototypes: Dict[str, Dict[str, SimTypeFunction]] = defaultdict(dict)  # keyed by abi
+        self.syscall_number_mapping: dict[str, dict[int, str]] = defaultdict(dict)  # keyed by abi
+        self.syscall_name_mapping: dict[str, dict[str, int]] = defaultdict(dict)  # keyed by abi
+        self.default_cc_mapping: dict[str, type["SimCCSyscall"]] = {}  # keyed by abi
+        self.syscall_prototypes: dict[str, dict[str, SimTypeFunction]] = defaultdict(dict)  # keyed by abi
         self.fallback_proc = stub_syscall
 
     def copy(self):
@@ -551,7 +551,7 @@ class SimSyscallLibrary(SimLibrary):
         """
         self.syscall_prototypes[abi][name] = proto
 
-    def set_prototypes(self, abi: str, protos: Dict[str, SimTypeFunction]) -> None:  # pylint: disable=arguments-differ
+    def set_prototypes(self, abi: str, protos: dict[str, SimTypeFunction]) -> None:  # pylint: disable=arguments-differ
         """
         Set the prototypes of many syscalls.
 
@@ -621,7 +621,7 @@ class SimSyscallLibrary(SimLibrary):
         l.debug("unsupported syscall: %s", number)
         return proc
 
-    def get_prototype(self, abi: str, name: str, arch=None) -> Optional[SimTypeFunction]:
+    def get_prototype(self, abi: str, name: str, arch=None) -> SimTypeFunction | None:
         """
         Get a prototype of the given syscall name and its ABI, optionally specialize the prototype to a given
         architecture.
@@ -686,7 +686,7 @@ class SimSyscallLibrary(SimLibrary):
 # - We will load all APIs when load_all_definitions() is called.
 
 _DEFINITIONS_BASEDIR = os.path.dirname(os.path.realpath(__file__))
-_EXTERNAL_DEFINITIONS_DIRS: Optional[List[str]] = None
+_EXTERNAL_DEFINITIONS_DIRS: list[str] | None = None
 
 
 def load_type_collections(skip=None) -> None:

angr/procedures/definitions/linux_kernel.py

@@ -1279,7 +1279,7 @@ _amd64_fd_spots = \
 }
 
 
-_syscall_abis: Dict[str,Dict[str,SimTypeFunction]] = {
+_syscall_abis: dict[str,dict[str,SimTypeFunction]] = {
     "amd64": {},
     "arm": {},
     "armhf": {},

angr/procedures/definitions/parse_win32json.py

@@ -22,7 +22,7 @@ altnames = set()
 
 typelib = SimTypeCollection()
 typelib.names = ["win32"]
-known_struct_names: Set[str] = set()
+known_struct_names: set[str] = set()
 
 
 def is_anonymous_struct(s_name: str) -> bool:

angr/procedures/java_jni/__init__.py

@@ -20,7 +20,7 @@ class JNISimProcedure(SimProcedure):
     """
 
     # Java type of return value
-    return_ty: typing.Optional[str] = None
+    return_ty: str | None = None
 
     # jboolean constants
     JNI_TRUE = 1

angr/procedures/java_jni/array_operations.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 from . import JNISimProcedure
 from ...engines.soot.expressions import SimSootExpr_NewArray
@@ -30,7 +29,7 @@ class GetArrayLength(JNISimProcedure):
 
 
 class NewArray(JNISimProcedure):
-    element_type: Optional[str] = None
+    element_type: str | None = None
     return_ty = "reference"
 
     def run(self, ptr_env, length_):

angr/procedures/java_jni/method_calls.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 from archinfo.arch_soot import ArchSoot, SootAddressDescriptor, SootArgument, SootMethodDescriptor
 
@@ -38,7 +37,7 @@ class GetMethodID(JNISimProcedure):
 
 
 class CallMethodBase(JNISimProcedure):
-    return_ty: Optional[str] = None
+    return_ty: str | None = None
 
     def _invoke(self, method_id, obj=None, dynamic_dispatch=True, args_in_array=None):
         # get invoke target

angr/procedures/posix/inet_ntoa.py

@@ -1,5 +1,4 @@
 from socket import inet_ntoa as _inet_ntoa
-from typing import List
 
 from claripy import BVS, BVV, Concat
 from claripy.ast import BV
@@ -28,7 +27,7 @@ class inet_ntoa(angr.SimProcedure):
             size=self.INET_INADDRSTRLEN,
         ).rebased_addr
 
-        rv_exprs: List[BV] = []
+        rv_exprs: list[BV] = []
         addr_s_in = addr_in["s_addr"]
 
         if addr_s_in.concrete:

angr/procedures/stubs/format_parser.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, TYPE_CHECKING
+from typing import TYPE_CHECKING
 from string import digits as ascii_digits
 import logging
 import math
@@ -434,7 +434,7 @@ class FormatParser(SimProcedure):
         return FormatParser._MOD_SPEC
 
     @property
-    def _all_spec(self) -> Dict[bytes, "SimType"]:
+    def _all_spec(self) -> dict[bytes, "SimType"]:
         """
         All specifiers and their lengths.
         """
@@ -506,7 +506,7 @@ class FormatParser(SimProcedure):
 
         return None
 
-    def extract_components(self, fmt: List) -> List:
+    def extract_components(self, fmt: list) -> list:
         """
         Extract the actual formats from the format string `fmt`.