angr 9.2.116__py3-none-win_amd64.whl → 9.2.118__py3-none-win_amd64.whl

angr/knowledge_plugins/functions/function_manager.py

@@ -1,4 +1,7 @@
 # pylint:disable=raise-missing-from
+from __future__ import annotations
+
+import contextlib
 from collections.abc import Generator
 import logging
 import collections.abc
@@ -37,16 +40,14 @@ class FunctionDict(SortedDict):
             return super().__getitem__(addr)
         except KeyError as ex:
             if not isinstance(addr, self._key_types):
-                raise TypeError("FunctionDict only supports %s as key type" % self._key_types) from ex
+                raise TypeError(f"FunctionDict only supports {self._key_types} as key type") from ex
 
             if isinstance(addr, SootMethodDescriptor):
                 t = SootFunction(self._backref, addr)
             else:
                 t = Function(self._backref, addr)
-            try:
+            with contextlib.suppress(Exception):
                 self[addr] = t
-            except Exception:  # pylint:disable=broad-except
-                pass
             self._backref._function_added(t)
             return t
 
@@ -56,21 +57,21 @@ class FunctionDict(SortedDict):
     def floor_addr(self, addr):
         try:
             return next(self.irange(maximum=addr, reverse=True))
-        except StopIteration:
-            raise KeyError(addr)
+        except StopIteration as err:
+            raise KeyError(addr) from err
 
     def ceiling_addr(self, addr):
         try:
             return next(self.irange(minimum=addr, reverse=False))
-        except StopIteration:
-            raise KeyError(addr)
+        except StopIteration as err:
+            raise KeyError(addr) from err
 
     def __setstate__(self, state):
         for v, k in state.items():
             self[k] = v
 
     def __getstate__(self):
-        return {v: k for (v, k) in self.items()}
+        return dict(self.items())
 
 
 class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
@@ -104,7 +105,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
             func._function_manager = self
 
     def __getstate__(self):
-        s = {
+        return {
             "_kb": self._kb,
             "function_address_types": self.function_address_types,
             "address_types": self.address_types,
@@ -112,7 +113,6 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
             "callgraph": self.callgraph,
             "block_map": self.block_map,
         }
-        return s
 
     def copy(self):
         fm = FunctionManager(self._kb)
@@ -315,7 +315,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
         elif type(k) is str:
             f = self.function(name=k)
         else:
-            raise ValueError("FunctionManager.__getitem__ does not support keys of type %s" % type(k))
+            raise ValueError(f"FunctionManager.__getitem__ does not support keys of type {type(k)}")
 
         if f is None:
             raise KeyError(k)
@@ -350,7 +350,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
     def get_by_addr(self, addr) -> Function:
         return self._function_map.get(addr)
 
-    def get_by_name(self, name: str) -> Generator[Function, None, None]:
+    def get_by_name(self, name: str) -> Generator[Function]:
         for f in self._function_map.values():
             if f.name == name:
                 yield f
@@ -489,7 +489,7 @@ class FunctionManager(KnowledgeBasePlugin, collections.abc.Mapping):
 
     def rebuild_callgraph(self):
         self.callgraph = networkx.MultiDiGraph()
-        for func_addr in self._function_map.keys():
+        for func_addr in self._function_map:
             self.callgraph.add_node(func_addr)
         for func in self._function_map.values():
             if func.block_addrs_set:

angr/knowledge_plugins/functions/function_parser.py

@@ -1,4 +1,5 @@
 # pylint:disable=no-member,raise-missing-from
+from __future__ import annotations
 import logging
 import pickle
 
@@ -89,7 +90,7 @@ class FunctionParser:
     @staticmethod
     def parse_from_cmsg(cmsg, function_manager=None, project=None, all_func_addrs=None):
         """
-        :param cmsg: The data to instanciate the <Function> from.
+        :param cmsg: The data to instantiate the <Function> from.
 
         :return Function:
         """
@@ -143,27 +144,28 @@ class FunctionParser:
                     project,
                     all_func_addrs=all_func_addrs,
                 )
-            except KeyError:
-                raise KeyError("Address of the edge source %#x is not found." % edge_cmsg.src_ea)
+            except KeyError as err:
+                raise KeyError(f"Address of the edge source {edge_cmsg.src_ea:#x} is not found.") from err
 
             edge_type = func_edge_type_from_pb(edge_cmsg.jumpkind)
             assert edge_type is not None
 
             dst = None
             dst_addr = edge_cmsg.dst_ea
-            if dst_addr not in blocks:
-                if edge_type == "call" or (  # call has to go to either a HookNode or a function
-                    all_func_addrs is not None and dst_addr in all_func_addrs
-                ):  # jumps to another function
-                    if function_manager is not None:
-                        # get a function
-                        dst = FunctionParser._get_func(dst_addr, function_manager)
-                    else:
-                        l.warning(
-                            "About to get or create a function at %#x, but function_manager is not provided. "
-                            "Will create a block instead.",
-                            dst_addr,
-                        )
+            if (
+                dst_addr not in blocks
+                and edge_type == "call"  # call has to go to either a HookNode or a function
+                or (all_func_addrs is not None and dst_addr in all_func_addrs)  # jumps to another function
+            ):
+                if function_manager is not None:
+                    # get a function
+                    dst = FunctionParser._get_func(dst_addr, function_manager)
+                else:
+                    l.warning(
+                        "About to get or create a function at %#x, but function_manager is not provided. "
+                        "Will create a block instead.",
+                        dst_addr,
+                    )
 
             if dst is None:
                 # create a block instead
@@ -176,8 +178,8 @@ class FunctionParser:
                         project,
                         all_func_addrs=all_func_addrs,
                     )
-                except KeyError:
-                    raise KeyError("Address of the edge destination %#x is not found." % edge_cmsg.dst_ea)
+                except KeyError as err:
+                    raise KeyError(f"Address of the edge destination {edge_cmsg.dst_ea:#x} is not found.") from err
 
             data = {k: pickle.loads(v) for k, v in edge_cmsg.data.items()}
             data["outside"] = edge_cmsg.is_outside
@@ -252,38 +254,33 @@ class FunctionParser:
     def _get_block_or_func(addr, blocks, external_addrs, function_manager, project, all_func_addrs=None):
         # should we get a block or a function?
         try:
-            r = blocks[addr]
+            return blocks[addr]
             # it's a block. just return it
-            return r
         except KeyError:
             pass
 
         if addr in external_addrs:
             if project is not None and project.is_hooked(addr):
                 # get a hook node instead
-                r = HookNode(addr, 0, project.hooked_by(addr))
-                return r
+                return HookNode(addr, 0, project.hooked_by(addr))
             if all_func_addrs is not None and addr in all_func_addrs:
                 # get a function (which is yet to be created in the function manager)
-                r = function_manager.function(addr=addr, create=True)
-                return r
+                return function_manager.function(addr=addr, create=True)
+            # create a block
+            # TODO: We are deciding the size by re-lifting the block from project. This is usually fine except for
+            # TODO: the cases where the block does not exist in project (e.g., when the block was dynamically
+            # TODO: created). The correct solution is to store the size and bytes of the block, too.
+            if project is not None:
+                block = project.factory.block(addr)
+                block_size = block.size
+                bytestr = block.bytes
             else:
-                # create a block
-                # TODO: We are deciding the size by re-lifting the block from project. This is usually fine except for
-                # TODO: the cases where the block does not exist in project (e.g., when the block was dynamically
-                # TODO: created). The correct solution is to store the size and bytes of the block, too.
-                if project is not None:
-                    block = project.factory.block(addr)
-                    block_size = block.size
-                    bytestr = block.bytes
-                else:
-                    l.warning(
-                        "The Project instance is not specified. Use a dummy block size of 1 byte for block %#x.", addr
-                    )
-                    block_size = 1
-                    bytestr = b"\x00"
-                r = BlockNode(addr, block_size, bytestr=bytestr)
-                return r
+                l.warning(
+                    "The Project instance is not specified. Use a dummy block size of 1 byte for block %#x.", addr
+                )
+                block_size = 1
+                bytestr = b"\x00"
+            return BlockNode(addr, block_size, bytestr=bytestr)
         raise ValueError(
             "Unsupported case: The block %#x is not in external_addrs and is not in local blocks. "
             "This probably indicates a bug in angrdb generation."
@@ -291,5 +288,4 @@ class FunctionParser:
 
     @staticmethod
     def _get_func(addr, function_manager):
-        func = function_manager.function(addr=addr, create=True)
-        return func
+        return function_manager.function(addr=addr, create=True)

angr/knowledge_plugins/functions/soot_function.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import networkx
 from collections import defaultdict
@@ -115,16 +116,14 @@ class SootFunction(Function):
             node._graph = self.transition_graph
             if node.addr not in self or self._block_sizes[node.addr] == 0:
                 self._block_sizes[node.addr] = node.size
-            if node.addr == self.addr.addr:
-                if self.startpoint is None or not self.startpoint.is_hook:
-                    self.startpoint = node
+            if node.addr == self.addr.addr and (self.startpoint is None or not self.startpoint.is_hook):
+                self.startpoint = node
             if is_local:
                 self._local_blocks[node.addr] = node
                 self._local_block_addrs.add(node.addr)
             # add BlockNodes to the addr_to_block_node cache if not already there
-            if isinstance(node, BlockNode):
-                if node.addr not in self._addr_to_block_node:
-                    self._addr_to_block_node[node.addr] = node
+            if isinstance(node, BlockNode) and node.addr not in self._addr_to_block_node:
+                self._addr_to_block_node[node.addr] = node
 
 
 from ...codenode import BlockNode

angr/knowledge_plugins/indirect_jumps.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .plugin import KnowledgeBasePlugin
 
 

angr/knowledge_plugins/key_definitions/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .rd_model import ReachingDefinitionsModel
 from .key_definition_manager import KeyDefinitionManager
 from .live_definitions import LiveDefinitions, DerefSize

angr/knowledge_plugins/key_definitions/atoms.py

@@ -1,4 +1,4 @@
-from typing import Union
+from __future__ import annotations
 from enum import Enum, auto
 
 import claripy
@@ -39,7 +39,7 @@ class Atom:
         self._hash = None
 
     def __repr__(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @property
     def bits(self) -> int:
@@ -54,21 +54,20 @@ class Atom:
         self.size = v
 
     @staticmethod
-    def from_ail_expr(expr: ailment.Expr.Expression, arch: Arch, full_reg: bool = False) -> "Register":
+    def from_ail_expr(expr: ailment.Expr.Expression, arch: Arch, full_reg: bool = False) -> Register:
         if isinstance(expr, ailment.Expr.Register):
             if full_reg:
                 reg_name = arch.translate_register_name(expr.reg_offset)
                 return Register(arch.registers[reg_name][0], arch.registers[reg_name][1], arch)
-            else:
-                return Register(expr.reg_offset, expr.size, arch)
+            return Register(expr.reg_offset, expr.size, arch)
         raise TypeError(f"Expression type {type(expr)} is not yet supported")
 
     @staticmethod
     def from_argument(
         argument: SimFunctionArgument, arch: Arch, full_reg=False, sp: int | None = None
-    ) -> Union["Register", "MemoryLocation"]:
+    ) -> Register | MemoryLocation:
         """
-        Instanciate an `Atom` from a given argument.
+        Instantiate an `Atom` from a given argument.
 
         :param argument: The argument to create a new atom from.
         :param arch: The argument representing archinfo architecture for argument.
@@ -79,19 +78,17 @@ class Atom:
         if isinstance(argument, SimRegArg):
             if full_reg:
                 return Register(arch.registers[argument.reg_name][0], arch.registers[argument.reg_name][1], arch)
-            else:
-                return Register(arch.registers[argument.reg_name][0] + argument.reg_offset, argument.size, arch)
-        elif isinstance(argument, SimStackArg):
+            return Register(arch.registers[argument.reg_name][0] + argument.reg_offset, argument.size, arch)
+        if isinstance(argument, SimStackArg):
             if sp is None:
                 raise ValueError("You must provide a stack pointer to translate a SimStackArg")
             return MemoryLocation(
                 SpOffset(arch.bits, argument.stack_offset + sp), argument.size, endness=arch.memory_endness
             )
-        else:
-            raise TypeError("Argument type %s is not yet supported." % type(argument))
+        raise TypeError(f"Argument type {type(argument)} is not yet supported.")
 
     @staticmethod
-    def reg(thing: str | RegisterOffset, size: int | None = None, arch: Arch | None = None) -> "Register":
+    def reg(thing: str | RegisterOffset, size: int | None = None, arch: Arch | None = None) -> Register:
         """
         Create a Register atom.
 
@@ -126,7 +123,7 @@ class Atom:
     register = reg
 
     @staticmethod
-    def mem(addr: SpOffset | HeapAddress | int, size: int, endness: str | None = None) -> "MemoryLocation":
+    def mem(addr: SpOffset | HeapAddress | int, size: int, endness: str | None = None) -> MemoryLocation:
         """
         Create a MemoryLocation atom,
 
@@ -141,7 +138,7 @@ class Atom:
     memory = mem
 
     def _identity(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def __hash__(self):
         if self._hash is None:
@@ -164,7 +161,7 @@ class GuardUse(Atom):
         self.target = target
 
     def __repr__(self):
-        return "<Guard %#x>" % self.target
+        return f"<Guard {self.target:#x}>"
 
     def _identity(self):
         return (self.target,)
@@ -242,6 +239,57 @@ class Register(Atom):
         )
 
 
+class VirtualVariable(Atom):
+    """
+    Represents a virtual variable.
+    """
+
+    __slots__ = (
+        "varid",
+        "category",
+        "oident",
+    )
+
+    def __init__(
+        self, varid: int, size: int, category: ailment.Expr.VirtualVariableCategory, oident: str | int | None = None
+    ):
+        super().__init__(size)
+
+        self.varid = varid
+        self.category = category
+        self.oident = oident
+
+    def __repr__(self):
+        return "<VVar %d<%d>>" % (self.varid, self.size)
+
+    def _identity(self):
+        return self.varid, self.size
+
+    @property
+    def was_reg(self) -> bool:
+        return self.category == ailment.Expr.VirtualVariableCategory.REGISTER
+
+    @property
+    def was_stack(self) -> bool:
+        return self.category == ailment.Expr.VirtualVariableCategory.STACK
+
+    @property
+    def was_parameter(self) -> bool:
+        return self.category == ailment.Expr.VirtualVariableCategory.PARAMETER
+
+    @property
+    def reg_offset(self) -> int | None:
+        if self.was_reg:
+            return self.oident
+        return None
+
+    @property
+    def stack_offset(self) -> int | None:
+        if self.was_stack:
+            return self.oident
+        return None
+
+
 class MemoryLocation(Atom):
     """
     Represents a memory slice.
@@ -282,7 +330,7 @@ class MemoryLocation(Atom):
     def symbolic(self) -> bool:
         if isinstance(self.addr, int):
             return False
-        elif isinstance(self.addr, SpOffset):
+        if isinstance(self.addr, SpOffset):
             return type(self.addr.offset) is not int
         return True
 

angr/knowledge_plugins/key_definitions/constants.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+from typing import Literal, Union
 import enum
 
 DEBUG = False
@@ -21,3 +23,7 @@ class ObservationPointType(enum.IntEnum):
 # For backwards compatibility
 OP_BEFORE = ObservationPointType.OP_BEFORE
 OP_AFTER = ObservationPointType.OP_AFTER
+
+ObservationPoint = tuple[
+    Literal["insn", "node", "stmt", "exit"], Union[int, tuple[int, int], tuple[int, int, int]], ObservationPointType
+]

angr/knowledge_plugins/key_definitions/definition.py

@@ -1,4 +1,5 @@
-from typing import Optional, Literal, TypeVar, Generic
+from __future__ import annotations
+from typing import Literal, TypeVar, Generic
 from dataclasses import dataclass
 import logging
 
@@ -11,7 +12,7 @@ from angr.misc.ux import once
 
 from ...engines.light import SpOffset
 from ...code_location import CodeLocation, ExternalCodeLocation
-from .atoms import Atom, MemoryLocation, Register, Tmp, AtomKind, atom_kind_mapping
+from .atoms import Atom, MemoryLocation, Register, Tmp, AtomKind, atom_kind_mapping, VirtualVariable
 from .tag import Tag
 from ...sim_variable import SimVariable
 
@@ -39,7 +40,7 @@ class DefinitionMatchPredicate:
     extern: bool | None = None
 
     @staticmethod
-    def construct(predicate: Optional["DefinitionMatchPredicate"] = None, **kwargs) -> "DefinitionMatchPredicate":
+    def construct(predicate: DefinitionMatchPredicate | None = None, **kwargs) -> DefinitionMatchPredicate:
         if predicate is None:
             predicate = DefinitionMatchPredicate(**kwargs)
             predicate.normalize()
@@ -79,7 +80,7 @@ class DefinitionMatchPredicate:
         elif self.tmp_idx is not None:
             self.kind = AtomKind.TMP
 
-    def matches(self, defn: "Definition") -> bool:
+    def matches(self, defn: Definition) -> bool:
         if self.variable is not None:
             if self.variable_manager is False:
                 pass
@@ -123,16 +124,14 @@ class DefinitionMatchPredicate:
                 else:
                     raise TypeError(self.reg_name)
         elif isinstance(defn.atom, MemoryLocation):
-            if self.stack_offset is not None:
-                if (
-                    not isinstance(defn.atom.addr, SpOffset)
-                    or defn.atom.addr.base != "sp"  # TODO???????
-                    or defn.atom.addr.offset != self.stack_offset
-                ):
-                    return False
-        elif isinstance(defn.atom, Tmp):
-            if self.tmp_idx is not None and self.tmp_idx != defn.atom.tmp_idx:
+            if self.stack_offset is not None and (
+                not isinstance(defn.atom.addr, SpOffset)
+                or defn.atom.addr.base != "sp"  # TODO???????
+                or defn.atom.addr.offset != self.stack_offset
+            ):
                 return False
+        elif isinstance(defn.atom, Tmp) and self.tmp_idx is not None and self.tmp_idx != defn.atom.tmp_idx:
+            return False
 
         return True
 
@@ -174,10 +173,9 @@ class Definition(Generic[A]):
             return "<Definition {{Atom:{}, Codeloc:{}}}{}>".format(
                 self.atom, self.codeloc, "" if not self.dummy else "dummy"
             )
-        else:
-            return "<Definition {{Tags:{}, Atom:{}, Codeloc:{}}}{}>".format(
-                repr(self.tags), self.atom, self.codeloc, "" if not self.dummy else " dummy"
-            )
+        return "<Definition {{Tags:{}, Atom:{}, Codeloc:{}}}{}>".format(
+            repr(self.tags), self.atom, self.codeloc, "" if not self.dummy else " dummy"
+        )
 
     def __str__(self):
         pretty_tags = "\n".join([str(tag) for tag in self.tags])
@@ -192,22 +190,21 @@ class Definition(Generic[A]):
     def offset(self) -> int:
         if isinstance(self.atom, Register):
             return self.atom.reg_offset
-        elif isinstance(self.atom, MemoryLocation):
+        if isinstance(self.atom, MemoryLocation):
             if isinstance(self.atom.addr, SpOffset):
                 return self.atom.addr.offset
-            else:
-                return self.atom.addr
-        else:
-            raise ValueError("Unsupported operation offset on %s." % type(self.atom))
+            return self.atom.addr
+        raise ValueError(f"Unsupported operation offset on {type(self.atom)}.")
 
     @property
     def size(self) -> int:
         if isinstance(self.atom, Register):
             return self.atom.size
-        elif isinstance(self.atom, MemoryLocation):
+        if isinstance(self.atom, MemoryLocation):
             return self.atom.bits // 8
-        else:
-            raise ValueError("Unsupported operation size on %s." % type(self.atom))
+        if isinstance(self.atom, VirtualVariable):
+            return self.atom.size
+        raise ValueError(f"Unsupported operation size on {type(self.atom)}.")
 
     def matches(self, **kwargs) -> bool:
         """

angr/knowledge_plugins/key_definitions/environment.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from .undefined import Undefined, UNDEFINED
@@ -14,7 +15,7 @@ class Environment:
 
     __slots__ = ("_environment",)
 
-    def __init__(self, environment: dict[str | Undefined, set[claripy.ast.Base]] = None):
+    def __init__(self, environment: dict[str | Undefined, set[claripy.ast.Base]] | None = None):
         self._environment: dict[str | Undefined, set[claripy.ast.Base]] = environment or {}
 
     def get(self, names: set[str]) -> tuple[set[claripy.ast.Base], bool]:
@@ -25,11 +26,11 @@ class Environment:
             And a boolean value telling whether all the names were known of the internal representation (i.e. will be
             False if one of the queried variable was not found).
         """
-        has_unknown = not all(map(lambda name: name in self._environment.keys(), names))
+        has_unknown = not all(name in self._environment for name in names)
 
         def _get(name):
             if not isinstance(name, (str, Undefined)):
-                raise TypeError("get(): Expected str, or Undefined, got %s" % type(name).__name__)
+                raise TypeError(f"get(): Expected str, or Undefined, got {type(name).__name__}")
             return self._environment.get(name, {UNDEFINED})
 
         pointers = set()
@@ -44,25 +45,25 @@ class Environment:
         :param pointers: New addresses where the new values of the environment variable are located.
         """
         if not isinstance(name, (str, Undefined)):
-            raise TypeError("set(): Expected str, or Undefined, got %s" % type(name).__name__)
+            raise TypeError(f"set(): Expected str, or Undefined, got {type(name).__name__}")
         self._environment[name] = pointers
 
     def __str__(self):
-        return "Environment: %s" % self._environment
+        return f"Environment: {self._environment}"
 
     def __repr__(self):
-        return "Environment: %s" % self._environment
+        return f"Environment: {self._environment}"
 
     def __eq__(self, other: object) -> bool:
-        assert isinstance(other, Environment), "Cannot compare Environment with %s" % type(other).__name__
+        assert isinstance(other, Environment), f"Cannot compare Environment with {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:
             if not isinstance(other, Environment):
-                raise TypeError("Cannot merge Environment with %s" % type(other).__name__)
+                raise TypeError(f"Cannot merge Environment with {type(other).__name__}")
 
             keys = set(new_env.keys())
             keys |= other._environment.keys()
@@ -77,16 +78,19 @@ class Environment:
                     return v
                 return v | w
 
-            new_env = dict(map(lambda k: (k, _dataset_from_key(k, new_env, other._environment)), keys))
+            new_env = {k: _dataset_from_key(k, new_env, other._environment) for k in keys}
 
         merge_occurred = new_env != self._environment
         return Environment(environment=new_env), merge_occurred
 
-    def compare(self, other: "Environment") -> bool:
+    def compare(self, other: Environment) -> bool:
         for k in set(self._environment.keys()).union(set(other._environment.keys())):
             if k not in self._environment:
                 return False
-            if k in self._environment and k in other._environment:
-                if not self._environment[k].issuperset(other._environment[k]):
-                    return False
+            if (
+                k in self._environment
+                and k in other._environment
+                and not self._environment[k].issuperset(other._environment[k])
+            ):
+                return False
         return True

angr/knowledge_plugins/key_definitions/heap_address.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .undefined import Undefined
 
 
@@ -14,12 +15,12 @@ class HeapAddress:
         return self._value
 
     def __repr__(self):
-        address_as_string = ("%#x" % self._value) if isinstance(self._value, int) else ("%s" % self._value)
-        return "HeapAddress<%s>" % address_as_string
+        address_as_string = (f"{self._value:#x}") if isinstance(self._value, int) else (f"{self._value}")
+        return f"HeapAddress<{address_as_string}>"
 
     def __add__(self, value):
         if not isinstance(value, int):
-            raise TypeError("Can only add int to HeapAddress, got %s" % type(value).__name__)
+            raise TypeError(f"Can only add int to HeapAddress, got {type(value).__name__}")
         return HeapAddress(self.value + value)
 
     def __radd__(self, value):