fix: ImportsObfuscator to include complex cases

Author: deoktr

README.md

@@ -750,20 +750,50 @@ exec(binascii.a2b_hex("".join(['7072696e-7428-2748-656c-6c6f2c20776f','726c6427-
 
 #### ImportsObfuscator
 
-Source: `import pathlib`
+Remove keyword `import`.
 
 ```python
-pathlib=__import__('pathlib')
+# import X
+X = __import__("X")
+
+# import X as Y
+Y = __import__("X")
+
+# import X, Y
+X = __import__("X")
+Y = __import__("Y")
+
+# import X.Y
+X = __import__("X.Y")
+
+# from X import Y
+Y = __import__("X", fromlist=["Y"]).Y
+
+# from X import Y as Z
+Z = __import__("X", fromlist=["Y"]).Y
+
+# from X import Y, Z
+Y = __import__("X", fromlist=["Y"]).Y
+Z = __import__("X", fromlist=["Z"]).Z
 ```
 
+> [!NOTE]
+> Does not support wildcard imports `*`, or local imports `from . import`.
+
 #### CharFromDocObfuscator
 
+Get a single character from a documentation.
+
 Source: `print('h')`
 
 ```python
 print(oct.__doc__[8])
 ```
 
+> [!WARNING]
+> This is highly prone to error, if the documentation change between Python
+> versions, then this may break.
+
 #### AddCommentsObfuscator
 
 ```python

pof/obfuscator/esoteric/doc.py

@@ -183,31 +183,31 @@ class CharFromDocObfuscator:
     )
 
     @staticmethod
-    def get_char_indexes(string, char):
+    def _get_char_indexes(string, char):
         return [pos for pos, c in enumerate(string) if c == char]
 
     @classmethod
-    def try_find_doc_index(cls, char):
+    def _try_find_doc_index(cls, char):
         # take a random builtin doc and search for index in it
         builtin = random.choice(cls.BUILTINS)
         doc = __builtins__[builtin].__doc__
         if not doc:
             msg = f"doc for {builtin} is not a string"
             raise PofError(msg)
-        indexes = cls.get_char_indexes(doc, char)
+        indexes = cls._get_char_indexes(doc, char)
         if len(indexes) == 0:
             msg = "char not present"
             raise PofError(msg)
         index = random.choice(indexes)
         return builtin, index
 
-    def obfuscate_char(self, char):
+    def _obfuscate_char(self, char):
         builtin = None
         index = None
         retry = 3
         for _ in range(retry):
             try:
-                builtin, index = self.try_find_doc_index(char)
+                builtin, index = self._try_find_doc_index(char)
             except PofError:
                 pass
             else:
@@ -239,7 +239,7 @@ def obfuscate_tokens(self, tokens):
                 string = ast.literal_eval(tokval)
                 if len(string) == 1:
                     try:
-                        new_tokens = self.obfuscate_char(string)
+                        new_tokens = self._obfuscate_char(string)
                     except PofError as e:
                         logger.debug(str(e))
                     except Exception:  # noqa: BLE001

pof/obfuscator/esoteric/globals.py

@@ -47,7 +47,7 @@ def obfuscate_tokens(cls, tokens):
                 local_functions.append(tokval)
             prev_tokval = tokval
 
-        result = []  # obfuscated tokens
+        result = []
         prev_tokval = None
         for index, (toknum, tokval, *_) in enumerate(tokens):
             new_tokens = [(toknum, tokval)]
@@ -60,7 +60,7 @@ def obfuscate_tokens(cls, tokens):
                 # ensure it's not a definition
                 and prev_tokval not in ["def", "class", "."]
                 # ensure it's not an argument of a call
-                and next_tokval not in ["="]
+                and next_tokval != "="
                 and tokval not in cls.RESERVED
             ):
                 new_tokens = [