angr 9.2.117__py3-none-manylinux2014_aarch64.whl → 9.2.118__py3-none-manylinux2014_aarch64.whl

angr/knowledge_plugins/key_definitions/key_definition_manager.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 from collections.abc import Iterable
 
@@ -20,7 +21,7 @@ class RDAObserverControl:
             block_addr = kwargs.pop("addr", None)
             op_type = kwargs.pop("op_type", None)
             return block_addr in self.call_site_block_addrs and op_type == OP_AFTER
-        elif ob_type == "insn":
+        if ob_type == "insn":
             ins_addr = kwargs.pop("addr", None)
             op_type = kwargs.pop("op_type", None)
             return ins_addr in self.call_site_ins_addrs and op_type == OP_BEFORE
@@ -38,7 +39,7 @@ class KeyDefinitionManager(KnowledgeBasePlugin):
     - After returning from each call: ('node', address of the block that ends with a call, OP_AFTER)
     """
 
-    def __init__(self, kb: "KnowledgeBase"):
+    def __init__(self, kb: KnowledgeBase):
         super().__init__(kb=kb)
         self.model_by_funcaddr: dict[int, ReachingDefinitionsModel] = {}
 
@@ -72,9 +73,9 @@ class KeyDefinitionManager(KnowledgeBasePlugin):
 
         return self.model_by_funcaddr[func_addr]
 
-    def copy(self) -> "KeyDefinitionManager":
+    def copy(self) -> KeyDefinitionManager:
         dm = KeyDefinitionManager(self._kb)
-        dm.model_by_funcaddr = dict(map(lambda x: (x[0], x[1].copy()), self.model_by_funcaddr.items()))
+        dm.model_by_funcaddr = {x[0]: x[1].copy() for x in self.model_by_funcaddr.items()}
         return dm
 
 

angr/knowledge_plugins/key_definitions/live_definitions.py

@@ -1,4 +1,5 @@
-from typing import Optional, Union, Any, TYPE_CHECKING, overload
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING, overload
 from collections.abc import Iterable, Generator
 import weakref
 import logging
@@ -69,14 +70,13 @@ class DefinitionAnnotation(Annotation):
     def __hash__(self):
         return self._hash
 
-    def __eq__(self, other: "object"):
+    def __eq__(self, other: object):
         if type(other) is DefinitionAnnotation:
             return self.definition == other.definition
-        else:
-            return False
+        return False
 
     def __repr__(self):
-        return f"<{self.__class__.__name__}({repr(self.definition)})"
+        return f"<{self.__class__.__name__}({self.definition!r})"
 
 
 # pylint: disable=W1116
@@ -131,7 +131,7 @@ class LiveDefinitions:
         element_limit=5,
         merge_into_tops: bool = True,
     ):
-        self.project: Optional["Project"] = None
+        self.project: Project | None = None
         self.arch = arch
         self.track_tmps = track_tmps
         self._canonical_size: int = canonical_size  # TODO: Drop canonical_size
@@ -231,9 +231,9 @@ class LiveDefinitions:
         ctnt = "LiveDefs"
         if self.tmps:
             ctnt += ", %d tmpdefs" % len(self.tmps)
-        return "<%s>" % ctnt
+        return f"<{ctnt}>"
 
-    def copy(self, discard_tmpdefs=False) -> "LiveDefinitions":
+    def copy(self, discard_tmpdefs=False) -> LiveDefinitions:
         rd = LiveDefinitions(
             self.arch,
             track_tmps=self.track_tmps,
@@ -267,8 +267,8 @@ class LiveDefinitions:
 
     @staticmethod
     def _mo_cmp(
-        mo_self: Union["SimMemoryObject", set["SimMemoryObject"]],
-        mo_other: Union["SimMemoryObject", set["SimMemoryObject"]],
+        mo_self: SimMemoryObject | set[SimMemoryObject],
+        mo_other: SimMemoryObject | set[SimMemoryObject],
         addr: int,
         size: int,
     ):  # pylint:disable=unused-argument
@@ -344,7 +344,7 @@ class LiveDefinitions:
         if "stack_base" in addr.variables:
             if addr.op == "BVS":
                 return 0
-            elif addr.op == "__add__":
+            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)
@@ -378,13 +378,13 @@ class LiveDefinitions:
         return symvar.annotate(DefinitionAnnotation(definition), remove_annotations=annotations_to_remove)
 
     @staticmethod
-    def extract_defs(symvar: claripy.ast.Base) -> Generator[Definition, None, None]:
+    def extract_defs(symvar: claripy.ast.Base) -> Generator[Definition]:
         for anno in symvar.annotations:
             if isinstance(anno, DefinitionAnnotation):
                 yield anno.definition
 
     @staticmethod
-    def extract_defs_from_annotations(annos: Iterable["Annotation"]) -> set[Definition]:
+    def extract_defs_from_annotations(annos: Iterable[Annotation]) -> set[Definition]:
         defs = set()
         for anno in annos:
             if isinstance(anno, DefinitionAnnotation):
@@ -392,7 +392,7 @@ class LiveDefinitions:
         return defs
 
     @staticmethod
-    def extract_defs_from_mv(mv: MultiValues) -> Generator[Definition, None, None]:
+    def extract_defs_from_mv(mv: MultiValues) -> Generator[Definition]:
         for vs in mv.values():
             for v in vs:
                 yield from LiveDefinitions.extract_defs(v)
@@ -427,11 +427,9 @@ class LiveDefinitions:
         if sp_v is None:
             values = [v for v in next(iter(sp_values.values())) if self.get_stack_offset(v) is not None]
             assert len({self.get_stack_offset(v) for v in values}) == 1
-            result = self.get_stack_offset(values[0])
-            return result
+            return self.get_stack_offset(values[0])
 
-        result = self.get_stack_offset(sp_v)
-        return result
+        return self.get_stack_offset(sp_v)
 
     def get_stack_address(self, offset: claripy.ast.Base) -> int | None:
         offset_int = self.get_stack_offset(offset)
@@ -450,7 +448,7 @@ class LiveDefinitions:
             raise ValueError("Unsupported architecture word size %d" % self.arch.bits)
         return (base_v + offset) & mask
 
-    def merge(self, *others: "LiveDefinitions") -> tuple["LiveDefinitions", bool]:
+    def merge(self, *others: LiveDefinitions) -> tuple[LiveDefinitions, bool]:
         state = self.copy()
 
         merge_occurred = state.registers.merge([other.registers for other in others], None)
@@ -477,7 +475,7 @@ class LiveDefinitions:
 
         return state, merge_occurred
 
-    def compare(self, other: "LiveDefinitions") -> bool:
+    def compare(self, other: LiveDefinitions) -> bool:
         r0 = self.registers.compare(other.registers)
         if r0 is False:
             return False
@@ -669,7 +667,7 @@ class LiveDefinitions:
                 for v in vs:
                     defs.update(LiveDefinitions.extract_defs_from_annotations(v.annotations))
             return defs
-        elif isinstance(thing, Atom):
+        if isinstance(thing, Atom):
             pass
         elif isinstance(thing, Definition):
             thing = thing.atom
@@ -681,29 +679,26 @@ class LiveDefinitions:
 
         if isinstance(thing, Register):
             return self.get_register_definitions(thing.reg_offset, thing.size)
-        elif isinstance(thing, MemoryLocation):
+        if isinstance(thing, MemoryLocation):
             if isinstance(thing.addr, SpOffset):
                 return self.get_stack_definitions(thing.addr.offset, thing.size)
-            elif isinstance(thing.addr, HeapAddress):
+            if isinstance(thing.addr, HeapAddress):
                 return self.get_heap_definitions(thing.addr.value, size=thing.size)
-            elif isinstance(thing.addr, int):
+            if isinstance(thing.addr, int):
                 return self.get_memory_definitions(thing.addr, thing.size)
-            else:
-                return set()
-        elif isinstance(thing, Tmp):
+            return set()
+        if isinstance(thing, Tmp):
             return self.get_tmp_definitions(thing.tmp_idx)
-        else:
-            defs = set()
-            mv = self.others.get(thing, None)
-            if mv is not None:
-                defs |= self.get_definitions(mv)
-            return defs
+        defs = set()
+        mv = self.others.get(thing, None)
+        if mv is not None:
+            defs |= self.get_definitions(mv)
+        return defs
 
     def get_tmp_definitions(self, tmp_idx: int) -> set[Definition]:
         if tmp_idx in self.tmps:
             return self.tmps[tmp_idx]
-        else:
-            return set()
+        return set()
 
     def get_register_definitions(self, reg_offset: int, size: int) -> set[Definition]:
         try:
@@ -825,10 +820,7 @@ class LiveDefinitions:
                 r = self.get_values(atom)
                 if r is None:
                     continue
-                if result is None:
-                    result = r
-                else:
-                    result = result.merge(r)
+                result = r if result is None else result.merge(r)
             return result
 
         if isinstance(atom, Register):
@@ -858,10 +850,9 @@ class LiveDefinitions:
                         bytestring = self.project.loader.memory.load(atom.addr, atom.size)
                         if atom.endness == archinfo.Endness.LE:
                             bytestring = bytes(reversed(bytestring))
-                        mv = MultiValues(
+                        return MultiValues(
                             self.annotate_with_def(claripy.BVV(bytestring), Definition(atom, ExternalCodeLocation()))
                         )
-                        return mv
                     except KeyError:
                         pass
                 return None
@@ -926,7 +917,7 @@ class LiveDefinitions:
 
     def add_stack_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Any | None = None) -> None:
         if not isinstance(atom.addr, SpOffset):
-            raise TypeError("Atom %r is not a stack location atom." % atom)
+            raise TypeError(f"Atom {atom!r} is not a stack location atom.")
 
         for current_def in self.get_definitions(atom):
             self.add_stack_use_by_def(current_def, code_loc, expr=expr)
@@ -937,7 +928,7 @@ class LiveDefinitions:
 
     def add_heap_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Any | None = None) -> None:
         if not isinstance(atom.addr, HeapAddress):
-            raise TypeError("Atom %r is not a heap location atom." % atom)
+            raise TypeError(f"Atom {atom!r} is not a heap location atom.")
 
         current_defs = self.get_definitions(atom)
 
@@ -974,7 +965,7 @@ class LiveDefinitions:
 
     def add_tmp_use_by_def(self, def_: Definition, code_loc: CodeLocation) -> None:
         if not isinstance(def_.atom, Tmp):
-            raise TypeError("Atom %r is not a Tmp atom." % def_.atom)
+            raise TypeError(f"Atom {def_.atom!r} is not a Tmp atom.")
 
         self.tmp_uses[def_.atom.tmp_idx].add(code_loc)
         self.uses_by_codeloc[code_loc].add(def_)
@@ -1063,7 +1054,7 @@ class LiveDefinitions:
         if "heap_base" in addr.variables:
             if addr.op == "BVS":
                 return 0
-            elif addr.op == "__add__" and len(addr.args) == 2 and addr.args[1].op == "BVV":
+            if addr.op == "__add__" and len(addr.args) == 2 and addr.args[1].op == "BVV":
                 return addr.args[1].concrete_value
         return None
 

angr/knowledge_plugins/key_definitions/liveness.py

@@ -1,4 +1,5 @@
-from typing import DefaultDict, Optional, TYPE_CHECKING
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
 
 from collections import defaultdict
 from itertools import chain
@@ -26,23 +27,23 @@ class Liveness:
     """
 
     def __init__(self):
-        self.curr_live_defs: set["Definition"] = set()
+        self.curr_live_defs: set[Definition] = set()
         self.curr_loc: LocationType | None = None
         self.curr_block: BlockAddrType | None = None
         self.curr_stmt_idx: int | None = None
-        self.blockstart_to_defs: DefaultDict[BlockAddrType, set["Definition"]] = defaultdict(set)
-        self.blockend_to_defs: DefaultDict[BlockAddrType, set["Definition"]] = defaultdict(set)
-        self.loc_to_killed_defs: DefaultDict[BlockAddrType, dict[int, set["Definition"]]] = defaultdict(dict)
-        self.loc_to_added_defs: DefaultDict[BlockAddrType, dict[int, set["Definition"]]] = defaultdict(dict)
-        self._node_max_stmt_id: DefaultDict[BlockAddrType, int] = defaultdict(int)
+        self.blockstart_to_defs: defaultdict[BlockAddrType, set[Definition]] = defaultdict(set)
+        self.blockend_to_defs: defaultdict[BlockAddrType, set[Definition]] = defaultdict(set)
+        self.loc_to_killed_defs: defaultdict[BlockAddrType, dict[int, set[Definition]]] = defaultdict(dict)
+        self.loc_to_added_defs: defaultdict[BlockAddrType, dict[int, set[Definition]]] = defaultdict(dict)
+        self._node_max_stmt_id: defaultdict[BlockAddrType, int] = defaultdict(int)
 
-    def add_def(self, d: "Definition") -> None:
+    def add_def(self, d: Definition) -> None:
         self.curr_live_defs.add(d)
         if self.curr_stmt_idx not in self.loc_to_added_defs[self.curr_block]:
             self.loc_to_added_defs[self.curr_block][self.curr_stmt_idx] = set()
         self.loc_to_added_defs[self.curr_block][self.curr_stmt_idx].add(d)
 
-    def kill_def(self, d: "Definition") -> None:
+    def kill_def(self, d: Definition) -> None:
         self.curr_live_defs.discard(d)
         if self.curr_stmt_idx not in self.loc_to_killed_defs[self.curr_block]:
             self.loc_to_killed_defs[self.curr_block][self.curr_stmt_idx] = set()
@@ -52,7 +53,7 @@ class Liveness:
         if self.curr_block is not None:
             self.blockend_to_defs[self.curr_block] |= self.curr_live_defs
 
-    def at_new_stmt(self, code_loc: "CodeLocation") -> None:
+    def at_new_stmt(self, code_loc: CodeLocation) -> None:
         """
         Only support moving from a statement to the next statement within one basic block.
         """
@@ -65,7 +66,7 @@ class Liveness:
         ):
             self._node_max_stmt_id[(code_loc.block_addr, code_loc.block_idx)] = code_loc.stmt_idx
 
-    def at_new_block(self, code_loc: "CodeLocation", pred_codelocs: list["CodeLocation"]) -> None:
+    def at_new_block(self, code_loc: CodeLocation, pred_codelocs: list[CodeLocation]) -> None:
         """
         Only support moving to a new block from one or more blocks.
         """
@@ -87,31 +88,25 @@ class Liveness:
         self.curr_loc = loc
         self.curr_stmt_idx = 0
 
-    def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> set["Definition"]:
+    def find_defs_at(self, code_loc: CodeLocation, op: int = OP_BEFORE) -> set[Definition]:
         return self.find_defs_at_raw(code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx, op=op)
 
     def find_defs_at_raw(
         self, block_addr: int, block_idx: int | None, stmt_idx: int | None, op: int = OP_BEFORE
-    ) -> set["Definition"]:
+    ) -> set[Definition]:
         block: BlockAddrType = block_addr, block_idx
-        if block not in self.blockstart_to_defs:
-            defs = set()
-        else:
-            defs = self.blockstart_to_defs[block].copy()
+        defs = set() if block not in self.blockstart_to_defs else self.blockstart_to_defs[block].copy()
 
         if stmt_idx is None:
             return defs
 
-        added_defs = self.loc_to_added_defs[block] if block in self.loc_to_added_defs else None
+        added_defs = self.loc_to_added_defs.get(block, None)
         killed_defs = self.loc_to_killed_defs[block] if block in self.loc_to_added_defs else None
 
         if stmt_idx == DEFAULT_STATEMENT:
             end_stmt_idx = self._node_max_stmt_id[block] + 1
         else:
-            if op == OP_BEFORE:
-                end_stmt_idx = stmt_idx
-            else:
-                end_stmt_idx = stmt_idx + 1
+            end_stmt_idx = stmt_idx if op == OP_BEFORE else stmt_idx + 1
 
         if added_defs is not None and killed_defs is not None:
             indices = chain(added_defs, killed_defs)
@@ -156,7 +151,7 @@ class Liveness:
 
         return defs
 
-    def copy(self) -> "Liveness":
+    def copy(self) -> Liveness:
         o = Liveness()
         o.curr_live_defs = self.curr_live_defs.copy()
         o.curr_loc = self.curr_loc

angr/knowledge_plugins/key_definitions/rd_model.py

@@ -1,4 +1,5 @@
-from typing import Union, TYPE_CHECKING, overload
+from __future__ import annotations
+from typing import TYPE_CHECKING, overload
 
 from .atoms import Atom, Register, MemoryLocation, SpOffset
 from .uses import Uses
@@ -22,7 +23,7 @@ class ReachingDefinitionsModel:
         self.observed_results: dict[
             tuple[str, int | tuple[int, int] | tuple[int, int, int], ObservationPointType], LiveDefinitions
         ] = {}
-        self.all_definitions: set["Definition"] = set()
+        self.all_definitions: set[Definition] = set()
         self.all_uses = Uses()
         self.liveness = Liveness() if track_liveness else None
 
@@ -32,19 +33,19 @@ class ReachingDefinitionsModel:
             len(self.observed_results),
         )
 
-    def add_def(self, d: "Definition") -> None:
+    def add_def(self, d: Definition) -> None:
         if self.liveness is not None:
             self.liveness.add_def(d)
 
-    def kill_def(self, d: "Definition") -> None:
+    def kill_def(self, d: Definition) -> None:
         if self.liveness is not None:
             self.liveness.kill_def(d)
 
-    def at_new_stmt(self, codeloc: "CodeLocation") -> None:
+    def at_new_stmt(self, codeloc: CodeLocation) -> None:
         if self.liveness is not None:
             self.liveness.at_new_stmt(codeloc)
 
-    def at_new_block(self, code_loc: "CodeLocation", pred_codelocs: list["CodeLocation"]) -> None:
+    def at_new_block(self, code_loc: CodeLocation, pred_codelocs: list[CodeLocation]) -> None:
         if self.liveness is not None:
             self.liveness.at_new_block(code_loc, pred_codelocs)
 
@@ -52,10 +53,10 @@ class ReachingDefinitionsModel:
         if self.liveness is not None:
             self.liveness.make_liveness_snapshot()
 
-    def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> set["Definition"]:
+    def find_defs_at(self, code_loc: CodeLocation, op: int = OP_BEFORE) -> set[Definition]:
         return self.liveness.find_defs_at(code_loc, op=op)
 
-    def get_defs(self, atom: Atom, code_loc: "CodeLocation", op: int) -> set["Definition"]:
+    def get_defs(self, atom: Atom, code_loc: CodeLocation, op: int) -> set[Definition]:
         all_defs = self.liveness.find_defs_at(code_loc, op=op)
         defs = None
         if isinstance(atom, Register):
@@ -95,7 +96,7 @@ class ReachingDefinitionsModel:
 
         return defs
 
-    def copy(self) -> "ReachingDefinitionsModel":
+    def copy(self) -> ReachingDefinitionsModel:
         new = ReachingDefinitionsModel(self.func_addr)
         new.observed_results = self.observed_results.copy()
         new.all_definitions = self.all_definitions.copy()
@@ -103,45 +104,42 @@ class ReachingDefinitionsModel:
         new.liveness = self.liveness.copy() if self.liveness is not None else None
         return new
 
-    def merge(self, model: "ReachingDefinitionsModel"):
+    def merge(self, model: ReachingDefinitionsModel):
         for k, v in model.observed_results.items():
             if k not in self.observed_results:
                 self.observed_results[k] = v
             else:
-                merged, merge_occured = self.observed_results[k].merge(v)
-                if merge_occured:
+                merged, merge_occurred = self.observed_results[k].merge(v)
+                if merge_occurred:
                     self.observed_results[k] = merged
         self.all_definitions.union(model.all_definitions)
         self.all_uses.merge(model.all_uses)
         # TODO: Merge self.liveness
 
     def get_observation_by_insn(
-        self, ins_addr: Union[int, "CodeLocation"], kind: ObservationPointType
+        self, ins_addr: int | CodeLocation, kind: ObservationPointType
     ) -> LiveDefinitions | None:
         if isinstance(ins_addr, int):
             return self.observed_results.get(("insn", ins_addr, kind), None)
-        elif ins_addr.ins_addr is None:
+        if ins_addr.ins_addr is None:
             raise ValueError("CodeLocation must have an instruction address associated")
         return self.observed_results.get(("insn", ins_addr.ins_addr, kind))
 
     def get_observation_by_node(
-        self, node_addr: Union[int, "CodeLocation"], kind: ObservationPointType, node_idx: int | None = None
+        self, node_addr: int | CodeLocation, kind: ObservationPointType, node_idx: int | None = None
     ) -> LiveDefinitions | None:
         if isinstance(node_addr, int):
             key = ("node", node_addr, kind) if node_idx is None else ("node", (node_addr, node_idx), kind)
             return self.observed_results.get(key, None)
-        else:
-            key = (
-                ("node", node_addr.block_addr, kind)
-                if node_idx is None
-                else ("node", (node_addr.block_addr, node_idx), kind)
-            )
-            return self.observed_results.get(key, None)
+        key = (
+            ("node", node_addr.block_addr, kind)
+            if node_idx is None
+            else ("node", (node_addr.block_addr, node_idx), kind)
+        )
+        return self.observed_results.get(key, None)
 
     @overload
-    def get_observation_by_stmt(
-        self, codeloc: "CodeLocation", kind: ObservationPointType
-    ) -> LiveDefinitions | None: ...
+    def get_observation_by_stmt(self, codeloc: CodeLocation, kind: ObservationPointType) -> LiveDefinitions | None: ...
 
     @overload
     def get_observation_by_stmt(
@@ -152,15 +150,12 @@ class ReachingDefinitionsModel:
         if isinstance(arg1, int):
             if block_idx is None:
                 return self.observed_results.get(("stmt", (arg1, arg2), arg3), None)
-            else:
-                return self.observed_results.get(("stmt", (arg1, arg2, block_idx), arg3), None)
-        else:
-            if arg1.stmt_idx is None:
-                raise ValueError("CodeLocation must have a statement index associated")
-            if arg1.block_idx is None:
-                return self.observed_results.get(("stmt", (arg1.block_addr, arg1.stmt_idx), arg2), None)
-            else:
-                return self.observed_results.get(("stmt", (arg1.block_addr, arg1.stmt_idx, block_idx), arg2), None)
+            return self.observed_results.get(("stmt", (arg1, arg2, block_idx), arg3), None)
+        if arg1.stmt_idx is None:
+            raise ValueError("CodeLocation must have a statement index associated")
+        if arg1.block_idx is None:
+            return self.observed_results.get(("stmt", (arg1.block_addr, arg1.stmt_idx), arg2), None)
+        return self.observed_results.get(("stmt", (arg1.block_addr, arg1.stmt_idx, block_idx), arg2), None)
 
     def get_observation_by_exit(
         self,

angr/knowledge_plugins/key_definitions/tag.py

@@ -9,6 +9,8 @@ Classes to structure the different types of <Tag>s that can be attached to <Defi
     - InitialValueTag
 """
 
+from __future__ import annotations
+
 
 class Tag:
     """
@@ -27,15 +29,14 @@ class FunctionTag(Tag):
     A tag for a definition created (or used) in the context of a function.
     """
 
-    def __init__(self, function: int = None, metadata: object = None):
+    def __init__(self, function: int | None = None, metadata: object = None):
         super().__init__(metadata)
         self.function = function
 
     def __repr__(self):
         if self.function:
             return f"<{self.__class__.__name__} {{Function: {self.function:#x}, Metadata:{self.metadata}}}>"
-        else:
-            return super().__repr__()
+        return super().__repr__()
 
 
 class SideEffectTag(FunctionTag):
@@ -60,18 +61,18 @@ class LocalVariableTag(FunctionTag):
 
 class ReturnValueTag(FunctionTag):
     """
-    A tag for a definiton of a return value
+    A tag for a definition of a return value
     of a function.
     """
 
 
 class InitialValueTag(Tag):
     """
-    A tag for a definiton of an initial value
+    A tag for a definition of an initial value
     """
 
 
 class UnknownSizeTag(Tag):
     """
-    A tag for a definiton of an initial value
+    A tag for a definition of an initial value
     """

angr/knowledge_plugins/key_definitions/undefined.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class Undefined:
     """
     A TOP-like value indicating an unknown data source. Should live next to raw integers in DataSets.

angr/knowledge_plugins/key_definitions/unknown_size.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class UnknownSize:
     """
     A value indicating an unknown size for elements of DataSets.