Refactor strings templating, use f strings

Author: smarbal

src/sploitkit/base/commands/general.py

@@ -55,7 +55,7 @@ def run(self, text):
             t = BorderlessTable(data, "Matching modules")
             print_formatted_text(t.table)
             n = len(data) - 2
-            self.logger.info("{} match{} found".format(n, ["", "es"][n > 0]))
+            self.logger.info(f"{n} match{["", "es"][n > 0]} found")
 
 
 class Show(Command):

src/sploitkit/base/commands/project.py

@@ -45,22 +45,22 @@ class Archive(ProjectRootCommand):
     def run(self, project):
         projpath = Path(self.workspace).joinpath(project)
         folder = ProjectPath(projpath)
-        self.logger.debug("Archiving project '{}'...".format(project))
+        self.logger.debug(f"Archiving project '{project}'...")
         ask = self.console.config.option("ENCRYPT_PROJECT").value
         try:
             folder.archive(ask=ask)
-            self.logger.success("'{}' archived".format(project))
+            self.logger.success(f"'{project}' archived")
         except OSError as e:
-            logger.error(str(e))
-            self.logger.failure("'{}' not archived".format(project))
+            self.logger.error(str(e))
+            self.logger.failure(f"'{project}' not archived")
 
 
 class Delete(ProjectRootCommand):
     """ Delete a project """
     def run(self, project):
-        self.logger.debug("Deleting project '{}'...".format(project))
+        self.logger.debug(f"Deleting project '{project}'...")
         self.workspace.joinpath(project).remove()
-        self.logger.success("'{}' deleted".format(project))
+        self.logger.success(f"'{project}' deleted")
 
 
 class Load(ProjectRootCommand):
@@ -70,16 +70,16 @@ def complete_values(self):
         return [x.stem for x in self.workspace.iterfiles(".zip")]
 
     def run(self, project):
-        self.logger.debug("Loading archive '{}'...".format(project + ".zip"))
+        self.logger.debug(f"Loading archive '{project+ ".zip"}'...")
         projpath = Path(self.workspace).joinpath(project)
         archive = ProjectPath(projpath.with_suffix(".zip"))
         ask = self.console.config.option("ENCRYPT_PROJECT").value
         try:
             archive.load(ask=ask)
-            self.logger.success("'{}' loaded".format(project))
+            self.logger.success(f"'{project}' loaded")
         except Exception as e:
-            logger.error("Bad password" if "error -3" in str(e) else str(e))
-            self.logger.failure("'{}' not loaded".format(project))
+            self.logger.error("Bad password" if "error -3" in str(e) else str(e))
+            self.logger.failure(f"'{project}' not loaded")
 
     def validate(self, project):
         if project not in self.complete_values():
@@ -100,9 +100,9 @@ def run(self, project):
                                                            "do you want to load the archive instead ?"):
             loader.run(project)
         if not p.exists():
-            self.logger.debug("Creating project '{}'...".format(project))
+            self.logger.debug(f"Creating project '{project}'...")
             p.mkdir()
-            self.logger.success("'{}' created".format(project))
+            self.logger.success(f"'{project}' created")
         ProjectConsole(self.console, project).start()
         self.config['WORKSPACE'] = str(Path(self.config['WORKSPACE']).parent)
 

src/sploitkit/base/commands/recording.py

@@ -14,7 +14,7 @@ class RecordStatus(Command):
     values = ["status"]
 
     def run(self, status):
-        self.logger.info("Recording is {}".format(["disabled", "enabled"][self.recorder.enabled]))
+        self.logger.info(f"Recording is {["disabled", "enabled"][self.recorder.enabled]}")
 
 
 # ------------------------------ ROOT-LEVEL COMMANDS ---------------------------
@@ -38,7 +38,7 @@ def run(self, key, rcfile=None):
         elif key == "stop":
             self.recorder.stop()
         elif key == "status":
-            self.logger.info("Recording is {}".format(["disabled", "enabled"][self.recorder.enabled]))
+            self.logger.info(f"Recording is {["disabled", "enabled"][self.recorder.enabled]}")
 
     def validate(self, key, rcfile=None):
         if key == "start":
@@ -57,6 +57,6 @@ def complete_values(self, key=None):
         return [x.name for x in Path(self.workspace).iterfiles(".rc")]
 
     def run(self, rcfile):
-        self.logger.debug("Replaying commands from file '{}'...".format(rcfile))
+        self.logger.debug(f"Replaying commands from file '{rcfile}'...")
         self.console.replay(rcfile)
 

src/sploitkit/base/commands/utils.py

@@ -121,7 +121,7 @@ class State(DebugCommand):
     """ Display console's shared state """
     def run(self):
         for k, v in self.console.state.items():
-            print_formatted_text("\n{}:".format(k))
+            print_formatted_text(f"\n{k}:")
             v = v or ""
             if len(v) == 0:
                 continue

src/sploitkit/base/models/organization.py

@@ -23,7 +23,7 @@ class Meta:
 
     @property
     def fullname(self):
-        return "{} {} ({})".format(self.firstname, self.lastname, self.role)
+        return f"{self.firstname} {self.lastname} ({self.role})"
 
 
 class EmployeeUnit(BaseModel):

src/sploitkit/core/command.py

@@ -51,7 +51,7 @@ def __init__(self, *args):
             s += " ["
             i = []
             for a, d in zip(args[len(args)-len(defs):], defs):
-                i.append("{}={}".format(a, d) if d is not None else a)
+                i.append(f"{a}={d}" if d is not None else a)
             s += " ".join(i) + "]"
         self.signature = s
         self.args, self.defaults = args, defs
@@ -182,7 +182,7 @@ def get_help(cls, *levels, **kwargs):
                     continue
                 d.append([n, getattr(c, "description", "")])
             if len(d) > 1:
-                t = BorderlessTable(d, "{} commands".format(l.capitalize()))
+                t = BorderlessTable(d, f"{l.capitalize()} commands")
                 s += t.table + "\n"
                 i += 1
         return "\n" + s.strip() + "\n" if i > 0 else ""
@@ -200,13 +200,13 @@ def register_command(cls, subcls):
                 Command.commands[l][subcls.name] = subcls
             for alias in subcls.aliases:
                 Command.commands[l][alias] = subcls
-                logger.detail("Registered command alias '{}'".format(alias))
+                logger.detail(f"Registered command alias '{alias}'")
 
     @classmethod
     def set_style(cls, style):
         """ Set the style of command name. """
         if style not in COMMAND_STYLES:
-            raise ValueError("Command style must be one of the followings: [{}]".format("|".join(COMMAND_STYLES)))
+            raise ValueError(f"Command style must be one of the followings: [{'|'.join(COMMAND_STYLES)}]")
         MetaCommand.style = style
 
     @classmethod
@@ -234,7 +234,7 @@ def unregister_command(cls, subcls):
         for l in levels:
             if len(Command.commands[l]) == 0:
                 del Command.commands[l]
-        logger.detail("Unregistered command '{}/{}'".format(l, n))
+        logger.detail(f"Unregistered command '{l}/{n}'")
 
     @classmethod
     def unregister_commands(cls, *identifiers):
@@ -248,7 +248,7 @@ def unregister_commands(cls, *identifiers):
             # apply deletions
             if n is None:
                 if f not in cls._functionalities:
-                    raise ValueError("Unknown functionality {}".format(f))
+                    raise ValueError(f"Unknown functionality {f}")
                 p = Path(__file__).parent.joinpath("../base/commands/" + f + ".py").resolve()
                 for c in PythonPath(str(p)).get_classes(Command):
                     Command.unregister_command(c)

src/sploitkit/core/components/config.py

@@ -40,7 +40,7 @@ def __delitem__(self, key):
                 self.console.reset()
             except AttributeError as err:
                 pass
-        l.debug("{} => null".format(key.name))
+        l.debug(f"{key.name} => null")
 
     def __getitem__(self, key):
         """ Custom method for getting an item, returning the original value from the current Config instance or, if the
@@ -72,7 +72,7 @@ def __setitem__(self, key, value):
         key = self._setkey(key, value)
         if not force and key.old_value == key.value:
             try:
-                l.debug("{} unchanged".format(key.name))
+                l.debug(f"{key.name} unchanged")
             except AttributeError:
                 pass
             return  # stop here if the final value is unchanged
@@ -83,7 +83,7 @@ def __setitem__(self, key, value):
                 self.console.reset()
             except AttributeError as err:
                 pass
-        l.success("{} => {}".format(key.name, value if force else key.value))
+        l.success(f"{key.name} => {value if force else key.value}")
 
     def __str__(self):
         """ Custom string method. """
@@ -107,20 +107,20 @@ def __str__(self):
 
     def __run_callback(self, key, name):
         """ Method for executing a callback and updating the current value with its return value if any. """
-        logger.detail("{} {} callback triggered".format(key, name))
+        logger.detail(f"{key} {name} callback triggered")
         retval = None
         if hasattr(self, "_last_error"):
             del self._last_error
         try:
-            retval = getattr(key, "{}_callback".format(name))()
+            retval = getattr(key, f"{name}_callback")()
         except Exception as e:
             self._last_error = e
             if True:#not isinstance(e, AttributeError):
                 raise
         if retval is not None:
             key.old_value = key.value
             if not key.validate(retval):
-                raise ValueError("Invalid value '{}'".format(retval))
+                raise ValueError(f"Invalid value '{retval}'")
             self._d[key.name] = (key, retval)
 
     def _getitem(self, key):
@@ -159,7 +159,7 @@ def _setkey(self, key, value):
         # then assign the new one if it is valid
         self._d[key.name] = (key, value)
         if value is not None and not key.validate(value):
-            raise ValueError("Invalid value '{}' for key '{}'".format(value, key.name))
+            raise ValueError(f"Invalid value '{value}' for key '{key.name}'")
         super(Config, self).__setitem__(key, value)
         return key
 
@@ -300,7 +300,7 @@ def __repr__(self):
 
     def __str__(self):
         """ Custom string method. """
-        return "<{}[{}]>".format(self.name, ["N", "Y"][self.required])
+        return f"<{self.name}[{["N", "Y"][self.required]}]>"
 
     def __set_func(self, func, name, default_func=None):
         """ Set a function, e.g. for manipulating option's value. """
@@ -309,7 +309,7 @@ def __set_func(self, func, name, default_func=None):
         if isinstance(func, type(lambda:0)):
             setattr(self, name, func.__get__(self, self.__class__))
         else:
-            raise Exception("Bad {} lambda".format(name))
+            raise Exception(f"Bad {name} lambda")
 
     def bind(self, parent):
         """ Register this instance as a key of the given Config or retrieve the already existing one. """
@@ -344,7 +344,7 @@ def input(self):
         if hasattr(self, "config"):
             return self.config[self]
         else:
-            raise Exception("Unbound option {}".format(self.name))
+            raise Exception(f"Unbound option {self.name}")
 
     @property
     def module(self):
@@ -368,7 +368,7 @@ def value(self):
         if value == getattr(self, "default", None):
             value = Config._g.get(self.name, value)
         if self.required and value is None:
-            raise ValueError("{} must be defined".format(self.name))
+            raise ValueError(f"{self.name} must be defined")
         try: # try to expand format variables using console's attributes
             kw = {}
             for n in re.findall(r'\{([a-z]+)\}', str(value)):
@@ -447,7 +447,7 @@ def __getattribute__(self, name):
                     return c.__getattribute__(name)
                 except AttributeError:
                     continue
-        raise AttributeError("'ProxyConfig' object has no attribute '{}'".format(name))
+        raise AttributeError(f"'ProxyConfig' object has no attribute '{name}'")
 
     def __getitem__(self, key):
         """ Get method for returning the first occurrence of a key among the list of Config instances. """

src/sploitkit/core/components/files.py

@@ -72,7 +72,7 @@ def get(self, locator, *args, **kwargs):
             with open(path, 'rb') as f:
                 self[locator] = f.read()
         else:
-            raise ValueError("Unsupported scheme '{}'".format(scheme))
+            raise ValueError(f"Unsupported scheme '{scheme}'")
 
     def page(self, *filenames):
         """ Page a list of files using Less. """

src/sploitkit/core/components/store.py

@@ -120,10 +120,10 @@ def snapshot(self, save=True):
         self.close()
         if save:
             self._last_snapshot += 1
-        s = "{}.snapshot{}".format(self.path, self._last_snapshot)
+        s = f"{self.path}.snapshot{self._last_snapshot}"
         copy(self.path, s) if save else copy(s, self.path)
         if not save:
-            remove("{}.snapshot{}".format(self.path, self._last_snapshot))
+            remove(f"{self.path}.snapshot{self._last_snapshot}")
             self._last_snapshot -= 1
         self.connect()
 

src/sploitkit/core/components/validator.py

@@ -30,7 +30,7 @@ def validate(self, document):
             try:
                 c._validate(*tokens[1:])
             except Exception as e:
-                m = "Command syntax: %s{}" % c.signature.format(cmd)
+                m = f"Command syntax: {c.signature.format(cmd)}" 
                 e = str(e)
                 if not e.startswith("validate() "):
                     m = m.format([" (" + e + ")", ""][len(e) == 0])