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

angr/project.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 import os
 import types
@@ -139,7 +140,7 @@ class Project:
             self.filename = None
             self.loader = cle.Loader(thing, **load_options)
         elif not isinstance(thing, (str, Path)) or not os.path.exists(thing) or not os.path.isfile(thing):
-            raise Exception("Not a valid binary file: %s" % repr(thing))
+            raise Exception(f"Not a valid binary file: {thing!r}")
         else:
             # use angr's loader, provided by cle
             l.info("Loading binary %s", thing)
@@ -202,10 +203,9 @@ class Project:
             )
             self.selfmodifying_code = bool(support_selfmodifying_code)
 
-        if self.selfmodifying_code:
-            if self._translation_cache is True:
-                self._translation_cache = False
-                l.warning("Disabling IRSB translation cache because support for self-modifying code is enabled.")
+        if self.selfmodifying_code and self._translation_cache is True:
+            self._translation_cache = False
+            l.warning("Disabling IRSB translation cache because support for self-modifying code is enabled.")
 
         self.entry = self.loader.main_object.entry
         self.storage = defaultdict(list)
@@ -248,7 +248,7 @@ class Project:
             # If we execute a Java archive that includes native JNI libraries,
             # we need to use the arch of the native simos for all (native) sim
             # procedures.
-            sim_proc_arch = getattr(self.simos, "native_arch")
+            sim_proc_arch = self.simos.native_arch
         else:
             sim_proc_arch = self.arch
         for obj in self.loader.initial_load_objects:
@@ -258,14 +258,14 @@ class Project:
         self.simos.configure_project()
 
     @property
-    def analyses(self) -> "AnalysesHubWithDefault":
+    def analyses(self) -> AnalysesHubWithDefault:
         result = self._analyses
         if result is None:
             raise ValueError("Cannot access analyses this early in project lifecycle")
         return result
 
     @analyses.setter
-    def analyses(self, v: "AnalysesHubWithDefault"):
+    def analyses(self, v: AnalysesHubWithDefault):
         self._analyses = v
 
     def _initialize_analyses_hub(self):
@@ -428,11 +428,7 @@ class Project:
         for lib in hinted_libs:
             if SIM_LIBRARIES[lib].has_implementation(f.name):
                 l.debug("Found implementation for %s in %s", f, lib)
-                if f.resolvedby:
-                    hook_at = f.resolvedby.rebased_addr
-                else:
-                    # ????
-                    hook_at = f.relative_addr
+                hook_at = f.resolvedby.rebased_addr if f.resolvedby else f.relative_addr  # ????
                 self.hook_symbol(hook_at, (SIM_LIBRARIES[lib].get(f.name, self.arch)))
                 return True
 
@@ -453,7 +449,7 @@ class Project:
 
     @staticmethod
     def _addr_to_str(addr):
-        return "%s" % repr(addr) if isinstance(addr, SootAddressDescriptor) else "%#x" % addr
+        return f"{addr!r}" if isinstance(addr, SootAddressDescriptor) else f"{addr:#x}"
 
     #
     # Public methods
@@ -505,12 +501,12 @@ class Project:
                 l.warning(
                     "Address is already hooked, during hook(%s, %s). Not re-hooking.", self._addr_to_str(addr), hook
                 )
-                return
+                return None
             else:
                 l.warning("Address is already hooked, during hook(%s, %s). Re-hooking.", self._addr_to_str(addr), hook)
 
         if isinstance(hook, type):
-            raise TypeError("Please instanciate your SimProcedure before hooking with it")
+            raise TypeError("Please instantiate your SimProcedure before hooking with it")
 
         if callable(hook):
             hook = SIM_PROCEDURES["stubs"]["UserHook"](user_func=hook, length=length, **kwargs)
@@ -524,6 +520,7 @@ class Project:
         #    l.error("Consider also using angr.SIM_LIBRARIES instead of angr.SIM_PROCEDURES or angr.procedures.")
 
         self._sim_procedures[addr] = hook
+        return None
 
     def is_hooked(self, addr) -> bool:
         """
@@ -709,10 +706,7 @@ class Project:
         simulation manager.
         """
 
-        if args:
-            state = args[0]
-        else:
-            state = self.factory.full_init_state(**kwargs)
+        state = args[0] if args else self.factory.full_init_state(**kwargs)
 
         pg = self.factory.simulation_manager(state)
         self._executing = True
@@ -751,7 +745,7 @@ class Project:
             self.store_function, self.load_function = None, None
             # ignore analyses. we re-initialize analyses when restoring from pickling so that we do not lose any newly
             # added analyses classes
-            d = {
+            return {
                 k: v
                 for k, v in self.__dict__.items()
                 if k
@@ -759,7 +753,6 @@ class Project:
                     "analyses",
                 }
             }
-            return d
         finally:
             self.store_function, self.load_function = store_func, load_func
 

angr/protos/__init__.py

@@ -5,6 +5,7 @@
 #
 # Then you need to manually fix all _pb2 imports to be relative because of this unresolved issue:
 # https://github.com/protocolbuffers/protobuf/issues/1491
+from __future__ import annotations
 
 from . import primitives_pb2
 from . import function_pb2

angr/serializable.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class Serializable:
     """
     The base class of all protobuf-serializable classes in angr.
@@ -13,7 +16,7 @@ class Serializable:
         :return:    The correct cmessage object.
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def serialize_to_cmessage(self):
         """
@@ -23,7 +26,7 @@ class Serializable:
         :rtype:     protobuf.cmessage
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def serialize(self):
         """
@@ -45,7 +48,7 @@ class Serializable:
         :rtype:         cls
         """
 
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @classmethod
     def parse(cls, s, **kwargs):

angr/sim_manager.py

@@ -263,11 +263,11 @@ class SimulationManager:
         if not isinstance(tech, ExplorationTechnique):
             raise SimulationManagerError
 
-        def _is_overriden(name):
+        def _is_overridden(name):
             return getattr(tech, name).__code__ is not getattr(ExplorationTechnique, name).__code__
 
-        overriden = filter(_is_overriden, ("step", "filter", "selector", "step_state", "successors"))
-        hooks = {name: getattr(tech, name) for name in overriden}
+        overridden = filter(_is_overridden, ("step", "filter", "selector", "step_state", "successors"))
+        hooks = {name: getattr(tech, name) for name in overridden}
         HookSet.remove_hooks(self, **hooks)
 
         self._techniques.remove(tech)
@@ -323,7 +323,9 @@ class SimulationManager:
             if isinstance(t, Veritesting):
                 deviation_filter_saved = t.options.get("deviation_filter", None)
                 if deviation_filter_saved is not None:
-                    t.options["deviation_filter"] = lambda s: tech.find(s) or tech.avoid(s) or deviation_filter_saved(s)
+                    t.options["deviation_filter"] = (
+                        lambda s, dfs=deviation_filter_saved: tech.find(s) or tech.avoid(s) or dfs(s)
+                    )
                 else:
                     t.options["deviation_filter"] = lambda s: tech.find(s) or tech.avoid(s)
                 break
@@ -357,7 +359,7 @@ class SimulationManager:
         :return:            The simulation manager, for chaining.
         :rtype:             SimulationManager
         """
-        for _ in itertools.count() if n is None else range(0, n):
+        for _ in itertools.count() if n is None else range(n):
             if not self.complete() and self._stashes[stash]:
                 self.step(stash=stash, **kwargs)
                 if not (until and until(self)):
@@ -371,9 +373,9 @@ class SimulationManager:
         """
         if not self._techniques:
             return False
-        if not any(tech._is_overriden("complete") for tech in self._techniques):
+        if not any(tech._is_overridden("complete") for tech in self._techniques):
             return False
-        return self.completion_mode(tech.complete(self) for tech in self._techniques if tech._is_overriden("complete"))
+        return self.completion_mode(tech.complete(self) for tech in self._techniques if tech._is_overridden("complete"))
 
     def step(
         self,
@@ -779,7 +781,7 @@ class SimulationManager:
         :param merge_func:  If provided, instead of using state.merge, call this function with
                             the states as the argument. Should return the merged state.
         :param merge_key:   If provided, should be a function that takes a state and returns a key that will compare
-                            equal for all states that are allowed to be merged together, as a first aproximation.
+                            equal for all states that are allowed to be merged together, as a first approximation.
                             By default: uses PC, callstack, and open file descriptors.
         :param prune:       Whether to prune the stash prior to merging it
 
@@ -796,7 +798,7 @@ class SimulationManager:
         merge_groups = []
         while to_merge:
             base_key = merge_key(to_merge[0])
-            g, to_merge = self._filter_states(lambda s: base_key == merge_key(s), to_merge)
+            g, to_merge = self._filter_states(lambda s, base_key=base_key: base_key == merge_key(s), to_merge)
             if len(g) <= 1:
                 not_to_merge.extend(g)
             else:
@@ -832,16 +834,15 @@ class SimulationManager:
     def _fetch_states(self, stash):
         if stash in self._stashes:
             return self._stashes[stash]
-        elif stash == SimulationManager.ALL:
+        if stash == SimulationManager.ALL:
             return list(itertools.chain.from_iterable(self._stashes.values()))
-        elif stash == "mp_" + SimulationManager.ALL:
+        if stash == "mp_" + SimulationManager.ALL:
             return mulpyplexer.MP(self._fetch_states(stash=SimulationManager.ALL))
-        elif stash.startswith("mp_"):
+        if stash.startswith("mp_"):
             return mulpyplexer.MP(self._stashes.get(stash[3:], []))
-        elif stash.startswith("one_"):
+        if stash.startswith("one_"):
             return self._stashes.get(stash[4:], [None])[0]
-        else:
-            raise AttributeError("No such stash: %s" % stash)
+        raise AttributeError(f"No such stash: {stash}")
 
     def _filter_states(self, filter_func, states):  # pylint:disable=no-self-use
         match, nomatch = [], []
@@ -889,8 +890,7 @@ class SimulationManager:
         if len(others):
             others.append(m)
             return self._merge_states(others)
-        else:
-            return m
+        return m
 
     #
     #   ...
@@ -964,7 +964,7 @@ class ErrorRecord:
         raise self.error.with_traceback(self.traceback)
 
     def __repr__(self):
-        return '<State errored with "%s">' % self.error
+        return f'<State errored with "{self.error}">'
 
     def __eq__(self, other):
         return self is other or self.state is other

angr/sim_options.py

@@ -1,5 +1,6 @@
 # This module contains the analysis options.
 # All variables with names of all caps will be registered as a state option to SimStateOptions.
+from __future__ import annotations
 
 import string
 from .sim_state_options import SimStateOptions
@@ -44,12 +45,9 @@ NO_SYMBOLIC_JUMP_RESOLUTION = "NO_SYMBOLIC_JUMP_RESOLUTION"
 # This option prevents angr from doing hundreds of constraint solves when it hits a symbolic syscall
 NO_SYMBOLIC_SYSCALL_RESOLUTION = "NO_SYMBOLIC_SYSCALL_RESOLUTION"
 
-# The absense of this option causes the analysis to avoid reasoning about most symbolic values.
+# The absence of this option causes the analysis to avoid reasoning about most symbolic values.
 SYMBOLIC = "SYMBOLIC"
 
-# This variable causes claripy to use a string solver (CVC4)
-STRINGS_ANALYSIS = "STRINGS_ANALYSIS"
-
 # Generate symbolic values for non-existent values. The absence of this option causes Unconstrained() to return default
 # concrete values (like 0)
 SYMBOLIC_INITIAL_VALUES = "SYMBOLIC_INITIAL_VALUES"
@@ -73,7 +71,7 @@ CONCRETIZE_SYMBOLIC_FILE_READ_SIZES = "CONCRETIZE_SYMBOLIC_FILE_READ_SIZES"
 FILES_HAVE_EOF = "FILES_HAVE_EOF"
 UNKNOWN_FILES_HAVE_EOF = FILES_HAVE_EOF
 
-# Attempting to open an unkown file will result in creating it with a symbolic length
+# Attempting to open an unknown file will result in creating it with a symbolic length
 ALL_FILES_EXIST = "ALL_FILES_EXIST"
 
 # Unknown files might or might not exist
@@ -315,7 +313,7 @@ CGC_ENFORCE_FD = "CGC_ENFORCE_FD"
 CGC_NON_BLOCKING_FDS = "CGC_NON_BLOCKING_FDS"
 
 # Allows memory breakpoints to get more accurate sizes in case of reading large chunks
-# Sacrafice performance for more fine tune memory read size
+# Sacrifice performance for more fine tune memory read size
 MEMORY_CHUNK_INDIVIDUAL_READS = "MEMORY_CHUNK_INDIVIDUAL_READS"
 
 # Synchronize memory mapping reported by angr with the concrete process.
@@ -337,7 +335,7 @@ JAVA_TRACK_ATTRIBUTES = "JAVA_TRACK_ATTRIBUTES"
 
 _g = globals().copy()
 for k, v in _g.items():
-    if all([char in string.ascii_uppercase + "_" + string.digits for char in k]) and type(v) is str:
+    if all(char in string.ascii_uppercase + "_" + string.digits for char in k) and type(v) is str:
         if k in (
             "UNKNOWN_FILES_HAVE_EOF",
             "CGC_ZERO_FILL_UNCONSTRAINED_MEMORY",

angr/sim_procedure.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import inspect
 import copy
 import itertools
@@ -99,7 +100,7 @@ class SimProcedure:
 
     """
 
-    state: "SimState"
+    state: SimState
 
     def __init__(
         self,
@@ -168,7 +169,7 @@ class SimProcedure:
         self.arg_session: None | ArgSession | int = None
 
     def __repr__(self):
-        return "<SimProcedure %s%s%s%s%s>" % self._describe_me()
+        return "<SimProcedure {}{}{}{}{}>".format(*self._describe_me())
 
     def _describe_me(self):
         """
@@ -176,7 +177,7 @@ class SimProcedure:
         """
         return (
             self.display_name,
-            " (cont: %s)" % self.run_func if self.is_continuation else "",
+            f" (cont: {self.run_func})" if self.is_continuation else "",
             " (syscall)" if self.is_syscall else "",
             " (inline)" if not self.use_state_arguments else "",
             " (stub)" if self.is_stub else "",
@@ -206,8 +207,8 @@ class SimProcedure:
                 )(self.arch)
             else:
                 raise SimProcedureError(
-                    "There is no default calling convention for architecture %s."
-                    " You must specify a calling convention." % self.arch.name
+                    f"There is no default calling convention for architecture {self.arch.name}."
+                    " You must specify a calling convention."
                 )
         if self.prototype._arch is None:
             self.prototype = self.prototype.with_arch(self.arch)
@@ -274,7 +275,7 @@ class SimProcedure:
                     inst.arg_session = 0
 
             # run it
-            l.debug("Executing %s%s%s%s%s with %s, %s", *(inst._describe_me() + (sim_args, inst.kwargs)))
+            l.debug("Executing %s%s%s%s%s with %s, %s", *((*inst._describe_me(), sim_args, inst.kwargs)))
             r = getattr(inst, inst.run_func)(*sim_args, **inst.kwargs)
 
         state._inspect(
@@ -327,7 +328,7 @@ class SimProcedure:
         """
         Implement the actual procedure here!
         """
-        raise SimProcedureError("%s does not implement a run() method" % self.__class__.__name__)
+        raise SimProcedureError(f"{self.__class__.__name__} does not implement a run() method")
 
     def static_exits(self, blocks, **kwargs):  # pylint: disable=unused-argument
         """
@@ -340,7 +341,7 @@ class SimProcedure:
         """
 
         if self.ADDS_EXITS:
-            raise SimProcedureError("static_exits() is not implemented for %s" % self)
+            raise SimProcedureError(f"static_exits() is not implemented for {self}")
 
         # This SimProcedure does not add any new exit
         return []
@@ -410,7 +411,7 @@ class SimProcedure:
         :param arguments:       Any additional positional args will be used as arguments to the
                                 procedure call
         :param sim_kwargs:      Any additional keyword args will be passed as sim_kwargs to the
-                                procedure construtor
+                                procedure constructor
         """
         e_args = [claripy.BVV(a, self.state.arch.bits) if isinstance(a, int) else a for a in arguments]
         p = procedure(project=self.project, **kwargs)
@@ -498,7 +499,7 @@ class SimProcedure:
 
         call_state = self.state.copy()
         ret_addr = self.make_continuation(continue_at)
-        saved_local_vars = list(zip(self.local_vars, map(lambda name: getattr(self, name), self.local_vars)))
+        saved_local_vars = list(zip(self.local_vars, (getattr(self, name) for name in self.local_vars)))
         simcallstack_entry = (
             self.state.regs.sp if hasattr(self.state.regs, "sp") else None,
             self.arguments,

angr/sim_state.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import functools
 import itertools
 import contextlib
@@ -20,14 +21,13 @@ from .sim_state_options import SimStateOptions
 from .state_plugins import SimStatePlugin
 
 
-def arch_overrideable(f):
+def arch_overridable(f):
     @functools.wraps(f)
     def wrapped_f(self, *args, **kwargs):
         if hasattr(self.arch, f.__name__):
             arch_f = getattr(self.arch, f.__name__)
             return arch_f(self, *args, **kwargs)
-        else:
-            return f(self, *args, **kwargs)
+        return f(self, *args, **kwargs)
 
     return wrapped_f
 
@@ -63,17 +63,17 @@ class SimState(PluginHub):
     """
 
     # Type Annotations for default plugins to allow type inference
-    solver: "SimSolver"
-    posix: "SimSystemPosix"
-    registers: "DefaultMemory"
-    regs: "SimRegNameView"
-    memory: "DefaultMemory"
-    callstack: "CallStack"
-    mem: "SimMemView"
-    history: "SimStateHistory"
-    inspect: "SimInspector"
-    jni_references: "SimStateJNIReferences"
-    scratch: "SimStateScratch"
+    solver: SimSolver
+    posix: SimSystemPosix
+    registers: DefaultMemory
+    regs: SimRegNameView
+    memory: DefaultMemory
+    callstack: CallStack
+    mem: SimMemView
+    history: SimStateHistory
+    inspect: SimInspector
+    jni_references: SimStateJNIReferences
+    scratch: SimStateScratch
 
     def __init__(
         self,
@@ -260,7 +260,7 @@ class SimState(PluginHub):
     def __getstate__(self):
         # Don't pickle attributes for plugins. These will be pickled
         # through self._active_plugins.
-        s = {k: v for k, v in self.__dict__.items() if k not in self._active_plugins.keys()}
+        s = {k: v for k, v in self.__dict__.items() if k not in self._active_plugins}
         s["_active_plugins"] = {k: v for k, v in s["_active_plugins"].items() if k not in ("inspect", "regs", "mem")}
         return s
 
@@ -280,14 +280,11 @@ class SimState(PluginHub):
     def __repr__(self):
         try:
             addr = self.addr
-            if type(addr) is int:
-                ip_str = "%#x" % addr
-            else:
-                ip_str = repr(addr)
+            ip_str = f"{addr:#x}" if type(addr) is int else repr(addr)
         except (SimValueError, SimSolverModeError):
             ip_str = repr(self.regs.ip)
 
-        return "<SimState @ %s>" % ip_str
+        return f"<SimState @ {ip_str}>"
 
     def __setattr__(self, key, value):
         if key == "options":
@@ -303,7 +300,7 @@ class SimState(PluginHub):
         elif isinstance(v, SimStateOptions):
             super().__setattr__("options", v)
         else:
-            raise SimStateError("Unsupported type '%s' in SimState.options.setter()." % type(v))
+            raise SimStateError(f"Unsupported type '{type(v)}' in SimState.options.setter().")
 
     #
     # Easier access to some properties
@@ -382,8 +379,7 @@ class SimState(PluginHub):
     def arch(self) -> Arch:
         if self._is_java_jni_project:
             return self._arch["soot"] if self.ip_is_soot_addr else self._arch["vex"]
-        else:
-            return self._arch
+        return self._arch
 
     @arch.setter
     def arch(self, v):
@@ -400,9 +396,8 @@ class SimState(PluginHub):
     T = TypeVar("T")
 
     def _inspect_getattr(self, attr: str, default_value: T):
-        if self.supports_inspect:
-            if hasattr(self.inspect, attr):
-                return getattr(self.inspect, attr)
+        if self.supports_inspect and hasattr(self.inspect, attr):
+            return getattr(self.inspect, attr)
 
         return default_value
 
@@ -455,8 +450,7 @@ class SimState(PluginHub):
         """
         if self._is_java_jni_project:
             return self.get_plugin("memory_soot")
-        else:
-            return self.get_plugin("memory")
+        return self.get_plugin("memory")
 
     @property
     def javavm_registers(self):
@@ -468,8 +462,7 @@ class SimState(PluginHub):
         """
         if self._is_java_jni_project:
             return self.get_plugin("registers_soot")
-        else:
-            return self.get_plugin("registers")
+        return self.get_plugin("registers")
 
     #
     # Constraint pass-throughs
@@ -491,10 +484,7 @@ class SimState(PluginHub):
             raise Exception("Tuple or list passed to add_constraints!")
 
         if o.TRACK_CONSTRAINTS in self.options and len(args) > 0:
-            if o.SIMPLIFY_CONSTRAINTS in self.options:
-                constraints = [self.simplify(a) for a in args]
-            else:
-                constraints = args
+            constraints = [self.simplify(a) for a in args] if o.SIMPLIFY_CONSTRAINTS in self.options else args
 
             self._inspect("constraints", BP_BEFORE, added_constraints=constraints)
             constraints = self._inspect_getattr("added_constraints", constraints)
@@ -580,8 +570,7 @@ class SimState(PluginHub):
                     return False
 
             return self._satisfiable
-        else:
-            return self.solver.satisfiable(**kwargs)
+        return self.solver.satisfiable(**kwargs)
 
     def downsize(self):
         """
@@ -680,7 +669,7 @@ class SimState(PluginHub):
         common_ancestor_history = kwargs.pop("common_ancestor_history", None)
 
         if len(kwargs) != 0:
-            raise ValueError("invalid arguments: %s" % kwargs.keys())
+            raise ValueError(f"invalid arguments: {kwargs.keys()}")
 
         if merge_conditions is None:
             # TODO: maybe make the length of this smaller? Maybe: math.ceil(math.log(len(others)+1, 2))
@@ -709,8 +698,8 @@ class SimState(PluginHub):
 
         # plugins
         for p in all_plugins:
-            our_plugin = merged.plugins[p] if p in merged.plugins else None
-            their_plugins = [(pl.plugins[p] if p in pl.plugins else None) for pl in others]
+            our_plugin = merged.plugins.get(p, None)
+            their_plugins = [(pl.plugins.get(p, None)) for pl in others]
 
             plugin_classes = ({our_plugin.__class__} | {pl.__class__ for pl in their_plugins}) - {None.__class__}
             if len(plugin_classes) != 1:
@@ -798,7 +787,7 @@ class SimState(PluginHub):
     ### Stack operation helpers ###
     ###############################
 
-    @arch_overrideable
+    @arch_overridable
     def stack_push(self, thing):
         """
         Push 'thing' to the stack, writing the thing to memory and adjusting the stack pointer.
@@ -808,7 +797,7 @@ class SimState(PluginHub):
         self.regs.sp = sp
         return self.memory.store(sp, thing, endness=self.arch.memory_endness, size=self.arch.bytes)
 
-    @arch_overrideable
+    @arch_overridable
     def stack_pop(self):
         """
         Pops from the stack and returns the popped thing. The length will be the architecture word size.
@@ -817,7 +806,7 @@ class SimState(PluginHub):
         self.regs.sp = sp - self.arch.stack_change
         return self.memory.load(sp, self.arch.bytes, endness=self.arch.memory_endness)
 
-    @arch_overrideable
+    @arch_overridable
     def stack_read(self, offset, length, bp=False):
         """
         Reads length bytes, at an offset into the stack.
@@ -845,7 +834,7 @@ class SimState(PluginHub):
         return v
 
     # This handles the preparation of concrete function launches from abstract functions.
-    @arch_overrideable
+    @arch_overridable
     def prepare_callsite(self, retval, args, cc="wtf"):
         # TODO
         pass
@@ -861,7 +850,7 @@ class SimState(PluginHub):
         strings = []
         for stack_value in stack_values:
             if self.solver.symbolic(stack_value):
-                concretized_value = "SYMBOLIC - %s" % repr(stack_value)
+                concretized_value = f"SYMBOLIC - {stack_value!r}"
             else:
                 if len(self.solver.eval_upto(stack_value, 2)) == 2:
                     concretized_value = repr(stack_value)
@@ -888,7 +877,7 @@ class SimState(PluginHub):
         else:
             sp_value = sp if sp is not None else self.solver.eval(sp_sim)
             if self.solver.symbolic(bp_sim):
-                result = "SP = 0x%08x, BP is symbolic\n" % (sp_value)
+                result = f"SP = 0x{sp_value:08x}, BP is symbolic\n"
                 bp_value = None
             else:
                 bp_value = self.solver.eval(bp_sim)
@@ -945,9 +934,8 @@ class SimState(PluginHub):
             new_state.add_constraints(new_state.regs.ip % 2 == 1, new_state.regs.ip % 2 != 0)
             return new_state.satisfiable()
 
-        else:
-            concrete_ip = self.solver.eval(self.regs.ip)
-            return concrete_ip % 2 == 1
+        concrete_ip = self.solver.eval(self.regs.ip)
+        return concrete_ip % 2 == 1
 
     #
     # Some pretty fancy global condition stuff!
@@ -970,18 +958,16 @@ class SimState(PluginHub):
     def _adjust_condition(self, c):
         if self._global_condition is None:
             return c
-        elif c is None:
+        if c is None:
             return self._global_condition
-        else:
-            return claripy.And(self._global_condition, c)
+        return claripy.And(self._global_condition, c)
 
     def _adjust_condition_list(self, conditions):
         if self._global_condition is None:
             return conditions
-        elif len(conditions) == 0:
+        if len(conditions) == 0:
             return conditions.__class__((self._global_condition,))
-        else:
-            return conditions.__class__((self._adjust_condition(claripy.And(*conditions)),))
+        return conditions.__class__((self._adjust_condition(claripy.And(*conditions)),))
 
 
 default_state_plugin_preset = PluginPreset()