angr 9.2.131__py3-none-manylinux2014_aarch64.whl → 9.2.133__py3-none-manylinux2014_aarch64.whl

angr/knowledge_plugins/key_definitions/live_definitions.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, TYPE_CHECKING, overload
+from typing import Any, TYPE_CHECKING, cast, overload
 from collections.abc import Iterable, Generator
 import weakref
 import logging
@@ -14,7 +14,7 @@ import archinfo
 from angr.misc.ux import deprecated
 from angr.errors import SimMemoryMissingError, SimMemoryError
 from angr.storage.memory_mixins import MultiValuedMemory
-from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
+from angr.storage.memory_mixins.paged_memory.pages.multi_values import MVType, MultiValues
 from angr.knowledge_plugins.key_definitions.definition import A
 from angr.engines.light import SpOffset
 from angr.code_location import CodeLocation, ExternalCodeLocation
@@ -52,7 +52,7 @@ class DefinitionAnnotation(Annotation):
     An annotation that attaches a `Definition` to an AST.
     """
 
-    __slots__ = ("definition", "_hash")
+    __slots__ = ("_hash", "definition")
 
     def __init__(self, definition):
         super().__init__()
@@ -91,24 +91,24 @@ class LiveDefinitions:
     _tops = {}
 
     __slots__ = (
-        "project",
+        "__weakref__",
+        "_canonical_size",
         "arch",
-        "track_tmps",
-        "registers",
-        "stack",
         "heap",
+        "heap_uses",
         "memory",
-        "tmps",
-        "others",
+        "memory_uses",
         "other_uses",
+        "others",
+        "project",
         "register_uses",
+        "registers",
+        "stack",
         "stack_uses",
-        "heap_uses",
-        "memory_uses",
-        "uses_by_codeloc",
         "tmp_uses",
-        "_canonical_size",
-        "__weakref__",
+        "tmps",
+        "track_tmps",
+        "uses_by_codeloc",
     )
 
     def __init__(
@@ -230,7 +230,7 @@ class LiveDefinitions:
     def __repr__(self):
         ctnt = "LiveDefs"
         if self.tmps:
-            ctnt += ", %d tmpdefs" % len(self.tmps)
+            ctnt += f", {len(self.tmps)} tmpdefs"
         return f"<{ctnt}>"
 
     def copy(self, discard_tmpdefs=False) -> LiveDefinitions:
@@ -324,7 +324,7 @@ class LiveDefinitions:
                 return True
         return False
 
-    def stack_address(self, offset: int) -> claripy.ast.bv.BV | None:
+    def stack_address(self, offset: int) -> claripy.ast.bv.BV:
         base = claripy.BVS("stack_base", self.arch.bits, explicit_name=True)
         if offset:
             return base + offset
@@ -346,21 +346,21 @@ class LiveDefinitions:
                 return 0
             if addr.op == "__add__":
                 if len(addr.args) == 2:
-                    off0 = LiveDefinitions.get_stack_offset(addr.args[0], had_stack_base=True)
-                    off1 = LiveDefinitions.get_stack_offset(addr.args[1], had_stack_base=True)
+                    off0 = LiveDefinitions.get_stack_offset(cast(claripy.ast.BV, addr.args[0]), had_stack_base=True)
+                    off1 = LiveDefinitions.get_stack_offset(cast(claripy.ast.BV, addr.args[1]), had_stack_base=True)
                     if off0 is not None and off1 is not None:
                         return off0 + off1
                 elif len(addr.args) == 1:
                     return 0
             elif addr.op == "__sub__" and len(addr.args) == 2:
-                off0 = LiveDefinitions.get_stack_offset(addr.args[0], had_stack_base=True)
-                off1 = LiveDefinitions.get_stack_offset(addr.args[1], had_stack_base=True)
+                off0 = LiveDefinitions.get_stack_offset(cast(claripy.ast.BV, addr.args[0]), had_stack_base=True)
+                off1 = LiveDefinitions.get_stack_offset(cast(claripy.ast.BV, addr.args[1]), had_stack_base=True)
                 if off0 is not None and off1 is not None:
                     return off0 - off1
         return None
 
     @staticmethod
-    def annotate_with_def(symvar: claripy.ast.BV, definition: Definition) -> claripy.ast.BV:
+    def annotate_with_def(symvar: MVType, definition: Definition) -> MVType:
         """
 
         :param symvar:
@@ -445,7 +445,7 @@ class LiveDefinitions:
             base_v = self.INITIAL_SP_64BIT
             mask = 0xFFFF_FFFF_FFFF_FFFF
         else:
-            raise ValueError("Unsupported architecture word size %d" % self.arch.bits)
+            raise ValueError(f"Unsupported architecture word size {self.arch.bits}")
         return (base_v + offset) & mask
 
     def merge(self, *others: LiveDefinitions) -> tuple[LiveDefinitions, bool]:
@@ -562,9 +562,12 @@ class LiveDefinitions:
         else:
             definition: Definition = Definition(atom, code_loc, dummy=dummy, tags=tags)
             d = MultiValues()
+            count = 0
             for offset, vs in data.items():
                 for v in vs:
+                    count += 1
                     d.add_value(offset, self.annotate_with_def(v, definition))
+            assert count != 0, "MV may not be empty, use TOP instead"
 
         # set_object() replaces kill (not implemented) and add (add) in one step
         if isinstance(atom, Register):
@@ -659,7 +662,7 @@ class LiveDefinitions:
             self.other_uses.add_use(definition, code_loc, expr)
 
     def get_definitions(
-        self, thing: A | Definition[A] | Iterable[A] | Iterable[Definition[A]] | MultiValues
+        self, thing: Atom | Definition[Atom] | Iterable[Atom] | Iterable[Definition[Atom]] | MultiValues
     ) -> set[Definition[Atom]]:
         if isinstance(thing, MultiValues):
             defs = set()
@@ -973,7 +976,7 @@ class LiveDefinitions:
     @overload
     def deref(
         self,
-        pointer: MultiValues | A | Definition[A] | Iterable[A] | Iterable[Definition[A]],
+        pointer: MultiValues[claripy.ast.BV] | Atom | Definition[Atom] | Iterable[Atom] | Iterable[Definition[Atom]],
         size: int | DerefSize,
         endness: archinfo.Endness = ...,
     ) -> set[MemoryLocation]: ...
@@ -1023,7 +1026,7 @@ class LiveDefinitions:
                 if heap_offset is not None:
                     addr = HeapAddress(heap_offset)
                 elif pointer.op == "BVV":
-                    addr = pointer.args[0]
+                    addr = cast(int, pointer.args[0])
                 else:
                     # cannot resolve
                     return None
@@ -1054,8 +1057,8 @@ class LiveDefinitions:
         if "heap_base" in addr.variables:
             if addr.op == "BVS":
                 return 0
-            if addr.op == "__add__" and len(addr.args) == 2 and addr.args[1].op == "BVV":
-                return addr.args[1].concrete_value
+            if addr.op == "__add__" and len(addr.args) == 2 and cast(claripy.ast.BV, addr.args[1]).op == "BVV":
+                return cast(claripy.ast.BV, addr.args[1]).concrete_value
         return None
 
     def heap_address(self, offset: int | HeapAddress) -> claripy.ast.BV:

angr/knowledge_plugins/labels.py

@@ -101,7 +101,7 @@ class Labels(KnowledgeBasePlugin):
         # use it as the prefix
         i = 1
         while True:
-            new_label = "%s_%d" % (label, i)
+            new_label = f"{label}_{i}"
             if new_label not in self._labels:
                 return new_label
             i += 1

angr/knowledge_plugins/propagations/__init__.py

@@ -5,6 +5,6 @@ from .propagation_manager import PropagationManager
 
 
 __all__ = (
-    "PropagationModel",
     "PropagationManager",
+    "PropagationModel",
 )

angr/knowledge_plugins/propagations/prop_value.py

@@ -17,7 +17,7 @@ class Detail:
                     or the current function.
     """
 
-    __slots__ = ("size", "expr", "def_at")
+    __slots__ = ("def_at", "expr", "size")
 
     def __init__(self, size: int, expr: ailment.Expression | None, def_at: CodeLocation | None):
         self.size = size
@@ -37,8 +37,8 @@ class PropValue:
     """
 
     __slots__ = (
-        "value",
         "offset_and_details",
+        "value",
     )
 
     def __init__(self, value: claripy.ast.Bits, offset_and_details: dict[int, Detail] | None = None):

angr/knowledge_plugins/propagations/propagation_model.py

@@ -15,17 +15,16 @@ class PropagationModel(Serializable):
     """
 
     __slots__ = (
-        "key",
-        "node_iterations",
-        "states",
-        "input_states",
+        "_function",
+        "_initial_state",
         "block_initial_reg_values",
-        "replacements",
         "equivalence",
-        # internals of the function graph visitor
         "graph_visitor",
-        "_initial_state",
-        "_function",
+        "input_states",
+        "key",
+        "node_iterations",
+        "replacements",
+        "states",
     )
 
     def __init__(

angr/knowledge_plugins/propagations/states.py

@@ -1,9 +1,12 @@
 # pylint:disable=too-many-boolean-expressions
 from __future__ import annotations
+from abc import abstractmethod
 from typing import Any, TYPE_CHECKING
 from collections import defaultdict
 import weakref
 
+from typing_extensions import Self
+
 import ailment
 import claripy
 import archinfo
@@ -62,20 +65,20 @@ class PropagatorState:
     """
 
     __slots__ = (
-        "arch",
-        "gpr_size",
+        "__weakref__",
+        "_artificial_reg_offsets",
+        "_equivalence",
         "_expr_used_locs",
+        "_gp",
+        "_max_prop_expr_occurrence",
         "_only_consts",
         "_replacements",
-        "_equivalence",
-        "project",
-        "rda",
         "_store_tops",
-        "_gp",
-        "_max_prop_expr_occurrence",
+        "arch",
+        "gpr_size",
         "model",
-        "_artificial_reg_offsets",
-        "__weakref__",
+        "project",
+        "rda",
     )
 
     _tops = {}
@@ -114,7 +117,7 @@ class PropagatorState:
         self.model = model
         self.rda = rda
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<PropagatorState>"
 
     @classmethod
@@ -155,6 +158,7 @@ class PropagatorState:
         # comparing bytes from two sets of memory objects
         # we don't need to resort to byte-level comparison. object-level is good enough.
 
+        # TODO what if object is bytes?
         if mo_self.object.symbolic or mo_other.object.symbolic:
             if type(mo_self) is SimLabeledMemoryObject and type(mo_other) is SimLabeledMemoryObject:
                 return mo_self.label == mo_other.label and mo_self.object is mo_other.object
@@ -165,7 +169,7 @@ class PropagatorState:
         return None
 
     @staticmethod
-    def top(bits: int) -> claripy.ast.Bits:
+    def top(bits: int) -> claripy.ast.BV:
         """
         Get a TOP value.
 
@@ -233,20 +237,20 @@ class PropagatorState:
                                 or isinstance(repl, claripy.ast.Base)
                             )
                             and replacements_0[loc][var] is not repl
-                            or (
-                                not isinstance(replacements_0[loc][var], claripy.ast.Base)
-                                and not isinstance(repl, claripy.ast.Base)
-                                and replacements_0[loc][var] != repl
-                            )
+                        ) or (
+                            not isinstance(replacements_0[loc][var], claripy.ast.Base)
+                            and not isinstance(repl, claripy.ast.Base)
+                            and replacements_0[loc][var] != repl
                         ):
                             replacements_0[loc][var] = repl
                             merge_occurred = True
         return merge_occurred
 
-    def copy(self) -> PropagatorState:
+    @abstractmethod
+    def copy(self) -> Self:
         raise NotImplementedError
 
-    def merge(self, *others):
+    def merge(self, *others: Self) -> tuple[Self, bool]:
         state = self.copy()
         merge_occurred = False
 
@@ -263,8 +267,8 @@ class PropagatorState:
         self._replacements = defaultdict(dict)
 
     def add_replacement(
-        self, codeloc: CodeLocation, old, new, force_replace: bool = False
-    ) -> bool:  # pylint:disable=unused-argument
+        self, codeloc: CodeLocation, old, new, force_replace: bool = False  # pylint:disable=unused-argument
+    ) -> bool:
         """
         Add a replacement record: Replacing expression `old` with `new` at program location `codeloc`.
         If the self._only_consts flag is set to true, only constant values will be set.
@@ -331,7 +335,7 @@ class RegisterComparisonAnnotation(claripy.Annotation):
     Annotate TOP values that are the result of register values comparing against constant values.
     """
 
-    def __init__(self, offset, size, cmp_op, value):
+    def __init__(self, offset: int, size: int, cmp_op: str, value: int):
         self.offset = offset
         self.size = size
         self.cmp_op = cmp_op
@@ -366,8 +370,8 @@ class PropagatorVEXState(PropagatorState):
     __slots__ = (
         "_registers",
         "_stack_variables",
-        "do_binops",
         "block_initial_reg_values",
+        "do_binops",
     )
 
     def __init__(
@@ -504,7 +508,7 @@ class PropagatorVEXState(PropagatorState):
         # TODO: Handle size
         self._stack_variables.store(offset, value, size=size, endness=endness)
 
-    def load_local_variable(self, offset, size, endness):  # pylint:disable=unused-argument
+    def load_local_variable(self, offset, size, endness) -> claripy.ast.BV:  # pylint:disable=unused-argument
         # TODO: Handle size
         try:
             return self._stack_variables.load(offset, size=size, endness=endness)
@@ -546,9 +550,9 @@ class Equivalence:
     """
 
     __slots__ = (
-        "codeloc",
         "atom0",
         "atom1",
+        "codeloc",
     )
 
     def __init__(self, codeloc, atom0, atom1):
@@ -578,14 +582,14 @@ class PropagatorAILState(PropagatorState):
 
     __slots__ = (
         "_registers",
+        "_sp_adjusted",
         "_stack_variables",
         "_tmps",
-        "temp_expressions",
-        "register_expressions",
-        "last_stack_store",
-        "global_stores",
         "block_initial_reg_values",
-        "_sp_adjusted",
+        "global_stores",
+        "last_stack_store",
+        "register_expressions",
+        "temp_expressions",
     )
 
     def __init__(
@@ -912,10 +916,8 @@ class PropagatorAILState(PropagatorState):
         replaced = False
         # count-based propagation rule only matters when we are performing a full-function copy propagation
         if self._max_prop_expr_occurrence == 0:
-            if (
-                isinstance(old, ailment.Expr.Tmp)
-                or isinstance(old, ailment.Expr.Register)
-                and self.should_replace_reg(old.reg_offset, bp_as_gpr, new)
+            if isinstance(old, ailment.Expr.Tmp) or (
+                isinstance(old, ailment.Expr.Register) and self.should_replace_reg(old.reg_offset, bp_as_gpr, new)
             ):
                 self._replacements[codeloc][old] = (
                     new if stmt_to_remove is None else {"expr": new, "stmt_to_remove": stmt_to_remove}
@@ -958,8 +960,7 @@ class PropagatorAILState(PropagatorState):
                 force_replace
                 or prop_count <= self._max_prop_expr_occurrence
                 or isinstance(new, ailment.Expr.StackBaseOffset)
-                or isinstance(new, ailment.Expr.Convert)
-                and isinstance(new.operand, ailment.Expr.StackBaseOffset)
+                or (isinstance(new, ailment.Expr.Convert) and isinstance(new.operand, ailment.Expr.StackBaseOffset))
                 or (
                     isinstance(old, ailment.Expr.Register)
                     and self.arch.is_artificial_register(old.reg_offset, old.size)
@@ -1015,10 +1016,14 @@ class PropagatorAILState(PropagatorState):
             isinstance(expr, ailment.Expr.BinaryOp)
             and expr.op in {"Add", "Sub"}
             and (
-                isinstance(expr.operands[0], ailment.Expr.Register)
-                and PropagatorAILState.is_global_variable_load(expr.operands[1])
-                or isinstance(expr.operands[1], ailment.Expr.Register)
-                and PropagatorAILState.is_global_variable_load(expr.operands[0])
+                (
+                    isinstance(expr.operands[0], ailment.Expr.Register)
+                    and PropagatorAILState.is_global_variable_load(expr.operands[1])
+                )
+                or (
+                    isinstance(expr.operands[1], ailment.Expr.Register)
+                    and PropagatorAILState.is_global_variable_load(expr.operands[0])
+                )
             )
         )
 

angr/knowledge_plugins/variables/variable_access.py

@@ -26,11 +26,11 @@ class VariableAccess(Serializable):
     """
 
     __slots__ = (
-        "variable",
         "access_type",
+        "atom_hash",
         "location",
         "offset",
-        "atom_hash",
+        "variable",
     )
 
     def __init__(self, variable, access_type, location, offset, atom_hash=None):

angr/knowledge_plugins/variables/variable_manager.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Literal, TYPE_CHECKING
+from typing import Literal, TYPE_CHECKING, overload
 import logging
 from collections import defaultdict
 from itertools import count, chain
@@ -77,14 +77,14 @@ class VariableManagerInternal(Serializable):
 
         self.func_addr = func_addr
 
-        self._variables: set[SimVariable] = OrderedSet()  # all variables that are added to any region
+        self._variables: OrderedSet[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._insn_to_variable: dict[int, set[tuple[SimVariable, int | None]]] = defaultdict(set)
         self._stmt_to_variable: dict[tuple[int, int] | tuple[int, int, int], set[tuple[SimVariable, int]]] = (
             defaultdict(set)
         )
@@ -115,7 +115,7 @@ class VariableManagerInternal(Serializable):
         # optimization
         self._variables_without_writes = set()
 
-        self.stack_offset_to_struct_member_info: dict[SimStackVariable, (int, SimStackVariable, SimStruct)] = {}
+        self.stack_offset_to_struct_member_info: dict[SimStackVariable, tuple[int, SimStackVariable, SimStruct]] = {}
 
         self.ret_val_size = None
 
@@ -291,9 +291,11 @@ class VariableManagerInternal(Serializable):
             variable_access = VariableAccess.parse_from_cmessage(varaccess_pb2, variable_by_ident=variable_by_ident)
             variable = variable_access.variable
             offset = variable_access.offset
+            assert variable is not None
             tpl = (variable, offset)
 
             model._variable_accesses[variable_access.variable].add(variable_access)
+            assert variable_access.location.ins_addr is not None
             model._insn_to_variable[variable_access.location.ins_addr].add(tpl)
             loc = (
                 (variable_access.location.block_addr, variable_access.location.stmt_idx)
@@ -388,7 +390,7 @@ class VariableManagerInternal(Serializable):
         else:
             prefix = "m"
 
-        return "i%s_%d" % (prefix, next(self._variable_counters[sort]))
+        return f"i{prefix}_{next(self._variable_counters[sort])}"
 
     def add_variable(self, sort, start, variable: SimVariable):
         if sort == "stack":
@@ -670,9 +672,16 @@ class VariableManagerInternal(Serializable):
 
         return accesses
 
+    @overload
+    def get_variables(self, sort: Literal["stack"], collapse_same_ident: bool = False) -> list[SimStackVariable]: ...
+    @overload
+    def get_variables(self, sort: Literal["reg"], collapse_same_ident: bool = False) -> list[SimRegisterVariable]: ...
+    @overload
     def get_variables(
-        self, sort: Literal["stack", "reg"] | None = None, collapse_same_ident=False
-    ) -> list[SimStackVariable | SimRegisterVariable]:
+        self, sort: None, collapse_same_ident: bool = False
+    ) -> list[SimRegisterVariable | SimRegisterVariable]: ...
+
+    def get_variables(self, sort=None, collapse_same_ident=False):
         """
         Get a list of variables.
 
@@ -695,9 +704,14 @@ class VariableManagerInternal(Serializable):
 
         return variables
 
-    def get_unified_variables(
-        self, sort: Literal["stack", "reg"] | None = None
-    ) -> list[SimStackVariable | SimRegisterVariable]:
+    @overload
+    def get_unified_variables(self, sort: Literal["stack"]) -> list[SimStackVariable]: ...
+    @overload
+    def get_unified_variables(self, sort: Literal["reg"]) -> list[SimRegisterVariable]: ...
+    @overload
+    def get_unified_variables(self, sort: None) -> list[SimRegisterVariable | SimRegisterVariable]: ...
+
+    def get_unified_variables(self, sort=None):
         """
         Get a list of unified variables.
 

angr/knowledge_plugins/xrefs/xref.py

@@ -10,13 +10,13 @@ class XRef(Serializable):
     """
 
     __slots__ = (
-        "ins_addr",
         "block_addr",
-        "stmt_idx",
+        "dst",
+        "ins_addr",
         "insn_op_idx",
         "insn_op_type",
         "memory_data",
-        "dst",
+        "stmt_idx",
         "type",
     )
 
@@ -58,11 +58,8 @@ class XRef(Serializable):
             dst_str = hex(self.memory_data.addr)
         else:
             dst_str = "unknown"
-        return "<XRef {}: {}->{}>".format(
-            self.type_string,
-            f"{self.ins_addr:#x}" if self.ins_addr is not None else "%#x[%d]" % (self.block_addr, self.stmt_idx),
-            dst_str,
-        )
+        ins_addr_str = f"{self.ins_addr:#x}" if self.ins_addr is not None else f"{self.block_addr:#x}[{self.stmt_idx}]"
+        return f"<XRef {self.type_string}: {ins_addr_str}->{dst_str}>"
 
     def __eq__(self, other):
         return (

angr/misc/__init__.py

@@ -9,11 +9,11 @@ from .picklable_lock import PicklableLock
 
 
 __all__ = (
-    "ux",
-    "autoimport",
+    "HookSet",
     "Loggers",
+    "PicklableLock",
     "PluginHub",
     "PluginPreset",
-    "HookSet",
-    "PicklableLock",
+    "autoimport",
+    "ux",
 )

angr/misc/hookset.py

@@ -85,11 +85,10 @@ class HookedMethod:
         self.pending = []
 
     def __repr__(self):
-        return "<HookedMethod(%s.%s, %d pending)>" % (
-            self.func.__self__.__class__.__name__,
-            self.func.__name__,
-            len(self.pending),
-        )
+        class_name = self.func.__self__.__class__.__name__
+        func_name = self.func.__name__
+        pending_count = len(self.pending)
+        return f"<HookedMethod({class_name}.{func_name}, {pending_count} pending)>"
 
     def __call__(self, *args, **kwargs):
         if self.pending:

angr/misc/loggers.py

@@ -15,10 +15,10 @@ class Loggers:
     """
 
     __slots__ = (
-        "default_level",
         "_loggers",
-        "profiling_enabled",
+        "default_level",
         "handler",
+        "profiling_enabled",
     )
 
     def __init__(self, default_level=logging.WARNING):

angr/misc/telemetry.py

@@ -47,7 +47,7 @@ except ImportError:
 
 from angr import __version__
 
-__all__ = ["get_tracer", "get_current_span", "Status", "StatusCode"]
+__all__ = ["Status", "StatusCode", "get_current_span", "get_tracer"]
 
 
 def get_tracer(name: str) -> Tracer:

angr/procedures/__init__.py

@@ -5,8 +5,8 @@ from .definitions import SIM_LIBRARIES, SIM_TYPE_COLLECTIONS
 
 
 __all__ = (
-    "SIM_PROCEDURES",
     "SIM_LIBRARIES",
+    "SIM_PROCEDURES",
     "SIM_TYPE_COLLECTIONS",
     "SimProcedures",
 )

angr/procedures/cgc/fdwait.py

@@ -23,7 +23,7 @@ class fdwait(angr.SimProcedure):
                     sym_bit = claripy.BVV(1, 1)
                 else:
                     sym_bit = self.state.solver.Unconstrained(
-                        "fdwait_read_%d_%d" % (run_count, fd), 1, key=("syscall", "fdwait", fd, "read_ready")
+                        f"fdwait_read_{run_count}_{fd}", 1, key=("syscall", "fdwait", fd, "read_ready")
                     )
                 fd = claripy.BVV(fd, self.state.arch.bits)
                 sym_newbit = claripy.If(claripy.ULT(fd, nfds), sym_bit, 0)
@@ -40,7 +40,7 @@ class fdwait(angr.SimProcedure):
                     sym_bit = claripy.BVV(1, 1)
                 else:
                     sym_bit = self.state.solver.Unconstrained(
-                        "fdwait_write_%d_%d" % (run_count, fd), 1, key=("syscall", "fdwait", fd, "write_ready")
+                        f"fdwait_write_{run_count}_{fd}", 1, key=("syscall", "fdwait", fd, "write_ready")
                     )
 
                 fd = claripy.BVV(fd, self.state.arch.bits)