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

angr/analyses/disassembly.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 from collections import defaultdict
 from typing import Union, Any
@@ -15,6 +16,7 @@ from ..utils.formatting import ansi_color_enabled, ansi_color, add_edge_to_buffe
 from ..block import DisassemblerInsn, CapstoneInsn, SootBlockNode
 from ..codenode import BlockNode
 from .disassembly_utils import decode_instruction
+import contextlib
 
 try:
     from ..engines import pcode
@@ -40,8 +42,7 @@ class DisassemblyPiece:
         x = self._render(formatting)
         if len(x) == 1:
             return [self.highlight(x[0], formatting)]
-        else:
-            return x
+        return x
 
     def _render(self, formatting):
         raise NotImplementedError
@@ -272,11 +273,8 @@ class Instruction(DisassemblyPiece):
             self.operands.append(cur_operand)
 
         for i, opr in enumerate(self.operands):
-            if i < len(self.insn.operands):
-                op_type = self.insn.operands[i].type
-            else:
-                # set extra dummy operand type to default 0
-                op_type = 0
+            # set extra dummy operand type to default 0
+            op_type = self.insn.operands[i].type if i < len(self.insn.operands) else 0
             self.operands[i] = Operand.build(op_type, i, opr, self)
 
         if len(self.operands) == 0 and len(self.insn.operands) != 0:
@@ -496,22 +494,21 @@ class SootStatement(DisassemblyPiece):
         return self.addr.stmt_idx
 
     def _parse(self):
-        func = "_parse_%s" % self.raw_stmt.__class__.__name__
+        func = f"_parse_{self.raw_stmt.__class__.__name__}"
 
         if hasattr(self, func):
             getattr(self, func)()
         else:
             # print func
-            self.components += ["NotImplemented: %s" % func]
+            self.components += [f"NotImplemented: {func}"]
 
     def _expr(self, expr):
-        func = "_handle_%s" % expr.__class__.__name__
+        func = f"_handle_{expr.__class__.__name__}"
 
         if hasattr(self, func):
             return getattr(self, func)(expr)
-        else:
-            # print func
-            return SootExpression(str(expr))
+        # print func
+        return SootExpression(str(expr))
 
     def _render(self, formatting=None):
         return [
@@ -639,9 +636,9 @@ class Operand(DisassemblyPiece):
             70: Operand,  # ARM64 BARRIER
         }
 
-        cls = MAPPING.get(operand_type, None)
+        cls = MAPPING.get(operand_type)
         if cls is None:
-            raise ValueError("Unknown capstone operand type %s." % operand_type)
+            raise ValueError(f"Unknown capstone operand type {operand_type}.")
 
         operand = cls(op_num, children, parentinsn)
 
@@ -652,7 +649,7 @@ class Operand(DisassemblyPiece):
                 # Indirect addressing in x86_64
                 # 400520  push [rip+0x200782] ==>  400520  push [0x600ca8]
                 absolute_addr = parentinsn.addr + parentinsn.size + op1.val
-                return MemoryOperand(1, operand.prefix + ["[", Value(absolute_addr, False), "]"], parentinsn)
+                return MemoryOperand(1, [*operand.prefix, "[", Value(absolute_addr, False), "]"], parentinsn)
 
         return operand
 
@@ -669,15 +666,12 @@ class RegisterOperand(Operand):
     def _render(self, formatting):
         custom_value_str = None
         if formatting is not None:
-            try:
+            with contextlib.suppress(KeyError):
                 custom_value_str = formatting["custom_values_str"][self.ident]
-            except KeyError:
-                pass
 
         if custom_value_str:
             return [custom_value_str]
-        else:
-            return super()._render(formatting)
+        return super()._render(formatting)
 
 
 class MemoryOperand(Operand):
@@ -689,7 +683,7 @@ class MemoryOperand(Operand):
         # or
         # [ '[', Register, ']' ]
         # or
-        # [ Value, '(', Regsiter, ')' ]
+        # [ Value, '(', Register, ')' ]
 
         # it will be converted into more meaningful and Pythonic properties
 
@@ -715,7 +709,7 @@ class MemoryOperand(Operand):
             elif "(" in self.children:
                 self._parse_memop_paren()
             else:
-                raise ValueError()
+                raise ValueError
 
         except ValueError:
             l.error("Failed to parse operand children %s. Please report to Fish.", self.children)
@@ -753,7 +747,7 @@ class MemoryOperand(Operand):
                 self.suffix_str = "!"
                 close_square_pos -= 1
             else:
-                raise ValueError()
+                raise ValueError
 
         self.values = self.children[square_bracket_pos + 1 : close_square_pos]
 
@@ -789,43 +783,54 @@ class MemoryOperand(Operand):
         if self.prefix is None:
             # we failed in parsing. use the default rendering
             return super()._render(formatting)
-        else:
-            values_style = self.values_style
-            show_prefix = True
-            custom_values_str = None
+        values_style = self.values_style
+        show_prefix = True
+        custom_values_str = None
 
-            if formatting is not None:
-                try:
-                    values_style = formatting["values_style"][self.ident]
-                except KeyError:
-                    pass
+        if formatting is not None:
+            with contextlib.suppress(KeyError):
+                values_style = formatting["values_style"][self.ident]
 
-                try:
-                    show_prefix_str = formatting["show_prefix"][self.ident]
-                    if show_prefix_str in ("false", "False"):
-                        show_prefix = False
-                except KeyError:
-                    pass
+            try:
+                show_prefix_str = formatting["show_prefix"][self.ident]
+                if show_prefix_str in ("false", "False"):
+                    show_prefix = False
+            except KeyError:
+                pass
 
-                try:
-                    custom_values_str = formatting["custom_values_str"][self.ident]
-                except KeyError:
-                    pass
+            with contextlib.suppress(KeyError):
+                custom_values_str = formatting["custom_values_str"][self.ident]
 
-            prefix_str = " ".join(self.prefix) + " " if show_prefix and self.prefix else ""
-            if custom_values_str is not None:
-                value_str = custom_values_str
-            else:
-                value_str = "".join(
-                    x.render(formatting)[0] if not isinstance(x, (bytes, str)) else x for x in self.values
-                )
+        prefix_str = " ".join(self.prefix) + " " if show_prefix and self.prefix else ""
+        if custom_values_str is not None:
+            value_str = custom_values_str
+        else:
+            value_str = "".join(x.render(formatting)[0] if not isinstance(x, (bytes, str)) else x for x in self.values)
+
+        if values_style == "curly":
+            left_paren, right_paren = "{", "}"
+        elif values_style == "paren":
+            left_paren, right_paren = "(", ")"
+        else:  # square
+            left_paren, right_paren = "[", "]"
+
+        if self.offset:
+            offset_str = "".join(x.render(formatting)[0] if not isinstance(x, (bytes, str)) else x for x in self.offset)
+
+            # combine values and offsets according to self.offset_location
+            if self.offset_location == "prefix":
+                value_str = f"{offset_str}{left_paren}{value_str}{right_paren}"
+            elif self.offset_location == "before_value":
+                value_str = f"{left_paren}{offset_str}{value_str}{right_paren}"
+            else:  # after_value
+                value_str = f"{left_paren}{value_str}{offset_str}{right_paren}"
+        else:
+            value_str = left_paren + value_str + right_paren
+
+        segment_selector_str = "" if self.segment_selector is None else self.segment_selector
 
-            if values_style == "curly":
-                left_paren, right_paren = "{", "}"
-            elif values_style == "paren":
-                left_paren, right_paren = "(", ")"
-            else:  # square
-                left_paren, right_paren = "[", "]"
+        if segment_selector_str and prefix_str:
+            prefix_str += " "
 
             if self.offset:
                 offset_str = "".join(
@@ -847,7 +852,7 @@ class MemoryOperand(Operand):
             if segment_selector_str and prefix_str:
                 prefix_str += " "
 
-            return [f"{prefix_str}{segment_selector_str}{value_str}{self.suffix_str}"]
+        return [f"{prefix_str}{segment_selector_str}{value_str}{self.suffix_str}"]
 
 
 class OperandPiece(DisassemblyPiece):  # pylint: disable=abstract-method
@@ -889,15 +894,13 @@ class Value(OperandPiece):
                 style = formatting["int_styles"][self.ident]
                 if style[0] == "hex":
                     if self.render_with_sign:
-                        return ["%#+x" % self.val]
-                    else:
-                        return ["%#x" % self.val]
-                elif style[0] == "dec":
+                        return [f"{self.val:+#x}"]
+                    return [f"{self.val:#x}"]
+                if style[0] == "dec":
                     if self.render_with_sign:
                         return ["%+d" % self.val]
-                    else:
-                        return [str(self.val)]
-                elif style[0] == "label":
+                    return [str(self.val)]
+                if style[0] == "label":
                     labeloffset = style[1]
                     if labeloffset == 0:
                         lbl = self.project.kb.labels[self.val]
@@ -920,20 +923,17 @@ class Value(OperandPiece):
 
         if self.val in self.project.kb.labels:
             lbl = self.project.kb.labels[self.val]
-            if func is not None:
+            if func is not None and lbl == func.name and func.name != func.demangled_name:
                 # see if lbl == func.name and func.demangled_name != func.name. if so, we prioritize the
                 # demangled name
-                if lbl == func.name and func.name != func.demangled_name:
-                    normalized_name = get_cpp_function_name(func.demangled_name, specialized=False, qualified=True)
-                    return [normalized_name]
+                normalized_name = get_cpp_function_name(func.demangled_name, specialized=False, qualified=True)
+                return [normalized_name]
             return [("+" if self.render_with_sign else "") + lbl]
-        elif func is not None:
+        if func is not None:
             return [func.demangled_name]
-        else:
-            if self.render_with_sign:
-                return ["%#+x" % self.val]
-            else:
-                return ["%#x" % self.val]
+        if self.render_with_sign:
+            return [f"{self.val:+#x}"]
+        return [f"{self.val:#x}"]
 
 
 class Comment(DisassemblyPiece):
@@ -1083,13 +1083,11 @@ class Disassembly(Analysis):
         if irsb.statements is not None:
             if pcode is not None and isinstance(self.project.factory.default_engine, pcode.HeavyPcodeMixin):
                 addr = None
-                stmt_idx = 0
-                for op in irsb._ops:
+                for stmt_idx, op in enumerate(irsb._ops):
                     if op.opcode == pypcode.OpCode.IMARK:
                         addr = op.inputs[0].offset
                     else:
                         addr_to_ops_map[addr].append(IROp(addr, stmt_idx, op, irsb))
-                    stmt_idx += 1
             else:
                 for seq, stmt in enumerate(irsb.statements):
                     if isinstance(stmt, pyvex.stmt.IMark):

angr/analyses/disassembly_utils.py

@@ -1,6 +1,8 @@
-import capstone as cs
+from __future__ import annotations
+
 import logging
 
+import capstone as cs
 from archinfo.arch_arm import is_arm_arch
 
 from ..misc.ux import once
@@ -31,16 +33,11 @@ INS_GROUP_INFO["ARMHF"] = INS_GROUP_INFO["ARM"]
 INS_GROUP_INFO["ARMCortexM"] = INS_GROUP_INFO["ARM"]
 
 
-try:
-    INS_GROUP_INFO["MIPS32"] = {
-        cs.mips.MIPS_GRP_CALL: "call",
-        cs.mips.MIPS_GRP_JUMP: "branch",
-        cs.mips.MIPS_GRP_RET: "return",
-    }
-except AttributeError:
-    # The installed capstone is too old - it does not support cs.mips.MIPS_GRP_*
-    pass
-
+INS_GROUP_INFO["MIPS32"] = {
+    cs.mips.MIPS_GRP_CALL: "call",
+    cs.mips.MIPS_GRP_JUMP: "branch",
+    cs.mips.MIPS_GRP_RET: "return",
+}
 
 INS_INFO = {
     "MIPS32": {
@@ -59,7 +56,7 @@ def decode_instruction(arch, instr):
 
     insn_info = None
 
-    info = INS_GROUP_INFO.get(arch_name, None)
+    info = INS_GROUP_INFO.get(arch_name)
     if info is not None:
         for group in instr.insn.insn.groups:
             insn_info = info.get(group, None)
@@ -67,7 +64,7 @@ def decode_instruction(arch, instr):
                 break
 
     if insn_info is None:
-        info = INS_INFO.get(arch_name, None)
+        info = INS_INFO.get(arch_name)
         if info is not None:
             insn_info = info.get(instr.insn.insn.id, None)
 

angr/analyses/dominance_frontier.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ..utils.graph import compute_dominance_frontier, Dominators
 from .analysis import Analysis
 from . import register_analysis
@@ -9,8 +10,10 @@ class DominanceFrontier(Analysis):
     querying the frontier information.
     """
 
-    def __init__(self, func, exception_edges=False):
+    def __init__(self, func, func_graph=None, entry=None, exception_edges=False):
         self.function = func
+        self.func_graph = func_graph
+        self.entry = entry
         self._exception_edges = exception_edges
 
         self.frontiers = None
@@ -18,17 +21,32 @@ class DominanceFrontier(Analysis):
         self._compute()
 
     def _get_graph(self):
-        g = self.function.graph_ex(exception_edges=self._exception_edges)
-        return g
+        if self.func_graph is not None:
+            return self.func_graph
+        return self.function.graph_ex(exception_edges=self._exception_edges)
 
     def _compute(self):
         g = self._get_graph()
 
+        if self.entry is not None:
+            startpoint = self.entry
+        else:
+            if self.function.startpoint is None:
+                # The function might be empty or is corrupted (maybe the object is created manually)
+                raise TypeError(f"Startpoint of function {self.function!r} is None. Is this function empty?")
+
+            if self.function.startpoint not in g:
+                # find the actual start point
+                startpoint = next(iter(nn for nn in g if nn.addr == self.function.startpoint.addr), None)
+                if startpoint is None:
+                    raise ValueError(
+                        f"Cannot find the startpoint of function {self.function!r} in the given function graph."
+                    )
+            else:
+                startpoint = self.function.startpoint
+
         # Compute the dominator tree
-        if self.function.startpoint is None:
-            # The function might be empty or is corrupted (maybe the object is created manually)
-            raise TypeError("Startpoint of function %s is None. Is this function empty?" % repr(self.function))
-        doms = Dominators(g, self.function.startpoint)
+        doms = Dominators(g, startpoint)
 
         # Compute the dominance frontier
         dom_frontiers = compute_dominance_frontier(g, doms.dom)

angr/analyses/find_objects_static.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 from collections import defaultdict
 
@@ -60,8 +61,8 @@ class NewFunctionHandler(FunctionHandler):
 
     def handle_local_function(
         self,
-        state: "ReachingDefinitionsState",
-        data: "FunctionCallData",
+        state: ReachingDefinitionsState,
+        data: FunctionCallData,
     ):
         function_address = data.address
         if function_address == self.new_func_addr:

angr/analyses/flirt.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 from functools import partial
 from collections import defaultdict
@@ -10,6 +11,7 @@ from ..analyses import AnalysesHub
 from ..errors import AngrRuntimeError
 from ..flirt import FlirtSignature, STRING_TO_LIBRARIES, LIBRARY_TO_SIGNATURES, FLIRT_SIGNATURES_BY_ARCH
 from .analysis import Analysis
+import contextlib
 
 if TYPE_CHECKING:
     from angr.knowledge_plugins.functions import Function
@@ -84,7 +86,7 @@ class FlirtAnalysis(Analysis):
                     max_suggestions = len(suggestion)
 
             if max_suggestion_sig_path is not None:
-                sig_ = path_to_sig.get(max_suggestion_sig_path, None)
+                sig_ = path_to_sig.get(max_suggestion_sig_path)
                 _l.info("Applying FLIRT signature %s for library %s.", sig_, lib)
                 self._apply_changes(
                     sig_.sig_name if not self._temporary_sig else None, sig_to_suggestions[max_suggestion_sig_path]
@@ -117,7 +119,7 @@ class FlirtAnalysis(Analysis):
         with open(sig.sig_path, "rb") as sigfile:
             flirt = nampa.parse_flirt_file(sigfile)
             for func in self.project.kb.functions.values():
-                func: "Function"
+                func: Function
                 if func.is_simprocedure or func.is_plt:
                     continue
                 if not func.is_default_name:
@@ -140,7 +142,7 @@ class FlirtAnalysis(Analysis):
                 _callback = partial(self._on_func_matched, func)
                 nampa.match_function(flirt, func_bytes, start, _callback)
 
-    def _on_func_matched(self, func: "Function", base_addr: int, flirt_func: "nampa.FlirtFunction"):
+    def _on_func_matched(self, func: Function, base_addr: int, flirt_func: nampa.FlirtFunction):
         func_addr = base_addr + flirt_func.offset
         _l.debug(
             "_on_func_matched() is called with func_addr %#x with a suggested name %s.", func_addr, flirt_func.name
@@ -153,10 +155,8 @@ class FlirtAnalysis(Analysis):
             except KeyError:
                 # the function is not found. Try the THUMB version
                 if self._is_arm:
-                    try:
+                    with contextlib.suppress(KeyError):
                         func = self.kb.functions.get_by_addr(func_addr + 1)
-                    except KeyError:
-                        pass
 
             if func is None:
                 _l.debug(
@@ -168,10 +168,7 @@ class FlirtAnalysis(Analysis):
             # set the function name
             # TODO: Make sure function names do not conflict with existing ones
             _l.debug("Identified %s @ %#x (%#x-%#x)", flirt_func.name, func_addr, base_addr, flirt_func.offset)
-            if flirt_func.name != "?":
-                func_name = flirt_func.name
-            else:
-                func_name = f"unknown_function_{func.addr:x}"
+            func_name = flirt_func.name if flirt_func.name != "?" else f"unknown_function_{func.addr:x}"
             self._suggestions[func.addr] = func_name
 
     def _apply_changes(self, library_name: str | None, suggestion: dict[int, str]) -> None:

angr/analyses/forward_analysis/__init__.py

@@ -1,2 +1,3 @@
+from __future__ import annotations
 from .forward_analysis import ForwardAnalysis
 from .visitors import CallGraphVisitor, FunctionGraphVisitor, LoopVisitor, SingleNodeGraphVisitor

angr/analyses/forward_analysis/forward_analysis.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
 from collections import defaultdict
-from typing import Any, Optional, Generic, TypeVar, TYPE_CHECKING
+from typing import Any, Generic, TypeVar, TYPE_CHECKING
 from collections.abc import Callable
 
 import networkx
@@ -42,8 +43,8 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
         order_jobs=False,
         allow_merging=False,
         allow_widening=False,
-        status_callback: Callable[[type["ForwardAnalysis"]], Any] | None = None,
-        graph_visitor: "Optional[GraphVisitor[NodeType]]" = None,
+        status_callback: Callable[[type[ForwardAnalysis]], Any] | None = None,
+        graph_visitor: GraphVisitor[NodeType] | None = None,
     ):
         """
         Constructor
@@ -363,8 +364,10 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
         all_input_states = self._input_states.get(self._node_key(node))
         if len(all_input_states) == 1:
             return all_input_states[0]
-        merged_state, _ = self._merge_states(node, *all_input_states)
-        return merged_state
+        if self._allow_merging:
+            merged_state, _ = self._merge_states(node, *all_input_states)
+            return merged_state
+        return all_input_states[0]
 
     def _analysis_core_baremetal(self) -> None:
         if not self._job_info_queue:
@@ -506,7 +509,7 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
         if pos < len(self._job_info_queue):
             return self._job_info_queue[pos].job
 
-        raise IndexError()
+        raise IndexError
 
     def _remove_job(self, predicate: Callable) -> None:
         """

angr/analyses/forward_analysis/job_info.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Generic, TypeVar
 
 JobType = TypeVar("JobType")
@@ -16,14 +17,13 @@ class JobInfo(Generic[JobType, JobKey]):
         self.narrowing_count = 0  # not used
 
     def __hash__(self):
-        return hash((self.key,) + tuple(self.jobs))
+        return hash((self.key, *tuple(self.jobs)))
 
     def __eq__(self, o):
         return type(self) == type(o) and self.key == o.key and self.job == o.job
 
     def __repr__(self):
-        s = "<JobInfo %s>" % (str(self.key))
-        return s
+        return f"<JobInfo {self.key!s}>"
 
     @property
     def job(self) -> JobType:

angr/analyses/forward_analysis/visitors/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .call_graph import CallGraphVisitor
 from .function_graph import FunctionGraphVisitor
 from .loop import LoopVisitor

angr/analyses/forward_analysis/visitors/call_graph.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from angr.utils.graph import GraphUtils
 from .graph import GraphVisitor
 

angr/analyses/forward_analysis/visitors/function_graph.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 import networkx
@@ -40,7 +41,7 @@ class FunctionGraphVisitor(GraphVisitor):
         if len(new_sorted_nodes) < len(self._sorted_nodes):
             must_restart = True
         else:
-            must_restart = not new_sorted_nodes[: len(self._sorted_nodes)] == self._sorted_nodes
+            must_restart = new_sorted_nodes[: len(self._sorted_nodes)] != self._sorted_nodes
 
         if must_restart:
             _l.debug("Cannot resume for function %r with the new graph.", self.function)
@@ -79,7 +80,7 @@ class FunctionGraphVisitor(GraphVisitor):
             start_nodes = [node for node in self.graph if self.graph.in_degree(node) == 0]
 
         if not start_nodes:
-            raise NotImplementedError()
+            raise NotImplementedError
 
         start_node = start_nodes[0]
         return list(dfs_back_edges(self.graph, start_node))

angr/analyses/forward_analysis/visitors/graph.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TypeVar, Generic
 from collections.abc import Collection, Iterator
 from collections import defaultdict
@@ -49,7 +50,7 @@ class GraphVisitor(Generic[NodeType]):
         :rtype:      list
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def predecessors(self, node: NodeType) -> list[NodeType]:
         """
@@ -59,7 +60,7 @@ class GraphVisitor(Generic[NodeType]):
         :return:     A list of predecessors.
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def sort_nodes(self, nodes: Collection[NodeType] | None = None) -> list[NodeType]:
         """
@@ -69,16 +70,16 @@ class GraphVisitor(Generic[NodeType]):
         :return:               A list of sorted nodes.
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def back_edges(self) -> list[tuple[NodeType, NodeType]]:
         """
-        Get a list of back edges. This function is optional. If not overriden, the traverser cannot achieve an optimal
+        Get a list of back edges. This function is optional. If not overridden, the traverser cannot achieve an optimal
         graph traversal order.
 
         :return:                A list of back edges (source -> destination).
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     #
     # Public methods
@@ -201,10 +202,9 @@ class GraphVisitor(Generic[NodeType]):
 
         successors = self.successors(node)  # , skip_reached_fixedpoint=True)
 
-        if include_self:
-            if node not in self._nodes_set:
-                binary_insert(self._worklist, node, lambda elem: self._node_to_index[elem])
-                self._nodes_set.add(node)
+        if include_self and node not in self._nodes_set:
+            binary_insert(self._worklist, node, lambda elem: self._node_to_index[elem])
+            self._nodes_set.add(node)
 
         for succ in successors:
             if succ not in self._nodes_set:

angr/analyses/forward_analysis/visitors/loop.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from angr.utils.graph import GraphUtils
 from .graph import GraphVisitor
 

angr/analyses/forward_analysis/visitors/single_node_graph.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .graph import GraphVisitor
 
 
@@ -34,5 +35,4 @@ class SingleNodeGraphVisitor(GraphVisitor):
     def sort_nodes(self, nodes=None):
         if nodes:
             return nodes
-        else:
-            return [self.node]
+        return [self.node]

angr/analyses/identifier/__init__.py

@@ -1 +1,2 @@
+from __future__ import annotations
 from .identify import Identifier