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

angr/misc/autoimport.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import importlib
 import importlib.machinery
@@ -23,7 +24,7 @@ def auto_import_packages(base_module, base_path, ignore_dirs=(), ignore_files=()
         l.debug("Loading %s.%s", base_module, lib_module_name)
 
         try:
-            package = importlib.import_module(".%s" % lib_module_name, base_module)
+            package = importlib.import_module(f".{lib_module_name}", base_module)
         except ImportError:
             l.warning("Unable to autoimport package %s.%s", base_module, lib_module_name, exc_info=True)
         else:
@@ -47,7 +48,7 @@ def auto_import_modules(base_module, base_path, ignore_files=(), filter_func: Ca
             continue
 
         try:
-            proc_module = importlib.import_module(".%s" % proc_module_name, base_module)
+            proc_module = importlib.import_module(f".{proc_module_name}", base_module)
         except ImportError:
             l.warning("Unable to autoimport module %s.%s", base_module, proc_module_name, exc_info=True)
             continue

angr/misc/bug_report.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import importlib.metadata
 import os
 import sys
@@ -21,7 +22,7 @@ native_modules = {
     "angr": lambda: angr.state_plugins.unicorn_engine._UC_NATIVE,  # pylint: disable=undefined-variable
     "unicorn": lambda: unicorn.unicorn._uc,  # pylint: disable=undefined-variable
     "pyvex": lambda: pyvex.pvc,  # pylint: disable=undefined-variable
-    "z3": lambda: [x for x in gc.get_objects() if type(x) is ctypes.CDLL and "z3" in str(x)][0],  # YIKES FOREVER
+    "z3": lambda: next(x for x in gc.get_objects() if type(x) is ctypes.CDLL and "z3" in str(x)),  # YIKES FOREVER
 }
 python_packages = {"z3": "z3-solver"}
 
@@ -34,7 +35,7 @@ def get_venv():
 
 def print_versions():
     for m in angr_modules:
-        print("######## %s #########" % m)
+        print(f"######## {m} #########")
         try:
             python_filename = importlib.util.find_spec(m).origin
         except ImportError:
@@ -42,11 +43,11 @@ def print_versions():
             continue
         except Exception as e:  # pylint: disable=broad-except
             print(f"An error occurred importing {m}: {e}")
-        print("Python found it in %s" % (python_filename))
+        print(f"Python found it in {python_filename}")
         try:
             pip_package = python_packages.get(m, m)
             pip_version = importlib.metadata.version(pip_package)
-            print("Pip version %s" % pip_version)
+            print(f"Pip version {pip_version}")
         except Exception:  # pylint: disable-broad-except
             print("Pip version not found!")
         print_git_info(python_filename)
@@ -72,7 +73,7 @@ def print_git_info(dirname):
             remote_url = repo.remotes[remote_name].url
             print(f"\tChecked out from remote {remote_name}: {remote_url}")
         else:
-            print("Tracking local branch %s" % cur_tb.name)
+            print(f"Tracking local branch {cur_tb.name}")
     except Exception:  # pylint: disable=broad-except
         print("Could not resolve tracking branch or remote info!")
 

angr/misc/hookset.py

@@ -4,6 +4,8 @@ This process is formalized as a "hooking" of a python method - each exploration
 the same name on the simulation manager class.
 """
 
+from __future__ import annotations
+
 
 class HookSet:
     """
@@ -97,8 +99,7 @@ class HookedMethod:
             finally:
                 self.pending.append(current_hook)
             return result
-        else:
-            return self.func(*args, **kwargs)
+        return self.func(*args, **kwargs)
 
     def copy_to(self, new_func):
         new_hooked = HookedMethod(new_func)

angr/misc/loggers.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import traceback
 import logging
 import zlib
@@ -49,8 +50,7 @@ class Loggers:
         real_k = k.replace("_", ".")
         if real_k in self._loggers:
             return self._loggers[real_k]
-        else:
-            raise AttributeError(k)
+        raise AttributeError(k)
 
     def __dir__(self):
         return list(super().__dir__()) + list(self._loggers.keys())

angr/misc/picklable_lock.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import threading
 
 

angr/misc/plugins.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TypeVar, Generic
 
 from angr.errors import AngrNoPluginError
@@ -74,8 +75,8 @@ class PluginHub(Generic[P]):
     def __getattr__(self, name: str) -> P:
         try:
             return self.get_plugin(name)
-        except AngrNoPluginError:
-            raise AttributeError(name)
+        except AngrNoPluginError as err:
+            raise AttributeError(name) from err
 
     def __dir__(self):
         out = set(self.__dict__)
@@ -120,11 +121,11 @@ class PluginHub(Generic[P]):
         if isinstance(preset, str):
             try:
                 preset = self._presets[preset]
-            except (AttributeError, KeyError):
-                raise AngrNoPluginError("There is no preset named %s" % preset)
+            except (AttributeError, KeyError) as err:
+                raise AngrNoPluginError(f"There is no preset named {preset}") from err
 
         elif not isinstance(preset, PluginPreset):
-            raise ValueError("Argument must be an instance of PluginPreset: %s" % preset)
+            raise ValueError(f"Argument must be an instance of PluginPreset: {preset}")
 
         if self._active_preset:
             l.warning("Overriding active preset %s with %s", self._active_preset, preset)
@@ -156,7 +157,7 @@ class PluginHub(Generic[P]):
         if name in self._active_plugins:
             return self._active_plugins[name]
 
-        elif self._active_preset is not None:
+        if self._active_preset is not None:
             plugin_cls: type[P] = self._active_preset.request_plugin(name)
             plugin = self._init_plugin(plugin_cls)
 
@@ -166,8 +167,7 @@ class PluginHub(Generic[P]):
             self.register_plugin(name, plugin)
             return plugin
 
-        else:
-            raise AngrNoPluginError("No such plugin: %s" % name)
+        raise AngrNoPluginError(f"No such plugin: {name}")
 
     def _init_plugin(self, plugin_cls: type[P]) -> P:  # pylint: disable=no-self-use
         """
@@ -250,8 +250,8 @@ class PluginPreset:
         """
         try:
             return self._default_plugins[name]
-        except KeyError:
-            raise AngrNoPluginError("There is no plugin named %s" % name)
+        except KeyError as err:
+            raise AngrNoPluginError(f"There is no plugin named {name}") from err
 
     def copy(self):
         """
@@ -266,7 +266,7 @@ class PluginPreset:
 class PluginVendor(Generic[P], PluginHub[P]):
     """
     A specialized hub which serves only as a plugin vendor, never having any "active" plugins.
-    It will directly return the plugins provided by the preset instead of instanciating them.
+    It will directly return the plugins provided by the preset instead of instantiating them.
     """
 
     def release_plugin(self, name):
@@ -287,5 +287,3 @@ class VendorPreset(PluginPreset):
     """
     A specialized preset class for use with the PluginVendor.
     """
-
-    ...

angr/misc/range.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class IRange:
     """
     A simple range object for testing inclusion. Like range but works for huge numbers.

angr/misc/testing.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 
 TESTER_MODULE_NAMES = ["unittest", "pytest", "_pytest", "nose", "nose2"]
@@ -14,7 +15,7 @@ def detect_test_env():
 
         if frame_module == "__main__" or frame_module == "__console__":
             return False
-        elif frame_module is not None and any(
+        if frame_module is not None and any(
             frame_module.startswith(module_name + ".") for module_name in TESTER_MODULE_NAMES
         ):
             return True

angr/misc/ux.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import warnings
 
 
@@ -7,9 +8,8 @@ once_set = set()
 def once(key):
     if key in once_set:
         return False
-    else:
-        once_set.add(key)
-        return True
+    once_set.add(key)
+    return True
 
 
 already_complained = set()
@@ -20,9 +20,9 @@ def deprecated(replacement=None):
         def inner(*args, **kwargs):
             if func not in already_complained:
                 if replacement is None:
-                    warnings.warn("Don't use %s" % (func.__name__), DeprecationWarning)
+                    warnings.warn(f"Don't use {func.__name__}", DeprecationWarning, stacklevel=1)
                 else:
-                    warnings.warn(f"Use {replacement} instead of {func.__name__}", DeprecationWarning)
+                    warnings.warn(f"Use {replacement} instead of {func.__name__}", DeprecationWarning, stacklevel=1)
                 already_complained.add(func)
             return func(*args, **kwargs)
 

angr/misc/weakpatch.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from weakref import WeakValueDictionary, WeakKeyDictionary, _IterationGuard
 
 

angr/procedures/__init__.py

@@ -1,2 +1,3 @@
+from __future__ import annotations
 from .procedure_dict import SIM_PROCEDURES, SimProcedures
 from .definitions import SIM_LIBRARIES, SIM_TYPE_COLLECTIONS

angr/procedures/cgc/_terminate.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import angr
 
 

angr/procedures/cgc/allocate.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 import claripy
@@ -18,13 +19,13 @@ class allocate(angr.SimProcedure):
         length = self.state.solver.max_int(length)
 
         # return code (see allocate() docs)
-        r = self.state.solver.ite_cases(
+        r = claripy.ite_cases(
             (
                 (length == 0, self.state.cgc.EINVAL),
                 (length > self.state.cgc.max_allocation, self.state.cgc.EINVAL),
                 (self.state.cgc.addr_invalid(addr), self.state.cgc.EFAULT),
             ),
-            self.state.solver.BVV(0, self.state.arch.bits),
+            claripy.BVV(0, self.state.arch.bits),
         )
 
         if self.state.solver.max_int(r) != 0:
@@ -34,7 +35,7 @@ class allocate(angr.SimProcedure):
         aligned_length = ((length + 0xFFF) // 0x1000) * 0x1000
 
         if isinstance(self.state.cgc.allocation_base, int):
-            self.state.cgc.allocation_base = self.state.solver.BVV(self.state.cgc.allocation_base, self.state.arch.bits)
+            self.state.cgc.allocation_base = claripy.BVV(self.state.cgc.allocation_base, self.state.arch.bits)
 
         chosen = self.state.cgc.get_max_sinkhole(aligned_length)
         if chosen is None:
@@ -49,26 +50,24 @@ class allocate(angr.SimProcedure):
                 if sinkhole_size != 0:
                     self.state.cgc.add_sinkhole(cgc_flag_page_start_addr + 0x1000, sinkhole_size)
 
-                chosen = self.state.solver.BVV(cgc_flag_page_start_addr - aligned_length, self.state.arch.bits)
+                chosen = claripy.BVV(cgc_flag_page_start_addr - aligned_length, self.state.arch.bits)
             elif chosen_conc <= self.state.project.loader.max_addr < allocation_base_conc:
                 # Chosen memory overlaps with some loaded object
                 sinkhole_size = allocation_base_conc - self.state.project.loader.max_addr
                 if sinkhole_size != 0:
                     self.state.cgc.add_sinkhole(self.state.project.loader.max_addr, sinkhole_size)
 
-                chosen = self.state.solver.BVV(
-                    self.state.project.loader.min_addr - aligned_length, self.state.arch.bits
-                )
+                chosen = claripy.BVV(self.state.project.loader.min_addr - aligned_length, self.state.arch.bits)
 
             self.state.cgc.allocation_base = chosen
 
         self.state.memory.store(
-            addr, chosen, size=self.state.arch.bytes, condition=self.state.solver.And(addr != 0), endness="Iend_LE"
+            addr, chosen, size=self.state.arch.bytes, condition=claripy.And(addr != 0), endness="Iend_LE"
         )
 
         # PROT_READ | PROT_WRITE default
-        permissions = self.state.solver.BVV(1 | 2, 3)
-        permissions |= self.state.solver.If(is_x != 0, claripy.BVV(4, 3), claripy.BVV(0, 3))
+        permissions = claripy.BVV(1 | 2, 3)
+        permissions |= claripy.If(is_x != 0, claripy.BVV(4, 3), claripy.BVV(0, 3))
 
         chosen_conc = self.state.solver.eval(chosen)
         l.debug("Allocating [%#x, %#x]", chosen_conc, chosen_conc + aligned_length - 1)

angr/procedures/cgc/deallocate.py

@@ -1,8 +1,11 @@
+from __future__ import annotations
 import logging
 
+import claripy
 from unique_log_filter import UniqueLogFilter
 
 import angr
+from angr.state_plugins.sim_action_object import SimActionObject
 
 l = logging.getLogger(name=__name__)
 l.addFilter(UniqueLogFilter())
@@ -11,16 +14,21 @@ l.addFilter(UniqueLogFilter())
 class deallocate(angr.SimProcedure):
     # pylint:disable=arguments-differ
 
-    def run(self, addr, length):  # pylint:disable=unused-argument
+    def run(self, addr, length):
+        if isinstance(addr, SimActionObject):
+            addr = addr.ast
+        if isinstance(length, SimActionObject):
+            length = length.ast
+
         # return code (see deallocate() docs)
-        r = self.state.solver.ite_cases(
+        r = claripy.ite_cases(
             (
                 (addr % 0x1000 != 0, self.state.cgc.EINVAL),
                 (length == 0, self.state.cgc.EINVAL),
                 (self.state.cgc.addr_invalid(addr), self.state.cgc.EINVAL),
                 (self.state.cgc.addr_invalid(addr + length), self.state.cgc.EINVAL),
             ),
-            self.state.solver.BVV(0, self.state.arch.bits),
+            claripy.BVV(0, self.state.arch.bits),
         )
 
         if self.state.solver.symbolic(addr):

angr/procedures/cgc/fdwait.py

@@ -1,7 +1,10 @@
-import angr
-
+from __future__ import annotations
 import itertools
 
+import claripy
+
+import angr
+
 fdcount = itertools.count()
 
 
@@ -10,42 +13,42 @@ class fdwait(angr.SimProcedure):
 
     def run(self, nfds, readfds, writefds, timeout, readyfds):
         run_count = next(fdcount)
-        total_ready = self.state.solver.BVV(0, self.state.arch.bits)
+        total_ready = claripy.BVV(0, self.state.arch.bits)
 
         read_fds = []
         for fd_set in range(0, 32, 8):
             sym_newbits = []
             for fd in range(fd_set, fd_set + 8):
                 if angr.options.CGC_NON_BLOCKING_FDS in self.state.options:
-                    sym_bit = self.state.solver.BVV(1, 1)
+                    sym_bit = claripy.BVV(1, 1)
                 else:
                     sym_bit = self.state.solver.Unconstrained(
                         "fdwait_read_%d_%d" % (run_count, fd), 1, key=("syscall", "fdwait", fd, "read_ready")
                     )
-                fd = self.state.solver.BVV(fd, self.state.arch.bits)
-                sym_newbit = self.state.solver.If(self.state.solver.ULT(fd, nfds), sym_bit, 0)
+                fd = claripy.BVV(fd, self.state.arch.bits)
+                sym_newbit = claripy.If(claripy.ULT(fd, nfds), sym_bit, 0)
                 total_ready += sym_newbit.zero_extend(self.state.arch.bits - 1)
                 sym_newbits.append(sym_newbit)
             read_fds.extend(reversed(sym_newbits))
-        self.state.memory.store(readfds, self.state.solver.Concat(*read_fds), condition=readfds != 0)
+        self.state.memory.store(readfds, claripy.Concat(*read_fds), condition=readfds != 0)
 
         write_fds = []
         for fd_set in range(0, 32, 8):
             sym_newbits = []
             for fd in range(fd_set, fd_set + 8):
                 if angr.options.CGC_NON_BLOCKING_FDS in self.state.options:
-                    sym_bit = self.state.solver.BVV(1, 1)
+                    sym_bit = claripy.BVV(1, 1)
                 else:
                     sym_bit = self.state.solver.Unconstrained(
                         "fdwait_write_%d_%d" % (run_count, fd), 1, key=("syscall", "fdwait", fd, "write_ready")
                     )
 
-                fd = self.state.solver.BVV(fd, self.state.arch.bits)
-                sym_newbit = self.state.solver.If(self.state.solver.ULT(fd, nfds), sym_bit, 0)
+                fd = claripy.BVV(fd, self.state.arch.bits)
+                sym_newbit = claripy.If(claripy.ULT(fd, nfds), sym_bit, 0)
                 total_ready += sym_newbit.zero_extend(self.state.arch.bits - 1)
                 sym_newbits.append(sym_newbit)
             write_fds.extend(reversed(sym_newbits))
-        self.state.memory.store(writefds, self.state.solver.Concat(*write_fds), condition=writefds != 0)
+        self.state.memory.store(writefds, claripy.Concat(*write_fds), condition=writefds != 0)
 
         self.state.memory.store(readyfds, total_ready, endness="Iend_LE", condition=readyfds != 0)
 
@@ -56,7 +59,7 @@ class fdwait(angr.SimProcedure):
             timeout + 4, 4, endness=self.state.arch.memory_endness, condition=timeout != 0, fallback=0
         )
         total_time = tv_sec * 1000000 + tv_usec
-        self.state.cgc.time += self.state.solver.If(total_ready == 0, total_time, 0)
+        self.state.cgc.time += claripy.If(total_ready == 0, total_time, 0)
 
         # TODO: errors
-        return self.state.solver.BVV(0, self.state.arch.bits)
+        return claripy.BVV(0, self.state.arch.bits)

angr/procedures/cgc/random.py

@@ -1,6 +1,10 @@
+from __future__ import annotations
 import itertools
 
+import claripy
+
 import angr
+from angr.state_plugins.sim_action_object import SimActionObject
 
 rand_count = itertools.count()
 
@@ -9,6 +13,9 @@ class random(angr.SimProcedure):
     # pylint:disable=arguments-differ,missing-class-docstring
 
     def run(self, buf, count, rnd_bytes, concrete_data=None):
+        if isinstance(rnd_bytes, SimActionObject):
+            rnd_bytes = rnd_bytes.ast
+
         if self.state.mode == "fastpath":
             # Special case for CFG
             if (
@@ -28,15 +35,15 @@ class random(angr.SimProcedure):
                     self.state.memory.store(rnd_bytes, count, endness="Iend_LE")
 
             # We always return something in fastpath mode
-            return self.state.solver.BVV(0, self.state.arch.bits)
+            return claripy.BVV(0, self.state.arch.bits)
 
         # return code
-        r = self.state.solver.ite_cases(
+        r = claripy.ite_cases(
             (
                 (self.state.cgc.addr_invalid(buf), self.state.cgc.EFAULT),
-                (self.state.solver.And(rnd_bytes != 0, self.state.cgc.addr_invalid(rnd_bytes)), self.state.cgc.EFAULT),
+                (claripy.And(rnd_bytes != 0, self.state.cgc.addr_invalid(rnd_bytes)), self.state.cgc.EFAULT),
             ),
-            self.state.solver.BVV(0, self.state.arch.bits),
+            claripy.BVV(0, self.state.arch.bits),
         )
 
         if self.state.satisfiable(extra_constraints=[count != 0]):
@@ -46,7 +53,7 @@ class random(angr.SimProcedure):
             )
 
             if concrete_data:
-                value = self.state.solver.BVS(f"random_{next(rand_count)}", max_size)
+                value = claripy.BVS(f"random_{next(rand_count)}", max_size)
                 self.state.preconstrainer.preconstrain(concrete_data, value)
             else:
                 value = self.state.solver.Unconstrained(

angr/procedures/cgc/receive.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
 from itertools import count
 
+import claripy
+
 import angr
 
 from ... import sim_options as o
@@ -30,7 +33,7 @@ class receive(angr.SimProcedure):
                 count = self.state.solver.Unconstrained("receive_length", self.state.arch.bits)
             self.state.memory.store(rx_bytes, count, endness="Iend_LE")
 
-            return self.state.solver.BVV(0, self.state.arch.bits)
+            return claripy.BVV(0, self.state.arch.bits)
 
         # check invalid memory accesses
         # rules for invalid: greater than 0xc0 or wraps around
@@ -56,36 +59,35 @@ class receive(angr.SimProcedure):
             )
             read_length = simfd.read(buf, count, short_reads=False, do_concrete_update=do_concrete_update)
             if type(read_length) is int:
-                read_length = self.state.solver.BVV(read_length, 32)
+                read_length = claripy.BVV(read_length, 32)
             self.state.memory.store(rx_bytes, read_length, condition=rx_bytes != 0, endness="Iend_LE")
             self.size = read_length
 
             return 0
-        else:
-            if self.state.solver.solution(count != 0, True):
-                data, read_length = simfd.read_data(count)
-                if not self.state.solver.is_true(read_length == 0):
-                    self.state.memory.store(buf, data, size=read_length)
-                action_list = list(self.state.history.recent_actions)
-
-                try:
-                    # get and fix up the memory write
-                    action = next(
-                        a
-                        for a in reversed(action_list)
-                        if isinstance(a, SimActionData) and a.action == "write" and a.type == "mem"
-                    )
-                    action.size.ast = read_length
-                    action.data.ast = action.actual_value.ast
-                    self.data = data
-                except StopIteration:
-                    # the write didn't occur (i.e., size of 0)
-                    self.data = None
-            else:
+        if self.state.solver.solution(count != 0, True):
+            data, read_length = simfd.read_data(count)
+            if not self.state.solver.is_true(read_length == 0):
+                self.state.memory.store(buf, data, size=read_length)
+            action_list = list(self.state.history.recent_actions)
+
+            try:
+                # get and fix up the memory write
+                action = next(
+                    a
+                    for a in reversed(action_list)
+                    if isinstance(a, SimActionData) and a.action == "write" and a.type == "mem"
+                )
+                action.size.ast = read_length
+                action.data.ast = action.actual_value.ast
+                self.data = data
+            except StopIteration:
+                # the write didn't occur (i.e., size of 0)
                 self.data = None
+        else:
+            self.data = None
 
-            self.size = read_length
-            if type(read_length) is int:
-                read_length = self.state.solver.BVV(read_length, 32)
-            self.state.memory.store(rx_bytes, read_length, condition=rx_bytes != 0, endness="Iend_LE")
-            return 0
+        self.size = read_length
+        if type(read_length) is int:
+            read_length = claripy.BVV(read_length, 32)
+        self.state.memory.store(rx_bytes, read_length, condition=rx_bytes != 0, endness="Iend_LE")
+        return 0

angr/procedures/cgc/transmit.py

@@ -1,5 +1,7 @@
-import angr
+from __future__ import annotations
+import claripy
 
+import angr
 from ... import sim_options as o
 
 
@@ -17,7 +19,7 @@ class transmit(angr.SimProcedure):
         if self.state.mode == "fastpath":
             # Special case for CFG generation
             self.state.memory.store(tx_bytes, count, endness="Iend_LE")
-            return self.state.solver.BVV(0, self.state.arch.bits)
+            return claripy.BVV(0, self.state.arch.bits)
 
         if o.ABSTRACT_MEMORY in self.state.options:
             simfd.write(buf, count)
@@ -54,10 +56,10 @@ class transmit(angr.SimProcedure):
             )
 
             if do_concrete_update and count.symbolic:
-                concrete_count = self.state.solver.BVV(self.state.solver.eval(count), 32)
+                concrete_count = claripy.BVV(self.state.solver.eval(count), 32)
                 self.state.memory.store(tx_bytes, concrete_count, endness="Iend_LE", condition=tx_bytes != 0)
 
             self.state.memory.store(tx_bytes, count, endness="Iend_LE", condition=tx_bytes != 0)
 
         # TODO: transmit failure
-        return self.state.solver.BVV(0, self.state.arch.bits)
+        return claripy.BVV(0, self.state.arch.bits)

angr/procedures/definitions/__init__.py

@@ -1,4 +1,5 @@
 # pylint:disable=arguments-renamed,global-statement
+from __future__ import annotations
 import copy
 import os
 import logging
@@ -25,8 +26,8 @@ if TYPE_CHECKING:
 
 
 l = logging.getLogger(name=__name__)
-SIM_LIBRARIES: dict[str, "SimLibrary"] = {}
-SIM_TYPE_COLLECTIONS: dict[str, "SimTypeCollection"] = {}
+SIM_LIBRARIES: dict[str, SimLibrary] = {}
+SIM_TYPE_COLLECTIONS: dict[str, SimTypeCollection] = {}
 
 
 class SimTypeCollection:
@@ -36,14 +37,14 @@ class SimTypeCollection:
 
     def __init__(self):
         self.names: list[str] | None = None
-        self.types: dict[str, "SimType"] = {}
+        self.types: dict[str, SimType] = {}
 
     def set_names(self, *names):
         self.names = names
         for name in names:
             SIM_TYPE_COLLECTIONS[name] = self
 
-    def add(self, name: str, t: "SimType") -> None:
+    def add(self, name: str, t: SimType) -> None:
         """
         Add a type to the collection.
 
@@ -53,7 +54,7 @@ class SimTypeCollection:
 
         self.types[name] = t
 
-    def get(self, name: str, bottom_on_missing: bool = False) -> "SimType":
+    def get(self, name: str, bottom_on_missing: bool = False) -> SimType:
         """
         Get a SimType object from the collection as identified by the name.
 
@@ -273,8 +274,7 @@ class SimLibrary:
             proc = copy.deepcopy(self.procedures[name])
             self._apply_metadata(proc, arch)
             return proc
-        else:
-            return self.get_stub(name, arch)
+        return self.get_stub(name, arch)
 
     def get_stub(self, name, arch):
         """
@@ -470,7 +470,7 @@ class SimSyscallLibrary(SimLibrary):
         super().__init__()
         self.syscall_number_mapping: dict[str, dict[int, str]] = defaultdict(dict)  # keyed by abi
         self.syscall_name_mapping: dict[str, dict[str, int]] = defaultdict(dict)  # keyed by abi
-        self.default_cc_mapping: dict[str, type["SimCCSyscall"]] = {}  # keyed by abi
+        self.default_cc_mapping: dict[str, type[SimCCSyscall]] = {}  # keyed by abi
         self.syscall_prototypes: dict[str, dict[str, SimTypeFunction]] = defaultdict(dict)  # keyed by abi
         self.fallback_proc = stub_syscall
 
@@ -743,8 +743,7 @@ def load_win32api_definitions():
         for _ in autoimport.auto_import_modules(
             "angr.procedures.definitions",
             _DEFINITIONS_BASEDIR,
-            filter_func=lambda module_name: module_name.startswith("win32_")
-            or module_name.startswith("wdk_")
+            filter_func=lambda module_name: module_name.startswith(("win32_", "wdk_"))
             or module_name in {"ntoskrnl", "ntdll", "user32"},
         ):
             pass