Adapted lazy imports

Author: dhondta

src/sploitkit/core/components/config.py

@@ -1,9 +1,4 @@
 # -*- coding: UTF-8 -*-
-import re
-from itertools import chain
-from termcolor import colored
-from tinyscript.helpers import is_function, BorderlessTable, Path
-
 from .logger import *
 
 
@@ -40,7 +35,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 +67,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 +78,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. """
@@ -94,33 +89,35 @@ def __str__(self):
                 continue
             r = ["N", "Y"][r]
             if v == "":
+                from tinyscript.helpers import colored
                 n, v, r = map(lambda s: colored(s, "red", attrs=['bold']), [n, v, r])
             data.append([n, v, r, d])
         if len(data) > 1:
+            from tinyscript.helpers import BorderlessTable
             try:
                 prefix = self.console.opt_prefix
             except AttributeError:
                 prefix = None
             return BorderlessTable(data).table if prefix is None else \
-                   BorderlessTable(data, "%s options" % prefix).table
+                   BorderlessTable(data, f"{prefix} options").table
         return ""
 
     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 +156,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
 
@@ -181,6 +178,7 @@ def items(self, fail=True):
 
     def keys(self, glob=False):
         """ Return string keys (like original dict). """
+        from itertools import chain
         l = [k for k in self._d.keys()]
         if glob:
             for k in chain(self._d.keys(), Config._g.keys()):
@@ -300,7 +298,7 @@ def __repr__(self):
 
     def __str__(self):
         """ Custom string method. """
-        return "<{}[{}]>".format(self.name, ["N", "Y"][self.required])
+        return f"<{self.name}[{'NY'[self.required]}]>"
 
     def __set_func(self, func, name, default_func=None):
         """ Set a function, e.g. for manipulating option's value. """
@@ -309,7 +307,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. """
@@ -325,6 +323,7 @@ def bind(self, parent):
     @property
     def choices(self):
         """ Pre- or lazy-computed list of choices. """
+        from tinyscript.helpers import is_function
         c = self._choices
         if not is_function(c):
             return c
@@ -344,7 +343,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,10 +367,12 @@ 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))
-        try: # try to expand format variables using console's attributes
+            raise ValueError(f"{self.name} must be defined")
+        # try to expand format variables using console's attributes
+        from re import findall
+        try:
             kw = {}
-            for n in re.findall(r'\{([a-z]+)\}', str(value)):
+            for n in findall(r'\{([a-z]+)\}', str(value)):
                 kw[n] = self.config.console.__dict__.get(n, "")
             try:
                 value = value.format(**kw)
@@ -381,6 +382,7 @@ def value(self):
             pass
         # expand and resolve paths
         if self.name.endswith("FOLDER") or self.name.endswith("WORKSPACE"):
+            from tinyscript.helpers import Path
             # this will ensure that every path is expanded
             value = str(Path(value, expand=True))
         # convert common formats to their basic types
@@ -447,7 +449,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

@@ -4,7 +4,7 @@
 from ftplib import FTP, FTP_TLS
 from shutil import which
 from subprocess import call, PIPE
-from tinyscript.helpers import b, ensure_str, txt_terminal_render, Path, TempPath
+from tinyscript.helpers import Path
 
 
 __all__ = ["FilesManager"]
@@ -42,7 +42,7 @@ def edit(self, filename):
         #FIXME: edit by calling the locator and manage its local file (e.g. for a URL, point to a temp folder)
         ted = self.console.config['TEXT_EDITOR']
         if which(ted) is None:
-            raise ValueError("'%s' does not exist or is not installed" % ted)
+            raise ValueError(f"'{ted}' does not exist or is not installed")
         p = Path(self.console.config['WORKSPACE']).joinpath(filename)
         if not p.exists():
             p.touch()
@@ -78,7 +78,7 @@ def page(self, *filenames):
         """ Page a list of files using Less. """
         tvw = self.console.config['TEXT_VIEWER']
         if which(tvw) is None:
-            raise ValueError("'%s' does not exist or is not installed" % tvw)
+            raise ValueError(f"'{tvw}' does not exist or is not installed")
         filenames = list(map(str, filenames))
         for f in filenames:
             if not Path(str(f)).is_file():
@@ -98,6 +98,7 @@ def save(self, key, dst):
 
     def view(self, key):
         """ View a file using the configured text viewer. """
+        from tinyscript.helpers import txt_terminal_render
         try:
             self.page_text(self[key])
         except KeyError:
@@ -120,7 +121,8 @@ def list(self):
     @property
     def tempdir(self):
         """ Get the temporary directory. """
+        from tinyscript.helpers import TempPath
         if not hasattr(self, "_tempdir"):
-            self._tempdir = TempPath(prefix="%s-" % self.console.appname, length=16)
+            self._tempdir = TempPath(prefix=f"{self.console.appname}-", length=16)
         return self._tempdir
 

src/sploitkit/core/components/jobs.py

@@ -1,11 +1,8 @@
 # -*- coding: UTF-8 -*-
 import shlex
 import subprocess
-from six import string_types
-from time import time
 from tinyscript.helpers.text import ansi_seq_strip
 
-from sploitkit.core.components.logger import null_logger
 
 __all__ = ["JobsPool"]
 
@@ -20,7 +17,7 @@ def __init__(self, cmd, **kwargs):
         debug = not kwargs.pop('no_debug', False)
         if debug:
             self.parent.logger.debug(" ".join(cmd) if isinstance(cmd, (tuple, list)) else cmd)
-        cmd = shlex.split(cmd) if isinstance(cmd, string_types) and not kwargs.get('shell', False) else cmd
+        cmd = shlex.split(cmd) if isinstance(cmd, str) and not kwargs.get('shell', False) else cmd
         super(Job, self).__init__(cmd, stdout=subprocess.PIPE, **kwargs)
         self._debug = debug
 
@@ -86,6 +83,7 @@ def run(self, cmd, stdin=None, show=False, timeout=None, ansi_strip=True, **kwar
         return out, err
 
     def run_iter(self, cmd, timeout=None, ansi_strip=True, **kwargs):
+        from time import time
         kwargs['stderr'] = subprocess.STDOUT
         kwargs['universal_newlines'] = True
         p = Job(cmd, parent=self, **kwargs)
@@ -124,5 +122,6 @@ def terminate(self, subpool=None):
     def logger(self):
         if hasattr(self, "console"):
             return self.console.logger
+        from sploitkit.core.components.logger import null_logger
         return null_logger
 

src/sploitkit/core/components/logger.py

@@ -1,7 +1,5 @@
 # -*- coding: utf8 -*-
-from logging.handlers import RotatingFileHandler
-from termcolor import colored
-from tinyscript import logging
+from tinyscript import colored, logging
 
 
 __all__ = ["get_logger", "null_logger", "set_logging_level"]
@@ -54,6 +52,7 @@ def emit(self, record):
 def get_logger(name, logfile=None, level="INFO", dev=False, enabled=True):
     """ Logger initialization function. """
     def _setup_logfile(l):
+        from logging.handlers import RotatingFileHandler
         if logfile is not None and not any(isinstance(h, RotatingFileHandler) for h in l.handlers):
             l.__logfile__ = logfile
             # setup a FileHandler for logging to a file (at level DEBUG)

src/sploitkit/core/components/recorder.py

@@ -1,7 +1,4 @@
 # -*- coding: UTF-8 -*-
-from tinyscript.helpers import Path
-
-
 __all__ = ["Recorder"]
 
 
@@ -24,6 +21,7 @@ def save(self, text):
 
     def start(self, filename, overwrite=False):
         """ Start the recorder, creating the record file. """
+        from tinyscript.helpers import Path
         self.__file = f = Path(filename)
         if f.suffix != ".rc":
             self.__file = f = Path(self.root_dir).joinpath(filename + ".rc")

src/sploitkit/core/components/sessions.py

@@ -1,20 +1,19 @@
 # -*- coding: UTF-8 -*-
 import os
-import shlex
-import shutil
-from subprocess import Popen
-from tinyscript.helpers import Path
+
 
 __all__ = ["SessionsManager"]
 
 
 class Session(object):
     """ Class representing a session object based on a shell command """
     def __init__(self, n, cmd, **kwargs):
+        from shlex import split
+        from tinyscript.helpers import Path
         self.id = n
         self.parent = kwargs.pop('parent')
         if isinstance(cmd, str):
-            cmd = shlex.split(cmd)
+            cmd = split(cmd)
         self._path = Path(self.parent.console._files.tempdir, "session", str(n), create=True)
         for i, s in enumerate(["stdin", "stdout", "stderr"]):
             fifo = str(self._path.joinpath(str(i)))
@@ -23,13 +22,15 @@ def __init__(self, n, cmd, **kwargs):
             setattr(self, "_" + s, os.open(fifo ,os.O_WRONLY))
 
     def close(self):
+        from shutil import rmtree
         for s in ["stdin", "stdout", "stderr"]:
             getattr(self, "_" + s).close()
-        shutil.rmtree(str(self._path))
+        rmtree(str(self._path))
         self._process.wait()
         del self.parent[self.id]
 
     def start(self, **kwargs):
+        from subprocess import Popen
         kwargs['close_fds'] = True
         kwargs['preexec_fn'] = os.setsid  # NB: see subprocess' doc ; preexec_fn is not thread-safe
         self._process = Popen(cmd, stdout=self._stdout, stderr=self._stderr, stdin=self._stdin, **kwargs) 

src/sploitkit/core/components/store.py

@@ -1,7 +1,4 @@
 # -*- coding: UTF-8 -*-
-import re
-from os import remove
-from shutil import copy
 from peewee import SqliteDatabase
 
 
@@ -88,6 +85,7 @@ def __init__(self, path, *args, **kwargs):
 
     def __getattr__(self, name):
         """ Override getattr to handle add_* store methods. """
+        from re import match
         if name == "basemodels":
             BaseModel = self._pool._entity_class._subclasses["basemodel"]
             return self._pool._entity_class._subclasses[BaseModel]
@@ -96,7 +94,7 @@ def __getattr__(self, name):
             return self._pool._entity_class._subclasses[Model]
         elif name == "volatile":
             return self.path == ":memory:"
-        elif re.match(r"^[gs]et_[a-z]+", name) and name != "model":
+        elif match(r"^[gs]et_[a-z]+", name) and name != "model":
             model = "".join(w.capitalize() for w in name.split("_")[1:])
             cls = self.get_model(model)
             if cls is not None:
@@ -121,8 +119,10 @@ def snapshot(self, save=True):
         if save:
             self._last_snapshot += 1
         s = "{}.snapshot{}".format(self.path, self._last_snapshot)
+        from shutil import copy
         copy(self.path, s) if save else copy(s, self.path)
         if not save:
+            from os import remove
             remove("{}.snapshot{}".format(self.path, self._last_snapshot))
             self._last_snapshot -= 1
         self.connect()