angr 9.2.117__py3-none-manylinux2014_x86_64.whl → 9.2.119__py3-none-manylinux2014_x86_64.whl

angr/knowledge_plugins/cfg/cfg_model.py

@@ -102,9 +102,7 @@ class CFGModel(Serializable):
     #
 
     def __getstate__(self):
-        state = dict(map(lambda x: (x, self.__getattribute__(x)), self.__slots__))
-
-        return state
+        return {x: self.__getattribute__(x) for x in self.__slots__}
 
     def __setstate__(self, state):
         for attribute, value in state.items():
@@ -161,11 +159,8 @@ class CFGModel(Serializable):
 
     @classmethod
     def parse_from_cmessage(cls, cmsg, cfg_manager=None, loader=None):  # pylint:disable=arguments-differ
-        if cfg_manager is None:
-            # create a new model unassociated from any project
-            model = cls(cmsg.ident)
-        else:
-            model = cfg_manager.new_model(cmsg.ident)
+        # create a new model unassociated from any project
+        model = cls(cmsg.ident) if cfg_manager is None else cfg_manager.new_model(cmsg.ident)
 
         # nodes
         for node_pb2 in cmsg.nodes:
@@ -173,14 +168,15 @@ class CFGModel(Serializable):
             model._nodes[node.block_id] = node
             model._nodes_by_addr[node.addr].append(node)
             model.graph.add_node(node)
-            if len(model._nodes_by_addr[node.block_id]) > 1:
-                if once("cfg_model_parse_from_cmessage many nodes at addr"):
-                    l.warning(
-                        "Importing a CFG with more than one node for a given address is currently unsupported. "
-                        "The resulting graph may be broken."
-                    )
+            if len(model._nodes_by_addr[node.block_id]) > 1 and once(
+                "cfg_model_parse_from_cmessage many nodes at addr"
+            ):
+                l.warning(
+                    "Importing a CFG with more than one node for a given address is currently unsupported. "
+                    "The resulting graph may be broken."
+                )
 
-        model._node_addrs = list(sorted(model._nodes_by_addr.keys()))
+        model._node_addrs = sorted(model._nodes_by_addr.keys())
 
         # edges
         for edge_pb2 in cmsg.edges:
@@ -284,7 +280,7 @@ class CFGModel(Serializable):
         :param addr:            Address of the beginning of the basic block. Set anyaddr to True to support arbitrary
                                 address.
         :param is_syscall:      Whether you want to get the syscall node or any other node. This is due to the fact that
-                                syscall SimProcedures have the same address as the targer it returns to.
+                                syscall SimProcedures have the same address as the target it returns to.
                                 None means get either, True means get a syscall node, False means get something that
                                 isn't a syscall node.
         :param anyaddr:         If anyaddr is True, then addr doesn't have to be the beginning address of a basic
@@ -318,10 +314,7 @@ class CFGModel(Serializable):
                 if actual_addr > addr:
                     break
 
-                if is_cfgemulated:
-                    cond = n.looping_times == 0
-                else:
-                    cond = True
+                cond = n.looping_times == 0 if is_cfgemulated else True
                 if anyaddr and n.size is not None:
                     cond = cond and (addr == actual_addr or actual_addr <= addr < actual_addr + n.size)
                 else:
@@ -336,7 +329,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 = None, anyaddr: bool = False) -> list[CFGNode]:
         """
         Get all CFGNodes whose address is the specified one.
 
@@ -347,11 +340,11 @@ class CFGModel(Serializable):
         results = []
 
         for cfg_node in self.graph.nodes():
-            if cfg_node.addr == addr or (
-                anyaddr and cfg_node.size is not None and cfg_node.addr <= addr < (cfg_node.addr + cfg_node.size)
-            ):
-                if is_syscall is None or is_syscall == cfg_node.is_syscall:
-                    results.append(cfg_node)
+            if (
+                cfg_node.addr == addr
+                or (anyaddr and cfg_node.size is not None and cfg_node.addr <= addr < (cfg_node.addr + cfg_node.size))
+            ) and (is_syscall is None or is_syscall == cfg_node.is_syscall):
+                results.append(cfg_node)
 
         return results
 
@@ -426,9 +419,8 @@ class CFGModel(Serializable):
         :rtype:                             list
         """
 
-        if jumpkind is not None:
-            if excluding_fakeret and jumpkind == "Ijk_FakeRet":
-                return []
+        if jumpkind is not None and excluding_fakeret and jumpkind == "Ijk_FakeRet":
+            return []
 
         if not excluding_fakeret and jumpkind is None:
             # fast path
@@ -592,10 +584,7 @@ class CFGModel(Serializable):
                 # TODO: Handle data in code regions (or executable regions)
                 pass
             else:
-                if i + 1 != len(keys):
-                    next_data_addr = keys[i + 1]
-                else:
-                    next_data_addr = None
+                next_data_addr = keys[i + 1] if i + 1 != len(keys) else None
 
                 # goes until the end of the section/segment
                 # TODO: the logic needs more testing
@@ -608,7 +597,7 @@ class CFGModel(Serializable):
                     last_addr = sec.vaddr + sec.memsize
                 else:
                     # it does not belong to any section. what's the next adjacent section? any memory data does not go
-                    # beyong section boundaries
+                    # beyond section boundaries
                     next_sec = self.project.loader.find_section_next_to(data_addr)
                     if next_sec is not None:
                         next_sec_addr = next_sec.vaddr
@@ -700,10 +689,7 @@ class CFGModel(Serializable):
                 if data_type == MemoryDataSort.PointerArray:
                     # make sure all pointers are identified
                     pointer_size = self.project.arch.bytes
-                    if xrefs is not None:
-                        old_crs = xrefs.get_xrefs_by_dst(data_addr)
-                    else:
-                        old_crs = []
+                    old_crs = xrefs.get_xrefs_by_dst(data_addr) if xrefs is not None else []
 
                     for j in range(0, data_size, pointer_size):
                         ptr = self.project.loader.fast_memory_load_pointer(data_addr + j)
@@ -735,7 +721,8 @@ class CFGModel(Serializable):
                             new_data_found = True
 
             else:
-                memory_data.size = memory_data.max_size
+                if memory_data.max_size is not None:
+                    memory_data.size = memory_data.max_size
 
             if seg_list is not None:
                 seg_list.occupy(data_addr, memory_data.size, memory_data.sort)
@@ -950,10 +937,7 @@ class CFGModel(Serializable):
 
     @staticmethod
     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
-        return False
+        return any(start <= addr < end for start, end in exec_mem_regions)
 
     def remove_node_and_graph_node(self, node: CFGNode) -> None:
         """

angr/knowledge_plugins/cfg/cfg_node.py

@@ -117,10 +117,9 @@ class CFGNode(Serializable):
         else:
             self.is_syscall = bool(self.simprocedure_name and self._cfg_model.project.simos.is_syscall_addr(addr))
 
-        if not instruction_addrs and not self.is_simprocedure:
+        if not instruction_addrs and not self.is_simprocedure and irsb is not None:
             # We have to collect instruction addresses by ourselves
-            if irsb is not None:
-                self.instruction_addrs = irsb.instruction_addresses
+            self.instruction_addrs = irsb.instruction_addresses
 
         self.irsb = None
         self.soot_block = soot_block
@@ -229,31 +228,24 @@ class CFGNode(Serializable):
 
     @classmethod
     def parse_from_cmessage(cls, cmsg, cfg=None):  # pylint:disable=arguments-differ
-        if len(cmsg.block_id) == 0:
-            block_id = None
-        else:
-            block_id = cmsg.block_id[0]
+        block_id = None if len(cmsg.block_id) == 0 else cmsg.block_id[0]
 
-        if not cmsg.instr_addrs:
-            instruction_addrs = None
-        else:
-            instruction_addrs = list(cmsg.instr_addrs)
+        instruction_addrs = None if not cmsg.instr_addrs else list(cmsg.instr_addrs)
 
-        obj = cls(
+        return cls(
             cmsg.ea,
             cmsg.size,
             cfg=cfg,
             block_id=block_id,
             instruction_addrs=instruction_addrs,
         )
-        return obj
 
     #
     # Pickling
     #
 
     def __getstate__(self):
-        s = {
+        return {
             "addr": self.addr,
             "size": self.size,
             "simprocedure_name": self.simprocedure_name,
@@ -267,7 +259,6 @@ class CFGNode(Serializable):
             "is_syscall": self.is_syscall,
             "has_return": self.has_return,
         }
-        return s
 
     def __setstate__(self, state):
         self.__init__(
@@ -291,7 +282,7 @@ class CFGNode(Serializable):
     #
 
     def copy(self):
-        c = CFGNode(
+        return CFGNode(
             self.addr,
             self.size,
             self._cfg_model,
@@ -306,7 +297,6 @@ class CFGNode(Serializable):
             is_syscall=self.is_syscall,
             name=self._name,
         )
-        return c
 
     def merge(self, other):
         """
@@ -363,8 +353,7 @@ class CFGNode(Serializable):
         if self.is_simprocedure or self.is_syscall:
             return None
         project = self._cfg_model.project  # everything in angr is connected with everything...
-        b = project.factory.block(self.addr, size=self.size, opt_level=self._cfg_model._iropt_level)
-        return b
+        return project.factory.block(self.addr, size=self.size, opt_level=self._cfg_model._iropt_level)
 
 
 class CFGENode(CFGNode):

angr/knowledge_plugins/cfg/indirect_jump.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ...serializable import Serializable
 
 
@@ -55,12 +56,9 @@ class IndirectJump(Serializable):
     def __repr__(self):
         status = ""
         if self.jumptable or self.jumptable_entries:
-            if self.type == IndirectJumpType.Vtable:
-                status = "vtable"
-            else:
-                status = "jumptable"
+            status = "vtable" if self.type == IndirectJumpType.Vtable else "jumptable"
             if self.jumptable_addr is not None:
-                status += "@%#08x" % self.jumptable_addr
+                status += f"@{self.jumptable_addr:#08x}"
             if self.jumptable_entries is not None:
                 status += " with %d entries" % len(self.jumptable_entries)
 

angr/knowledge_plugins/cfg/memory_data.py

@@ -1,4 +1,5 @@
 # pylint:disable=no-member
+from __future__ import annotations
 from ...protos import cfg_pb2
 from ...serializable import Serializable
 
@@ -15,6 +16,7 @@ class MemoryDataSort:
     GOTPLTEntry = "GOT PLT Entry"
     ELFHeader = "elf-header"
     FloatingPoint = "fp"  # the size is determined by the MemoryData itself
+    Alignment = "alignment"
 
 
 _SORT_TO_IDX = {
@@ -71,7 +73,7 @@ class MemoryData(Serializable):
 
         self.content: bytes | None = None  # temporary annotation
 
-    def __eq__(self, other: "MemoryData"):
+    def __eq__(self, other: MemoryData):
         return (
             self.addr == other.addr
             and self.size == other.size
@@ -147,10 +149,9 @@ class MemoryData(Serializable):
 
     @classmethod
     def parse_from_cmessage(cls, cmsg, **kwargs):
-        md = cls(
+        return cls(
             cmsg.ea,
             cmsg.size if cmsg.HasField("size") else None,
             _IDX_TO_SORT[cmsg.type],
             reference_size=cmsg.reference_size if cmsg.HasField("reference_size") else None,
         )
-        return md

angr/knowledge_plugins/comments.py

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

angr/knowledge_plugins/custom_strings.py

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

angr/knowledge_plugins/data.py

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

angr/knowledge_plugins/debug_variables.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 import logging
 
@@ -26,27 +27,26 @@ class DebugVariableContainer:
         """
         self.less_visible_vars = []
 
-    def _insertvar(self, var: "DebugVariable"):
+    def _insertvar(self, var: DebugVariable):
         for i, v in enumerate(self.less_visible_vars):
             if var.test_unsupported_overlap(v):
                 if var.cle_variable.declaration_only:
                     # ignore var
                     return
-                elif v.cle_variable.declaration_only:
+                if v.cle_variable.declaration_only:
                     # ignore v
                     self.less_visible_vars[i] = var
                     var.less_visible_vars = v.less_visible_vars
                     return
-                else:
-                    l.warning(
-                        'Unsupported variable with overlapping scopes. Have "%s" with %d-%d and ignore %d-%d.',
-                        v.cle_variable.name,
-                        v.low_pc,
-                        v.high_pc,
-                        var.low_pc,
-                        var.high_pc,
-                    )
-                    return
+                l.warning(
+                    'Unsupported variable with overlapping scopes. Have "%s" with %d-%d and ignore %d-%d.',
+                    v.cle_variable.name,
+                    v.low_pc,
+                    v.high_pc,
+                    var.low_pc,
+                    var.high_pc,
+                )
+                return
             if var.contains(v):
                 self.less_visible_vars[i] = var
                 var.less_visible_vars.append(v)
@@ -102,10 +102,10 @@ class DebugVariable(DebugVariableContainer):
                 return var.from_pc(pc)
         return self.cle_variable
 
-    def contains(self, dvar: "DebugVariable") -> bool:
+    def contains(self, dvar: DebugVariable) -> bool:
         return self.low_pc <= dvar.low_pc and dvar.high_pc <= self.high_pc
 
-    def test_unsupported_overlap(self, dvar: "DebugVariable") -> bool:
+    def test_unsupported_overlap(self, dvar: DebugVariable) -> bool:
         """
         Test for an unsupported overlapping
 
@@ -120,9 +120,7 @@ class DebugVariable(DebugVariableContainer):
             return True
         if l2 < l1 < h2 < h1:
             return True
-        if l1 < l2 < h1 < h2:
-            return True
-        return False
+        return l1 < l2 < h1 < h2
 
 
 class DebugVariableManager(KnowledgeBasePlugin):
@@ -130,7 +128,7 @@ class DebugVariableManager(KnowledgeBasePlugin):
     Structure to manage and access variables with different visibility scopes.
     """
 
-    def __init__(self, kb: "KnowledgeBase"):
+    def __init__(self, kb: KnowledgeBase):
         super().__init__(kb=kb)
         self._dvar_containers = {}
 
@@ -178,7 +176,7 @@ class DebugVariableManager(KnowledgeBasePlugin):
         """
         Add all variables in a list with the same visibility range
 
-        :param vlist:       A list of cle varibles to add
+        :param vlist:       A list of cle variables to add
         :param low_pc:      Start of the visibility scope as program counter address (rebased)
         :param high_pc:     End of the visibility scope as program counter address (rebased)
         """
@@ -192,10 +190,7 @@ class DebugVariableManager(KnowledgeBasePlugin):
         :param elf_object:  Optional, when only one elf object should be considered (e.g. p.loader.main_object)
         :param cu:          Optional, when only one compilation unit should be considered
         """
-        if elf_object:
-            objs = [elf_object]
-        else:
-            objs = self._kb._project.loader.all_elf_objects
+        objs = [elf_object] if elf_object else self._kb._project.loader.all_elf_objects
         for obj in objs:
             if cu:
                 if obj not in obj.compilation_units:

angr/knowledge_plugins/functions/__init__.py

@@ -1,2 +1,3 @@
+from __future__ import annotations
 from .function import Function
 from .function_manager import FunctionManager

angr/knowledge_plugins/functions/function.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import logging
 import networkx
@@ -29,6 +30,7 @@ l = logging.getLogger(name=__name__)
 from ...sim_type import SimTypeFunction, parse_defns
 from ...calling_conventions import SimCC
 from ...project import Project
+import contextlib
 
 
 class Function(Serializable):
@@ -277,10 +279,9 @@ class Function(Serializable):
 
     @property
     def project(self):
-        if self._project is None:
+        if self._project is None and self._function_manager is not None:
             # try to set it from function manager
-            if self._function_manager is not None:
-                self._project: Project | None = self._function_manager._kb._project
+            self._project: Project | None = self._function_manager._kb._project
         return self._project
 
     @property
@@ -300,12 +301,10 @@ class Function(Serializable):
         """
 
         for block_addr, block in self._local_blocks.items():
-            try:
+            with contextlib.suppress(SimEngineError, SimMemoryError):
                 yield self.get_block(
                     block_addr, size=block.size, byte_string=block.bytestr if isinstance(block, BlockNode) else None
                 )
-            except (SimEngineError, SimMemoryError):
-                pass
 
     @property
     def cyclomatic_complexity(self):
@@ -377,9 +376,8 @@ class Function(Serializable):
             b = self._block_cache[addr]
             if size is None or b.size == size:
                 return b
-            else:
-                # size seems to be updated. remove this cached entry from the block cache
-                del self._block_cache[addr]
+            # size seems to be updated. remove this cached entry from the block cache
+            del self._block_cache[addr]
 
         if size is None and addr in self.block_addrs:
             # we know the size
@@ -582,27 +580,24 @@ class Function(Serializable):
     def __contains__(self, val):
         if isinstance(val, int):
             return val in self._block_sizes
-        else:
-            return False
+        return False
 
     def __str__(self):
         s = f"Function {self.name} [{self.addr:#x}]\n"
-        s += "  Syscall: %s\n" % self.is_syscall
+        s += f"  Syscall: {self.is_syscall}\n"
         s += "  SP difference: %d\n" % self.sp_delta
-        s += "  Has return: %s\n" % self.has_return
+        s += f"  Has return: {self.has_return}\n"
         s += "  Returning: %s\n" % ("Unknown" if self.returning is None else self.returning)
-        s += "  Alignment: %s\n" % (self.alignment)
+        s += f"  Alignment: {self.alignment}\n"
         s += f"  Arguments: reg: {self._argument_registers}, stack: {self._argument_stack_variables}\n"
-        s += "  Blocks: [%s]\n" % ", ".join(["%#x" % i for i in self.block_addrs])
-        s += "  Cyclomatic Complexity: %s\n" % self.cyclomatic_complexity
-        s += "  Calling convention: %s" % self.calling_convention
+        s += "  Blocks: [{}]\n".format(", ".join([f"{i:#x}" for i in self.block_addrs]))
+        s += f"  Cyclomatic Complexity: {self.cyclomatic_complexity}\n"
+        s += f"  Calling convention: {self.calling_convention}"
         return s
 
     def __repr__(self):
         if self.is_syscall:
-            return "<Syscall function {} ({})>".format(
-                self.name, hex(self.addr) if isinstance(self.addr, int) else self.addr
-            )
+            return f"<Syscall function {self.name} ({hex(self.addr) if isinstance(self.addr, int) else self.addr})>"
         return f"<Function {self.name} ({hex(self.addr) if isinstance(self.addr, int) else self.addr})>"
 
     def __setstate__(self, state):
@@ -722,9 +717,8 @@ class Function(Serializable):
 
         self.is_default_name = False
         # Try to get a name from existing labels
-        if self._function_manager is not None:
-            if addr in self._function_manager._kb.labels:
-                name = self._function_manager._kb.labels[addr]
+        if self._function_manager is not None and addr in self._function_manager._kb.labels:
+            name = self._function_manager._kb.labels[addr]
 
         # try to get the name from a hook
         if name is None and self.project is not None:
@@ -739,7 +733,7 @@ class Function(Serializable):
         # generate an IDA-style sub_X name
         if name is None:
             self.is_default_name = True
-            name = "sub_%x" % addr
+            name = f"sub_{addr:x}"
 
         return name
 
@@ -781,7 +775,7 @@ class Function(Serializable):
         if hooker:
             if hasattr(hooker, "DYNAMIC_RET") and hooker.DYNAMIC_RET:
                 return True
-            elif hasattr(hooker, "NO_RET"):
+            if hasattr(hooker, "NO_RET"):
                 return not hooker.NO_RET
 
         # Cannot determine
@@ -934,9 +928,8 @@ class Function(Serializable):
             node._graph = self.transition_graph
             if self._block_sizes.get(node.addr, 0) == 0:
                 self._block_sizes[node.addr] = node.size
-            if node.addr == self.addr:
-                if self.startpoint is None or not self.startpoint.is_hook:
-                    self.startpoint = node
+            if node.addr == self.addr and (self.startpoint is None or not self.startpoint.is_hook):
+                self.startpoint = node
             if is_local and node.addr not in self._local_blocks:
                 self._update_local_blocks(node)
             # add BlockNodes to the addr_to_block_node cache if not already there
@@ -1096,11 +1089,13 @@ class Function(Serializable):
         for block in self._local_blocks.values():
             g.add_node(block)
         for src, dst, data in self.transition_graph.edges(data=True):
-            if "type" in data:
-                if data["type"] in ("transition", "exception") and ("outside" not in data or data["outside"] is False):
-                    g.add_edge(src, dst, **data)
-                elif data["type"] == "fake_return" and ("outside" not in data or data["outside"] is False):
-                    g.add_edge(src, dst, **data)
+            if "type" in data and (
+                data["type"] in ("transition", "exception")
+                and ("outside" not in data or data["outside"] is False)
+                or data["type"] == "fake_return"
+                and ("outside" not in data or data["outside"] is False)
+            ):
+                g.add_edge(src, dst, **data)
 
         self._local_transition_graph = g
 
@@ -1222,16 +1217,15 @@ class Function(Serializable):
 
             in_edges = subgraph.in_edges(n)
             # out_edges = subgraph.out_edges(n)
-            if len(in_edges) > 1:
-                # the first instruction address should be included
-                if n.addr not in insns:
-                    insns = [n.addr] + insns
+            # the first instruction address should be included
+            if len(in_edges) > 1 and n.addr not in insns:
+                insns = [n.addr, *insns]
 
             for src, _ in in_edges:
                 last_instr = block_addr_to_insns[src.addr][-1]
                 g.add_edge(last_instr, insns[0])
 
-            for i in range(0, len(insns) - 1):
+            for i in range(len(insns) - 1):
                 g.add_edge(insns[i], insns[i + 1])
 
         return g
@@ -1271,9 +1265,12 @@ class Function(Serializable):
             if b.addr <= addr < b.addr + b.size:
                 # found it
                 for i, instr_addr in enumerate(b.instruction_addrs):
-                    if i < len(b.instruction_addrs) - 1 and instr_addr <= addr < b.instruction_addrs[i + 1]:
-                        return instr_addr
-                    elif i == len(b.instruction_addrs) - 1 and instr_addr <= addr:
+                    if (
+                        i < len(b.instruction_addrs) - 1
+                        and instr_addr <= addr < b.instruction_addrs[i + 1]
+                        or i == len(b.instruction_addrs) - 1
+                        and instr_addr <= addr
+                    ):
                         return instr_addr
                 # Not covered by any instruction... why?
                 return None
@@ -1283,7 +1280,7 @@ class Function(Serializable):
         """
         Returns a representation of the list of basic blocks in this function.
         """
-        return "[%s]" % (", ".join(("%#08x" % n.addr) for n in self.transition_graph.nodes()))
+        return "[{}]".format(", ".join((f"{n.addr:#08x}") for n in self.transition_graph.nodes()))
 
     def dbg_draw(self, filename):
         """
@@ -1294,8 +1291,8 @@ class Function(Serializable):
 
         tmp_graph = networkx.classes.digraph.DiGraph()
         for from_block, to_block in self.transition_graph.edges():
-            node_a = "%#08x" % from_block.addr
-            node_b = "%#08x" % to_block.addr
+            node_a = f"{from_block.addr:#08x}"
+            node_b = f"{to_block.addr:#08x}"
             if node_b in self._ret_sites:
                 node_b += "[Ret]"
             if node_a in self._call_sites:
@@ -1322,10 +1319,9 @@ class Function(Serializable):
     def arguments(self):
         if self.calling_convention is None:
             return self._argument_registers + self._argument_stack_variables
-        else:
-            if self.prototype is None:
-                return []
-            return self.calling_convention.arg_locs(self.prototype)
+        if self.prototype is None:
+            return []
+        return self.calling_convention.arg_locs(self.prototype)
 
     @property
     def has_return(self):
@@ -1461,7 +1457,7 @@ class Function(Serializable):
 
         self.normalized = True
 
-    def find_declaration(self, ignore_binary_name: bool = False, binary_name_hint: str = None) -> bool:
+    def find_declaration(self, ignore_binary_name: bool = False, binary_name_hint: str | None = None) -> bool:
         """
         Find the most likely function declaration from the embedded collection of prototypes, set it to self.prototype,
         and update self.calling_convention with the declaration.
@@ -1571,8 +1567,8 @@ class Function(Serializable):
         # FIXME
         if isinstance(addr, tuple):
             return addr[0]
-        else:  # int, long
-            return addr
+        # int, long
+        return addr
 
     @property
     def demangled_name(self):
@@ -1618,7 +1614,7 @@ class Function(Serializable):
             definition += ";"
         func_def = parse_defns(definition, arch=self.project.arch)
         if len(func_def.keys()) > 1:
-            raise Exception("Too many definitions: %s " % list(func_def.keys()))
+            raise Exception(f"Too many definitions: {list(func_def.keys())} ")
 
         name: str
         ty: SimTypeFunction
@@ -1641,7 +1637,7 @@ class Function(Serializable):
         else:
             raise TypeError("calling_convention has to be one of: [SimCC, type(SimCC), None]")
 
-    def functions_reachable(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.
         """