bcpkgfox 0.15.30__py3-none-any.whl → 0.17.7__py3-none-any.whl

bcpkgfox/cli.py

@@ -8,53 +8,114 @@ import sys
 import re
 import os
 
+def main(): cli().main()
+
 class cli:
     def __init__(self):
         self.current_dir = os.getcwd()
+        self.file = None
+        self.args = None
 
         self.visuals = self.visual(self)
         self.exec_gen = self.exec_gen_(self)
         self.find_imports = self.find_import(self)
-        self.venv_managment = self.venv_mangt(self)
+        self.venv_manager = self.venv_mangt(self)
 
         self.parser = argparse.ArgumentParser(
-            add_help=False
+            add_help=False,
+            description=f"{self.visuals.bold}{self.visuals.DK_ORANGE} BCFOX Library \n You can use the arguments in any order you want.\n\n Most flags are independent, you can use it alone or combine them in a single command interacting with each other when applicable.{self.visuals.RESET}",
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter
+            # formatter_class=argparse.RawTextHelpFormatter  # Formats the 'help' text manually
         )
-        args = self.parser.parse_args()
-        self.file = args.filename
+
         self._setup_arguments()
 
     def _setup_arguments(self):
         """Configure all CLI arguments"""
-        venv_group = self.parser.add_argument_group('virtual environment options')
+        venv_group = self.parser.add_argument_group(f'{self.visuals.ORANGE}{self.visuals.bold} Virtual Environment Options{self.visuals.RESET}')
         venv_group.add_argument(
             '-v', '--venv',
             action='store_true',
-            help="Creates a virtual environment with all dependencies installed"
+            help="Creates a new virtual environment with all dependencies installed\n"
         )
 
         venv_group.add_argument(
             '-vc', '--venv-clean',
             action='store_true',
-            help="Creates a virtual environment without dependencies"
+            help="Creates a virtual environment without dependencies\n"
         )
 
         venv_group.add_argument(
             '-rv', '--recreate-venv',
             action='store_true',
-            help="Recreates venv (without dependencies)"
+            help="Recreates venv (without dependencies)\n"
         )
 
         venv_group.add_argument(
             '-dv', '--delete-venv',
             action='store_true',
-            help="Deletes venv"
+            help="Deletes venv\n"
         )
 
-        self.parser.add_argument(
+        venv_group.add_argument(
+            '-r', '--requirements',
+            action='store_true',
+            # nargs='?',
+            # action=self.venv_manager.custom_action_requirements,
+            # default=False,
+            help="Create a requirements\n"
+        )
+
+        exe_group = self.parser.add_argument_group(f'{self.visuals.ORANGE}{self.visuals.bold} Exe options{self.visuals.RESET}')
+        exe_group.add_argument(
+            '-e', '--exe',
+            action='store_true',
+            help="Creates a .exe of the file\n"
+        )
+
+        exe_group.add_argument(
+            '-nc', '--no-console',
+            action='store_true',
+            help="The exe don't open the console when started\n"
+        )
+
+        exe_group.add_argument(
+            '-z', '--zip',
+            action='store_true',
+            help="Make a zip of the 'dist' and rename it to the name of the file\n"
+        )
+
+        exe_group.add_argument(
+            '-ic', '--icon',
+            type=str,
+            nargs='+',
+            help="Change the exe icon (put .ico path)\n"
+        )
+
+        exe_group.add_argument(
+            '-ad', '--add-data',
+            type=str,
+            nargs='+',
+            help="Add data(s) to .exe (similar of pyinstaller)\n"
+        )
+
+        file_group = self.parser.add_argument_group(f'{self.visuals.ORANGE}{self.visuals.bold} File Options{self.visuals.RESET}')
+        file_group.add_argument(
             '-fi', '--find-imports',
             action='store_true',
-            help="Finds all imports necessary for the lib to work"
+            help="Finds all imports necessary for the lib to work\n"
+        )
+
+        file_group.add_argument(
+            '-vi', '--verify-imports',
+            action='store_true',
+            help="Shows imports that were not installed automatically\n"
+        )
+
+        file_group.add_argument(
+            '-i', '--install-imports',
+            action='store_true',
+            help="Installs all imports necessary for the lib to work\n"
         )
 
         self.parser.add_argument(
@@ -68,36 +129,77 @@ class cli:
             '-h', '--help',
             action='help',
             default=argparse.SUPPRESS,
-            help="Salveeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+            help="If you need more help contact guilherme"
         )
 
     def main(self):
-        args = self.parser.parse_args()
+        self.args = self.parser.parse_args()
+        self.file = self.args.filename
+
+        self.data_dict = []
+        if self.args.exe:
+            if self.args.add_data:
+                for data in self.args.add_data:
+                    self.data_dict.append(data)
+
+        # Icon check
+        if self.args.icon:
+            if len(self.args.icon) > 1:
+                raise ValueError("Put only one PATH in 'icon' argument.")
+
+            if not os.path.exists(os.path.join(self.current_dir, self.args.icon[0])):
+                raise ValueError(f"The path '{self.args.icon[0]}' not exists")
 
-        if args.venv:
+        # Venv
+        if self.args.venv:
             self.venv_manager.main()
-        elif args.venv_clean:
+        elif self.args.venv_clean:
             self.venv_manager.create_venv()
-        elif args.recreate_venv:
+        elif self.args.recreate_venv:
             self.venv_manager.recreate_venv()
-        elif args.delete_venv:
+        elif self.args.delete_venv:
             self.venv_manager.delete_venv()
 
-        if args.find_imports:
-            self.imports_finder.main()
-
-        if args.filename:
-            self._process_file(args.filename)
+        # Imports
+        if self.args.find_imports:
+            self.find_imports.main()
+        elif self.args.install_imports:
+            self.venv_manager.install_imports()
+
+        # EXEC
+        elif self.args.exe:
+            self.exec_gen.main()
+
+        if self.args.zip:
+            self.exec_gen.zip_file()
+
+        # LOG - Verify imports
+        if self.args.verify_imports:
+            if self.args.find_imports \
+            or self.args.install_imports \
+            or self.args.venv \
+            or self.args.recreate_venv \
+            or self.args.exe:
+                self.find_imports.verify_imports()
+            else:
+                print(f"{self.visuals.bold}{self.visuals.RD} > Error: You need to use one function that installs imports before verifying them{self.visuals.RESET}")
+                print("\033[J", end='', flush=True)
+
+        # Requirements
+        if self.args.requirements:
+            self.venv_manager.requirements()
+
+        self.clean_terminal()
 
     def clean_terminal(self):
         if self.exec_gen.error == 1 \
         or self.find_imports.error == 1 \
-        or self.venv_managment.error == 1:
+        or self.venv_manager.error == 1:
             print("\033[J", end='', flush=True)
 
         if self.exec_gen.descerror: print(f"\n {self.visuals.DK_ORANGE}>{self.visuals.RESET} {self.exec_gen.descerror}")
         if self.find_imports.descerror: print(f"\n {self.visuals.DK_ORANGE}>{self.visuals.RESET} {self.find_imports.descerror}")
-        if self.venv_managment.descerror: print(f"\n {self.visuals.DK_ORANGE}>{self.visuals.RESET} {self.venv_managment.descerror}")
+        if self.venv_manager.descerror: print(f"\n {self.visuals.DK_ORANGE}>{self.visuals.RESET} {self.venv_manager.descerror}")
 
     class visual:
         def __init__(self, self_cli):
@@ -105,6 +207,7 @@ class cli:
 
             self.DK_ORANGE = "\033[38;5;130m"
             self.ORANGE = "\033[38;5;214m"
+            self.YL = "\033[38;5;226m"
             self.RD = "\033[38;5;196m"
             self.GR = "\033[38;5;34m"
             self.RESET = "\033[0m"
@@ -136,6 +239,53 @@ class cli:
             time.sleep(delay)
             return f"    \033[1m{self.rgb_text(text, r, g, b)}\033[0m"
 
+        class animation:
+            def __init__(self, self_cli):
+                self.cli = self_cli
+                self.text = None
+                self.braille_spinner = [
+                    '\u280B',
+                    '\u2809',
+                    '\u2839',
+                    '\u2838',
+                    '\u283C',
+                    '\u2834',
+                    '\u2826',
+                    '\u2827',
+                    '\u2807',
+                    '\u280F'
+                ]
+
+                self.retro_computer_style = [
+                '\u23BA',  # ⎺
+                '\u23BB',  # ⎻
+                '\u23BC',  # ⎼
+                '\u23BD',  # ⎽
+                ]
+
+                self.footer_thread = None
+                self.process_finished = False
+
+            def print_footer(self):
+                s = 0
+                n = 0
+                while not self.process_finished:
+                    if s % 10 == 0: n += 1
+                    if n == len(self.retro_computer_style): n = 0
+
+                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.cli.visuals.animate_rgb_text(f"  {self.cli.visuals.bold} {self.retro_computer_style[n]} {self.text} {self.retro_computer_style[n]} {self.cli.visuals.RESET}")} \033[0J\n\033[F")
+                    sys.stdout.flush()
+                    s += 1
+
+            def start(self, text):
+                self.text = text
+                self.footer_thread = threading.Thread(target=self.print_footer)
+                self.footer_thread.start()
+
+            def finish(self):
+                self.process_finished = True
+                self.footer_thread.join()
+
     class exec_gen_:
         def __init__(self, self_cli):
             self.cli = self_cli
@@ -144,17 +294,11 @@ class cli:
             self.error = 0
             self.descerror = ""
             self.visuals = self.cli.visuals
+            self.ultimate_error = None
 
         def preparations(self):
             self.current_dir = os.getcwd()
-
-            parser = argparse.ArgumentParser(description="Script to generate .exe and preventing bugs")
-            parser.add_argument("file", type=str, help="Put the name of file after the command (with the extension '.py')")
-
-            # args = parser.parse_args()  #TODO
-            # self.file_name = args.file  #TODO
-            self.target_file = os.path.join(self.current_dir, self.file_name)  #TODO
-            # self.target_file = self.cli.file  #FIX
+            self.target_file = os.path.join(self.current_dir, self.cli.file)  #TODO
 
             if not os.path.exists(self.target_file):
                 self.descerror = f"Error: File '{self.target_file}' does not exist."
@@ -165,23 +309,23 @@ class cli:
             global process_finished
 
             braille_spinner = [
-                '\u280B',  # ⠋
-                '\u2809',  # ⠙
-                '\u2839',  # ⠹
-                '\u2838',  # ⠸
-                '\u283C',  # ⠼
-                '\u2834',  # ⠴
-                '\u2826',  # ⠦
-                '\u2827',  # ⠧
-                '\u2807',  # ⠇
-                '\u280F'   # ⠏
+                '\u280B',
+                '\u2809',
+                '\u2839',
+                '\u2838',
+                '\u283C',
+                '\u2834',
+                '\u2826',
+                '\u2827',
+                '\u2807',
+                '\u280F'
             ]
 
             retro_computer_style = [
-            '\u23BA',  # ⎺
-            '\u23BB',  # ⎻
-            '\u23BC',  # ⎼
-            '\u23BD',  # ⎽
+            '\u23BA',
+            '\u23BB',
+            '\u23BC',
+            '\u23BD',
             ]
 
             def print_footer():
@@ -191,34 +335,123 @@ class cli:
                     if s % 10 == 0: n += 1
                     if n == len(braille_spinner): n = 0
 
-                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.visuals.animate_rgb_text(f"  {self.visuals.bold} {braille_spinner[n]} Gerando executável do '{self.target_file}', aguarde finalização. {braille_spinner[n]} {self.visuals.RESET}")} \n\033[F")
+                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.visuals.animate_rgb_text(f"  {self.visuals.bold} {braille_spinner[n]} Gerando executável do '{self.cli.file}', aguarde finalização. {braille_spinner[n]} {self.visuals.RESET}")} \033[0J\n\033[F")
                     sys.stdout.flush()
                     s += 1
+                print("\033[1A \r\033[K \033[1B \r\033[K")  #\033[1B \r\033[K\033[1B \r\033[K\033[1B \r\033[K")
 
-            process_finished = False
-            command = ["pyinstaller", self.target_file]
-            process = subprocess.Popen(
-                command,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                universal_newlines=True,
-                bufsize=1
-            )
-            footer_thread = threading.Thread(target=print_footer)
-            footer_thread.start()
+            try:
+                process_finished = False
+                python_executable = os.path.join(".venv", 'Scripts' if os.name == 'nt' else 'bin', 'python')
+                command = [python_executable, "-m", "PyInstaller", "--onefile", "--clean"]
+                if self.cli.data_dict:
+                    for data in self.cli.data_dict:
+                        if ":" in data or ";" in data: command.extend(["--add-data", data])
+                        else: command.extend(["--add-data", f"{data}:{data}"])
+
+                if self.cli.args.no_console:
+                    command.append("--noconsole")
+
+                if self.cli.args.icon:
+                    command.extend(["--icon", f"{self.cli.args.icon[0]}"])
+
+                command.append(self.target_file)
+
+                process = subprocess.Popen(
+                    command,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    universal_newlines=True,
+                    bufsize=1
+                )
+                footer_thread = threading.Thread(target=print_footer)
+                footer_thread.start()
+
+                while True:
+                    output = process.stdout.readline()
+                    if output == '' and process.poll() is not None: break
+                    if output:
+                        sys.stdout.write(f"\033[F\r\033[K{output.strip()}\033[K\n\n")
+                        sys.stdout.flush()
 
-            while True:
-                output = process.stdout.readline()
-                if output == '' and process.poll() is not None:
-                    break
-                if output:
-                    sys.stdout.write(f"\033[F\r\033[K{output.strip()}\033[K\n\n")
-                    sys.stdout.flush()
+                process_finished = True
+                footer_thread.join()
 
-            process_finished = True
-            footer_thread.join()
+            except Exception as e:
+                process_finished = True
+                self.descerror = e
+                self.error = 1
+            finally: process_finished = True
+
+            rows = os.get_terminal_size().lines
+            print(f"\033[F\033[K\033[f\033[K\033[f\033[K{self.visuals.bold}{self.visuals.GR}\033[{rows};1H > Executável gerado com sucesso!\n{self.visuals.RESET} \033[0J")
+
+        def zip_file(self):
+
+            animation = self.visuals.animation(self.cli)
+            animation.start(text='Creating zip file')
+            zip_log = False
+
+            try:
+                name_dir = self.current_dir.split("\\")
+                print(name_dir)
+
+                name_dir = [part for part in name_dir if part]
+
+                target_name = name_dir[-1]
+
+                dist_path = os.path.join(self.current_dir, "dist")
+                temp_path = os.path.join(self.current_dir, f"{target_name}_temp")
+                inner_path = os.path.join(temp_path, target_name)
+
+                if os.path.isfile(os.path.join(self.current_dir, f"{target_name}.zip")):
+                    os.remove(os.path.join(self.current_dir, f"{target_name}.zip"))
+
+                if os.path.exists(os.path.join(self.current_dir, f"{target_name}")):
+                    shutil.rmtree(os.path.join(self.current_dir, f"{target_name}"))
+
+                if os.path.exists(dist_path):
+                    if os.path.exists(temp_path):
+                        shutil.rmtree(temp_path)
+                    os.mkdir(temp_path)
+                    shutil.move(dist_path, inner_path)
+                else:
+                    raise FileNotFoundError(f"{self.visuals.bold}{self.visuals.RD}Error: 'dist' directory not found!{self.visuals.RESET}")
+
+                zip_path = shutil.make_archive(
+                    os.path.join(self.current_dir, target_name),
+                    'zip',
+                    root_dir=temp_path,
+                    base_dir=target_name
+                )
+
+                # Espera o sistema liberar o zip
+                wait = 0
+                while True:
+                    try:
+                        with open(zip_path, 'rb'):
+                            break
+                    except (PermissionError, OSError):
+                        time.sleep(0.1)
+                        wait += 1
+                        if wait >= 600:
+                            raise TimeoutError("Timeout while waiting for zip file to be accessible.")
+
+                shutil.rmtree(temp_path)
+                zip_log = True
 
-            print(f"\r \033[F\r\033[K\033[f\r\033[K\033[2E{self.visuals.bold}{self.visuals.DK_ORANGE}>{self.visuals.RESET}{self.visuals.bold} Executável gerado com sucesso!\n{self.visuals.RESET}\033[3E")
+            except Exception as e:
+                self.ultimate_error = e
+
+            finally:
+                animation.finish()
+
+                if zip_log:
+                    print(f"{self.visuals.bold}{self.visuals.GR} > Zip file created successfully {self.visuals.RESET}\033[J\n\033[J")
+                else:
+                    print(f"{self.visuals.bold}{self.visuals.RD} > Error creating zip file:\033[J")
+                    print(f"{self.ultimate_error}{self.visuals.RESET}")
+                    sys.exit(1)
 
         def main(self):
             script = self.cli.exec_gen
@@ -234,6 +467,7 @@ class cli:
             self.descerror = ""
 
             self.imports = None
+            self.error_libs = []
 
         def hsl_to_rgb(self, h, s, l):
             h = h % 360
@@ -269,19 +503,22 @@ class cli:
                 hue = (hue + 1) % 360
                 time.sleep(delay)
 
+        def verify_imports(self):
+            if self.error_libs:
+                print(f"{self.visuals.bold}{self.visuals.YL} WARNING: \n The libraries below can't be installed. This is not necessarily an error, just an alert.{self.visuals.RESET}")
+                for lib in self.error_libs:
+                    print(f" {self.visuals.bold}{self.visuals.YL}   - {lib} {self.visuals.RESET}")
+
         def main(self, return_=False):
-            parser = argparse.ArgumentParser(description="A CLI tool to find imports.")
-            parser.add_argument("file", type=str, help="The target .py file to process")
+            self.target_file = self.cli.file
 
-            # args = parser.parse_args()  #TODO
-            # self.file_name = args.file  #TODO
-            # self.target_file = os.path.join(self.current_dir, self.file_name)  #TODO
-            self.target_file = self.cli.file  #FIX
+            if not self.target_file:
+                print(f"{self.visuals.bold}{self.visuals.RD} > Error: Please pass your 'target_file' to detect the libraries.{self.visuals.RESET}")
+                sys.exit(1)
 
             if not os.path.exists(self.target_file):
-                self.descerror = f"Error: File '{self.target_file}' does not exist."
-                self.error = 1
-                return
+                print(f"{self.visuals.bold}{self.visuals.RD} > Error: Your 'target_file' does not exist or can't be accessed.{self.visuals.RESET}")
+                sys.exit(1)
 
             try:
                 with open(self.target_file, "r", encoding="utf-8", errors="replace") as file:
@@ -294,25 +531,38 @@ class cli:
                 print(f"Erro: Não foi possível ler o arquivo '{self.target_file}' com nenhuma codificação testada.")
                 return
 
-            self.imports = []
+            self.imports = ["bcpkgfox"]
             import_data = {
                 "extract_pdf": "PyMuPDF",
                 "import requests": "requests",
                 "import pyautogui": "pyautogui",
                 "import cv2": "opencv-python",
+                "fitz": "PyMuPDF",
                 "from PIL": "Pillow",
                 "from reportlab.lib import utils": "reportlab",
                 "from PyPDF2 import PdfMerger": "PyPDF2",
+                "PdfWriter": "pypdf",
                 "import PyPDF2": "PyPDF2",
                 "invoke_api_": "requests",
+                "login_2fac": "pyautogui",
                 "wait_for": "pygetwindow",
                 "from selenium_stealth import stealth": "selenium-stealth",
+                "capmonstercloudclient": "bcpkgfox[capmonstercloudclient]",
+                "capmonstercloud_client": "bcpkgfox[capmonstercloudclient]",
                 "import undetected_chromedriver": "undetected-chromedriver",
-                "from webdriver_manager.chrome import ChromeDriverManager": "webdriver-manager",
+                "webdriver_manager": "webdriver-manager",
                 "move_to_image": ["pyscreeze", "pyautogui", "Pillow", "opencv-python"],
                 "move_mouse_smoothly": ["pyscreeze", "pyautogui", "Pillow"],
                 "initialize_driver": ["webdriver-manager", "undetected-chromedriver", "pyautogui", "psutil"],
-                "stealth max": ["webdriver-manager", "undetected-chromedriver", "fake-useragent"]
+                "stealth max": ["webdriver-manager", "undetected-chromedriver"],
+                "bs4": "beautifulsoup4", "beautifulsoup":"beautifulsoup4",
+                "psutil": "bcpkgfox[psutil]",
+                "screeninfo": "bcpkgfox[screeninfo]", "get_monitors": "bcpkgfox[screeninfo]",
+                "pynput": "bcpkgfox[pynput]", "pynput.mouse": "bcpkgfox[pynput]",
+                "pynput.keyboard": "bcpkgfox[pynput]",
+                "pywinauto": "bcpkgfox[pywinauto]",
+                "pdfplumber": "pdfplumber",
+                "twocaptcha": "bcpkgfox[twocaptcha]", "TwoCaptcha": "bcpkgfox[twocaptcha]",
             }
 
             for name, import_name in import_data.items():
@@ -321,6 +571,14 @@ class cli:
                         self.imports.extend(import_name)
                     else: self.imports.append(import_name)
 
+            IMPORT_PATTERN = re.compile(r'^(?:from|import)\s+([A-Za-z0-9_\.]+)', re.MULTILINE)
+
+            # Encontra outras libs por regex
+            for match in IMPORT_PATTERN.finditer(file_content):
+                módulo = match.group(1).split('.')[0]  # pega o pacote raiz
+                if módulo not in self.imports:
+                    self.imports.append(módulo)
+
             self.imports = list(set(self.imports))
             import pyperclip
 
@@ -339,8 +597,6 @@ class cli:
                 else: return self.imports
             else: print("No libraries from the list were found in the script.")
 
-
-
     class venv_mangt:
         def __init__(self, self_cli):
             self.cli = self_cli
@@ -380,24 +636,31 @@ class cli:
                     if s % 10 == 0: n += 1
                     if n == len(braille_spinner): n = 0
 
-                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.visuals.animate_rgb_text(f"  {self.visuals.bold} {braille_spinner[n]} Deleting virtual environment {braille_spinner[n]} {self.visuals.RESET}")} \n\033[F")
+                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.visuals.animate_rgb_text(f"  {self.visuals.bold} {braille_spinner[n]} Deleting virtual environment {braille_spinner[n]} {self.visuals.RESET}")} \033[0J\n\033[F")
                     sys.stdout.flush()
                     s += 1
 
-            footer_thread = threading.Thread(target=print_footer)
-            footer_thread.start()
-
-            if os.path.exists(os.path.join(self.current_dir, ".venv")):
-                try:
-                    shutil.rmtree(".venv")
-                except Exception as e:
-                    print(f"{self.visuals.RD} > Failed to remove venv: {e} {self.visuals.RESET}")
-                    return False
-            process_finished = True
-            footer_thread.join()
-
-            print(f"{self.visuals.bold}{self.visuals.GR} > Oldest virtual environment deleted with sucessfuly {self.visuals.RESET}\n")
+            try:
+                footer_thread = threading.Thread(target=print_footer)
+                footer_thread.start()
+
+                if os.path.exists(os.path.join(self.current_dir, ".venv")):
+                    try:
+                        shutil.rmtree(".venv")
+                    except Exception as e:
+                        print(f"{self.visuals.RD} > Failed to remove venv: {e} {self.visuals.RESET}")
+                        return False
+                process_finished = True
+                footer_thread.join()
 
+                print(f"{self.visuals.bold}{self.visuals.GR} > Oldest virtual environment deleted with sucessfuly {self.visuals.RESET}\n")
+            except Exception as e:
+                process_finished = True
+                self.descerror = e
+                self.error = 1
+                sys.exit()
+                raise SystemExit()
+            finally: process_finished = True
 
         def create_venv(self):
 
@@ -429,34 +692,40 @@ class cli:
                     if s % 10 == 0: n += 1
                     if n == len(braille_spinner): n = 0
 
-                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.visuals.animate_rgb_text(f"  {self.visuals.bold} {braille_spinner[n]} Generating virtual environment {braille_spinner[n]} {self.visuals.RESET}")} \n\033[F")
+                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.visuals.animate_rgb_text(f"  {self.visuals.bold} {braille_spinner[n]} Generating virtual environment {braille_spinner[n]} {self.visuals.RESET}")} \033[0J\n\033[F")
                     sys.stdout.flush()
                     s += 1
 
-            process_finished = False
-            command = [sys.executable, '-m', 'venv', ".venv"]
-            process = subprocess.Popen(
-                command,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                universal_newlines=True,
-                bufsize=1
-            )
-            footer_thread = threading.Thread(target=print_footer)
-            footer_thread.start()
-
-            while True:
-                output = process.stdout.readline()
-                if output == '' and process.poll() is not None:
-                    break
-                if output:
-                    sys.stdout.write(f"\033[F\r\033[K{output.strip()}\033[K\n\n")
-                    sys.stdout.flush()
+            try:
+                process_finished = False
+                command = [sys.executable, '-m', 'venv', ".venv"]
+                process = subprocess.Popen(
+                    command,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    universal_newlines=True,
+                    bufsize=1
+                )
+                footer_thread = threading.Thread(target=print_footer)
+                footer_thread.start()
+
+                while True:
+                    output = process.stdout.readline()
+                    if output == '' and process.poll() is not None:
+                        break
+                    if output:
+                        sys.stdout.write(f"\033[F\r\033[K{output.strip()}\033[K\n\n")
+                        sys.stdout.flush()
 
-            process_finished = True
-            footer_thread.join()
+                process_finished = True
+                footer_thread.join()
 
-            print(f"{self.visuals.bold}{self.visuals.GR} > Virtual environment created successfully {self.visuals.RESET}", end="\r")
+                print(f"{self.visuals.bold}{self.visuals.GR} > Virtual environment created successfully {self.visuals.RESET}\n")
+            except Exception as e:
+                process_finished = True
+                self.descerror = e
+                self.error = 1
+            finally: process_finished = True
 
         def install_imports(self):
             pip_path = os.path.join(".venv", 'Scripts' if os.name == 'nt' else 'bin', 'pip')
@@ -490,47 +759,105 @@ class cli:
                     if s % 10 == 0: n += 1
                     if n == len(braille_spinner): n = 0
 
-                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.visuals.animate_rgb_text(f"  {self.visuals.bold} {braille_spinner[n]} Installing all dependencies {braille_spinner[n]} {self.visuals.RESET}")} \n\033[F")
+                    sys.stdout.write(f"\r \033[F\r\033[K\033[E {self.visuals.animate_rgb_text(f"  {self.visuals.bold} {braille_spinner[n]} Installing all dependencies {braille_spinner[n]} {self.visuals.RESET}")} \033[0J\n\033[F")
                     sys.stdout.flush()
                     s += 1
 
-            log_animation = threading.Thread(target=print_footer)
-            log_animation.start()
-
-            process_finished = False
             try:
+                log_animation = threading.Thread(target=print_footer)
+                log_animation.start()
+
+                process_finished = False
                 for lib in librarys:
                     result = subprocess.run(
                         [pip_path, 'install', lib],
-                        check=True,
+                        # check=True,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         text=True
                     )
 
+                    if result.returncode != 0:
+                        if isinstance(lib, list):
+                            self.cli.find_imports.error_libs.extend(lib)
+                        else: self.cli.find_imports.error_libs.append(lib)
+                        continue
+
 
-                    if result.stdout:
+                    elif result.stdout:
                         print(f"\033[0J{result.stdout.strip()}\033[0J")
 
-            except subprocess.CalledProcessError as e:
-                print(f"{self.visuals.bold}{self.visuals.RD} Failed to install {lib}: {e.stderr.strip()}{self.visuals.RESET}", end="\r")
-                return False
-            finally:
                 process_finished = True
                 log_animation.join()
-            print(f" {self.visuals.bold}{self.visuals.GR} > All packges installed with sucessfully {self.visuals.RESET}", end="\r")
+                print(f" {self.visuals.bold}{self.visuals.GR} > All packages installed successfully {self.visuals.RESET}\n\n")
+
+            except Exception as e:
+                process_finished = True
+                self.descerror = e
+                self.error = 1
+                print(e)
+                sys.exit()
 
         def recreate_venv(self):
             self.delete_venv()
             self.create_venv()
 
+        class custom_action_requirements(argparse.Action):
+            ''' This is necessary to define a new action and the parser identifies it as valid '''
+
+            def __call__(self, parser, namespace, values, option_string=None):
+                if values is None:
+                    setattr(namespace, self.dest, 'requirements.txt')
+                else:
+                    setattr(namespace, self.dest, values)
+
+        def requirements(self):
+
+            # # Identifies endwish
+            # if '.' in self.cli.args.requirements:
+            #     name = self.cli.args.requirements
+            # else:
+            #     name = self.cli.args.requirements + '.txt'
+
+            # FIX: name is always 'requirements.txt'
+            name = 'requirements.txt'
+
+            # Attempt of recreate
+            try:
+                os.remove(os.path.join(self.current_dir, name))
+            except:
+                pass
+
+            # Creates a new one
+            subprocess.run(f"pip freeze > {name}", shell=True)
+
+            # Read
+            with open(f'{name}', 'r') as f:
+                lines = f.readlines()
+
+            # Re-write
+            add_list = []
+            imports = self.cli.find_imports.main(return_=True)
+            imports_lower = {imp.lower() for imp in imports}
+            with open(f'{name}', 'w') as f:
+
+                for line in lines:
+
+                    # Formats
+                    if '\n' in line:
+                        line_for_print = line.replace('\n', '').strip()
+
+                    # Compares
+                    pkg = line.split('==')[0].strip().lower()
+                    if pkg in imports_lower:
+                        f.write(line)
+                        add_list.append(line_for_print)
+
+            print(f"\n{self.visuals.bold}{self.visuals.GR} > Requirements created with sucessfuly {self.visuals.RESET}\n")
+            print(f"{self.visuals.bold}{self.visuals.YL} Libraries installed: {self.visuals.RESET}{self.visuals.YL}" + "".join(f"\n   {lib}" for lib in add_list) + f"{self.visuals.RESET}")
 
         def main(self):
-            self.delete_venv()
+            try: self.delete_venv()
+            except: pass
             self.create_venv()
-            self.install_imports()
-
-code = cli("bcpkgfox//cli.py")
-code.exec_gen.main()
-code.clean_terminal()
-print()
+            self.install_imports()