udemy-userAPI 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

udemy_userAPI/__version__.py

@@ -1,4 +1,4 @@
-__version__ = '0.3.9'
+__version__ = '0.3.11'
 __lib_name__ = 'udemy_userAPI'  # local name
 __repo_name__ = 'udemy-userAPI'
 __autor__ = 'PauloCesar-dev404'

udemy_userAPI/authenticate.py

@@ -208,7 +208,7 @@ class UdemyAuth:
             with open(self.__file_path, 'wb') as f:
                 f.write(b'')
 
-    def login_passwordless(self, email: str, locale: str = 'pt-BR'):
+    def login_passwordless(self, email: str, locale: str = 'pt-BR', otp_callback=None):
         """
         Realiza login na Udemy usando autenticação de dois fatores (2FA).
 
@@ -219,6 +219,7 @@ class UdemyAuth:
         Args:
             email (str): Email do usuário.
             locale (str): Localização do usuário (recomendado para receber mensagens no idioma local).
+            otp_callback (callable, opcional): Função para obter o código OTP (se None, usa input padrão).
 
         Raises:
             LoginException: Em caso de falha no processo de login.
@@ -227,23 +228,16 @@ class UdemyAuth:
         try:
             if self.verif_login():
                 raise UserWarning("Atenção, você já possui uma Sessão válida!")
-            # Inicializa uma sessão com proteção contra Cloudflare
-            session = cloudscraper.create_scraper()
 
-            # Requisita a página de inscrição para obter o token CSRF
+            session = cloudscraper.create_scraper()
             signup_url = "https://www.udemy.com/join/signup-popup/"
             headers = {"User-Agent": "okhttp/4.9.2 UdemyAndroid 8.9.2(499) (phone)"}
             response = session.get(signup_url, headers=headers)
-
-            # Obtém o token CSRF dos cookies retornados
             csrf_token = response.cookies.get("csrftoken")
             if not csrf_token:
                 raise LoginException("Não foi possível obter o token CSRF.")
 
-            # Prepara os dados do login
             data = {"email": email, "fullname": ""}
-
-            # Atualiza os cookies e cabeçalhos da sessão
             session.cookies.update(response.cookies)
             session.headers.update({
                 "User-Agent": "okhttp/4.9.2 UdemyAndroid 8.9.2(499) (phone)",
@@ -261,17 +255,20 @@ class UdemyAuth:
                 "Cache-Control": "no-cache",
             })
 
-            # Faz a requisição para iniciar o login
             login_url = "https://www.udemy.com/api-2.0/auth/code-generation/login/4.0/"
             response = session.post(login_url, data=data, allow_redirects=False)
+
             if 'error_message' in response.text:
                 erro_data: dict = response.json()
                 error_message = erro_data.get('error_message', {})
                 raise LoginException(error_message)
+
             for attempt in range(3):
-                # Solicita o código OTP ao usuário
-                otp = input("Digite o código de 6 dígitos enviado ao seu e-mail: ")
-                # Realiza o login com o código OTP
+                # Obtém o código OTP via callback ou terminal
+                if otp_callback and callable(otp_callback):
+                    otp = otp_callback()
+                else:
+                    otp = input("Digite o código de 6 dígitos enviado ao seu e-mail: ")
                 otp_login_url = "https://www.udemy.com/api-2.0/auth/udemy-passwordless/login/4.0/"
                 otp_data = {
                     "email": email,
@@ -280,33 +277,36 @@ class UdemyAuth:
                     "subscribeToEmails": "false",
                     "upow": J(email, 'login')
                 }
+
                 session.headers.update({
                     "Referer": f"https://www.udemy.com/join/passwordless-auth/?locale={locale}&next="
                                f"https%3A%2F%2Fwww.udemy.com%2Fmobile%2Fipad%2F&response_type=html"
                 })
+
                 response = session.post(otp_login_url, otp_data, allow_redirects=False)
-                # Verifica se o login foi bem-sucedido
+
                 if response.status_code == 200:
                     self._save_cookies(session.cookies)
+                    break  # Sai do loop se o login for bem-sucedido
                 else:
                     if 'error_message' in response.text:
                         erro_data: dict = response.json()
                         error_message = erro_data.get('error_message', {})
                         error_code = erro_data.get('error_code', {})
+
                         if error_code == '1538':
                             raise LoginException(error_message)
                         elif error_code == '2550':
-                            print(error_message)
-                            continue
+                            ### codigo errado....
+                            raise LoginException(error_message)
                         elif error_code == '1330':
                             raise LoginException(error_message)
                         elif error_code == '1149':
-                            raise LoginException(f"Erro interno ao enviar os dados veja os detalhes: '{error_message}'")
+                            raise LoginException(
+                                f"Erro interno ao enviar os dados, veja os detalhes: '{error_message}'")
+
                     raise LoginException(response.text)
-                break
+
         except Exception as e:
-            if DEBUG:
-                error_details = traceback.format_exc()
-            else:
-                error_details = str(e)
+            error_details = traceback.format_exc() if DEBUG else str(e)
             raise LoginException(error_details)

udemy_userAPI/bultins.py

@@ -49,7 +49,6 @@ class DRM:
         except Exception as e:
             raise Exception(f"Não foi possível obter as chaves!\n{e}")
 
-
 class Files:
     def __init__(self, files: list[dict], id_course):
         """
@@ -104,6 +103,112 @@ class Files:
                                'data-file': da['download_urls']}
                     download_urls.append(dt_file)
         return download_urls
+class Caption:
+    """Representa uma legenda."""
+
+    def __init__(self, caption: dict):
+        """
+        Inicializa uma instância de Caption.
+
+        Args:
+            caption (dict): Dados da legenda.
+        """
+        self._caption = caption
+
+    @property
+    def locale(self) -> str:
+        """Retorna o idioma."""
+        return self._caption.get('video_label', '')
+
+    @property
+    def status(self) -> str:
+        """Retorna o status da legenda 1 ou 0"""
+        return self._caption.get('status')
+
+    @property
+    def title(self) -> str:
+        """Retorna o título da legenda."""
+        return self._caption.get('title', '')
+
+    @property
+    def created(self) -> str:
+        """Retorna a data de criação da legenda."""
+        return self._caption.get('created', '')
+
+    @property
+    def id(self) -> int:
+        """Retorna o ID da legenda."""
+        return self._caption.get('id', 0)
+
+    @property
+    def url(self) -> str:
+        """Retorna a URL da legenda."""
+        return self._caption.get('url', '')
+
+    @property
+    def content(self) -> str:
+        """Obtém o conteúdo da legenda."""
+        if self.url:
+            r = requests.get(headers=HEADERS_USER, url=self.url)
+            if r.status_code == 200:
+                return r.text
+            else:
+                raise ConnectionError(
+                    f'status_code: {r.status_code}, Não foi possível obter o conteúdo da legenda!'
+                )
+        else:
+            raise FileNotFoundError(
+                'Não foi possível obter a URL da legenda!'
+            )
+
+class Captions:
+    """Gerencia as legendas de um vídeo."""
+
+    def __init__(self, caption_data: list):
+        """
+        Inicializa uma instância de Captions.
+
+        Args:
+            caption_data (list): Dados das legendas.
+        """
+        self._caption_data = caption_data
+
+    def languages(self) -> list[dict]:
+        """Retorna a lista de idiomas disponíveis na aula."""
+        langs = []
+        for caption in self._caption_data:
+            locale_id = caption.get('locale_id', '')
+            video_label = caption.get('video_label','')
+            if locale_id:
+                langs.append({'locale_id': locale_id,'locale':video_label})
+        return langs
+
+    def get_lang(self, locale_id: str) -> Caption:
+        """
+        Obtém a legenda para o idioma especificado.
+
+
+        Args:
+            locale_id (str): ID do idioma,pode ser obtido no método -> 'languages'
+
+        Returns:
+            Caption: Objeto Caption.
+
+        Raises:
+            FileNotFoundError: Se o idioma não estiver disponível na aula.
+        """
+        is_t = False
+        cpt = {}
+        for caption in self._caption_data:
+            if locale_id == caption.get('locale_id'):
+                is_t = True
+                cpt = caption
+        if not is_t:
+            raise FileNotFoundError(
+                'Esse idioma não está disponível nessa aula!'
+            )
+        c = Caption(caption=cpt)
+        return c
 
 class Quiz:
     """Representa um quiz.
@@ -244,14 +349,20 @@ class Lecture:
         return self.__asset.get('media_sources',[])
 
     @property
-    def get_captions(self) -> list:
+    def get_captions(self) -> Captions:
         """
         Obtém as legendas.
 
         Returns:
-            list: Uma lista contendo as legendas.
+            Captions: Objeto para gerenciar as legendas.
         """
-        return self.__asset.get('captions',[])
+        if self.__asset.get('captions', []):
+            c = Captions(caption_data=self.__asset.get('captions', []))
+            return c
+        else:
+            raise FileNotFoundError(
+                'Não foi encontrada legendas nessa aula!'
+            )
 
     @property
     def get_external_url(self) -> list:

{udemy_userAPI-0.3.9.dist-info → udemy_userAPI-0.3.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: udemy_userAPI
-Version: 0.3.9
+Version: 0.3.11
 Summary: Obtenha detalhes de cursos que o usuário esteja inscrito da plataforma Udemy,usando o EndPoint de usuário o mesmo que o navegador utiliza para acessar e redenrizar os cursos.
 Author: PauloCesar-dev404
 Author-email: paulocesar0073dev404@gmail.com
@@ -29,7 +29,7 @@ Dynamic: summary
 # udemy-userAPI
 
 
-![Versão](https://img.shields.io/badge/version-0.3.8-orange)
+![Versão](https://img.shields.io/badge/version-0.3.11-orange)
 ![Licença](https://img.shields.io/badge/license-MIT-orange)
 [![Sponsor](https://img.shields.io/badge/💲Donate-yellow)](https://paulocesar-dev404.github.io/me-apoiando-online/)
 [![Sponsor](https://img.shields.io/badge/Documentation-green)](https://github.com/PauloCesar-dev404/udemy-userAPI/blob/main/docs/iniciando.md)

udemy_userAPI-0.3.11.dist-info/RECORD

@@ -0,0 +1,17 @@
+udemy_userAPI/__init__.py,sha256=BPle89xE_CMTKKe_Lw6jioYLgpH-q_Lpho2S-n1PIUA,206
+udemy_userAPI/__version__.py,sha256=H_ODVq4mKyiFkG5i7lWTBSW7IGZEXM6ygiPLRFT_VtA,406
+udemy_userAPI/api.py,sha256=GVvbbs3vFN-rF-qLBwiuHz77sjehwk8HjAI-Dey_A6c,29167
+udemy_userAPI/authenticate.py,sha256=lKh4_UMT4zapnUzUSgM0HZoyZYX84w0MMZAaGvCMZQ4,14086
+udemy_userAPI/bultins.py,sha256=LZlyOjSGte6B6gNn7cjl6L2Q2T_CyXIqqfkOUzt4CV4,21996
+udemy_userAPI/exeptions.py,sha256=kfnPdZpqYY8nd0gnl6_Vh-MIz-XupmmbRPIuFnyXupk,692
+udemy_userAPI/sections.py,sha256=Q1PlVt2Bu5MSEP8g11-F_gilJDdhZq50TV1Bo400jcA,6389
+udemy_userAPI/udemy.py,sha256=SpK0LI4hjO45nZDz5waw-Py-d0uulBb28TVjltyWBxM,2920
+udemy_userAPI/.cache/.udemy_userAPI,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+udemy_userAPI/mpd_analyzer/__init__.py,sha256=i3JVWyvcFLaj5kPmx8c1PgjsLht7OUIQQClD4yqYbo8,102
+udemy_userAPI/mpd_analyzer/bin.wvd,sha256=1rAJdCc120hQlX9qe5KUS628eY2ZHYxQSmyhGNefSzo,2956
+udemy_userAPI/mpd_analyzer/mpd_parser.py,sha256=PgUkHc5x8FTuXFCuYkWPZr9TaO_nsKalb02EFYl_zeA,8926
+udemy_userAPI-0.3.11.dist-info/LICENSE,sha256=l4jdKYt8gSdDFOGr09vCKnMn_Im55XIcQKqTDEtFfNs,1095
+udemy_userAPI-0.3.11.dist-info/METADATA,sha256=HEgb5dgPW0dIQPdd2BHd4moLOuA1_y_8PWm1CapcxMY,1657
+udemy_userAPI-0.3.11.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+udemy_userAPI-0.3.11.dist-info/top_level.txt,sha256=ijTINaSDRKhdahY_X7dmSRFTxBIwQErWv9ATCG55mog,14
+udemy_userAPI-0.3.11.dist-info/RECORD,,

animation_consoles/__init__.py

@@ -1 +0,0 @@
-from .animation import  AnimationConsole

animation_consoles/animation.py

@@ -1,64 +0,0 @@
-import sys
-import time
-import threading
-from colorama import init, Fore, Style
-
-# Inicializa o suporte a cores no Windows
-init(autoreset=True)
-
-
-class AnimationConsole:
-    def __init__(self, text="Loading", color=Fore.GREEN, color_frame=Fore.BLUE):
-        """
-        Cria uma animação de loading com uma mensagem colorida no console.
-        :param text: Texto inicial da mensagem de loading.
-        :param color: Cor do texto, usando Fore do colorama.
-        """
-        self._color_frame = color_frame
-        self._text = text
-        self._color = color
-        self._running = False
-        self._animation_thread = None
-        self._frames = ["-", "\\", "|", "/"]
-        self._index = 0
-
-    def start(self):
-        """
-        Inicia a animação no console.
-        """
-        if self._running:
-            return  # Previne múltiplas execuções
-        self._running = True
-        self._animation_thread = threading.Thread(target=self._animate, daemon=True)
-        self._animation_thread.start()
-
-    def stop(self):
-        """
-        Para a animação no console.
-        """
-        self._running = False
-        if self._animation_thread:
-            self._animation_thread.join()
-        sys.stdout.write("\r" + " " * (len(self._text) + 20) + "\r")  # Limpa a linha
-
-    def update_message(self, new_text, new_color=None):
-        """
-        Atualiza a mensagem exibida junto à animação.
-        :param new_text: Novo texto a ser exibido.
-        :param new_color: Nova cor para o texto (opcional).
-        """
-        self._text = new_text
-        if new_color:
-            self._color = new_color
-
-    def _animate(self):
-        """
-        Animação interna do console.
-        """
-        while self._running:
-            frame = self._frames[self._index]
-            self._index = (self._index + 1) % len(self._frames)
-            sys.stdout.write(
-                f"\r{self._color}{self._text}{Style.RESET_ALL} {self._color_frame}{frame}{Style.RESET_ALL}")
-            sys.stdout.flush()
-            time.sleep(0.1)

ffmpeg_for_python/__config__.py

@@ -1,118 +0,0 @@
-import sys
-import os
-import requests
-import zipfile
-import shutil
-import stat
-from .exeptions import *
-from .__utils import URL_PLATAFOMR, system
-
-lib_name = os.path.dirname(__file__)
-URL_BASE_REPO = "https://raw.githubusercontent.com/PauloCesar-dev404/binarios/main/"
-
-
-class Configurate:
-    """Configura variáveis de ambiente no ambiente virtual ou globalmente."""
-
-    def __init__(self):
-        self.VERSION = self.__read_version
-        self.FFMPEG_URL = os.getenv('FFMPEG_URL')
-        self.FFMPEG_BINARY = os.getenv('FFMPEG_BINARY')
-        PATH = os.path.join(lib_name, 'ffmpeg-bin')
-        os.makedirs(PATH, exist_ok=True)
-        dirpath = PATH
-        self.INSTALL_DIR = os.getenv('INSTALL_DIR', dirpath)
-        self.configure()
-
-    def configure(self):
-        """Configura as variáveis de ambiente com base no sistema operacional."""
-        if not self.FFMPEG_URL or not self.FFMPEG_BINARY:
-            platform_name = system
-            if platform_name == 'Windows':
-                self.FFMPEG_URL = URL_PLATAFOMR
-                self.FFMPEG_BINARY = 'ffmpeg.exe'
-            elif platform_name == 'Linux':
-                self.FFMPEG_URL = URL_PLATAFOMR
-                self.FFMPEG_BINARY = 'ffmpeg'
-            else:
-                raise DeprecationWarning(f"Arquitetura '{platform_name}' ainda não suportada...\n\n"
-                                         f"Versão atual da lib: {self.VERSION}")
-            os.environ['FFMPEG_URL'] = self.FFMPEG_URL
-            os.environ['FFMPEG_BINARY'] = self.FFMPEG_BINARY
-
-        if not os.getenv('INSTALL_DIR'):
-            os.environ['INSTALL_DIR'] = self.INSTALL_DIR
-
-    @property
-    def __read_version(self):
-        """Lê a versão do arquivo __version__.py."""
-        version_file = os.path.join(os.path.dirname(os.path.abspath(__file__)).split('.')[0], '__version__.py')
-        if os.path.isfile(version_file):
-            with open(version_file, 'r') as file:
-                version_line = file.readline().strip()
-                if version_line.startswith('__version__'):
-                    return version_line.split('=')[1].strip().strip("'")
-        return 'Unknown Version'
-
-    def __download_file(self, url: str, local_filename: str):
-        """Baixa um arquivo do URL para o caminho local especificado."""
-        try:
-            response = requests.get(url, stream=True)
-            response.raise_for_status()
-            total_length = int(response.headers.get('content-length', 0))
-
-            with open(local_filename, 'wb') as f:
-                start_time = time.time()
-                downloaded = 0
-
-                for data in response.iter_content(chunk_size=4096):
-                    downloaded += len(data)
-                    f.write(data)
-
-                    elapsed_time = time.time() - start_time
-                    elapsed_time = max(elapsed_time, 0.001)
-                    speed_kbps = (downloaded / 1024) / elapsed_time
-                    percent_done = (downloaded / total_length) * 100
-
-
-        except requests.RequestException as e:
-            raise Exception(f"Erro durante o download: {e}")
-
-    def __extract_zip(self, zip_path: str, extract_to: str):
-        """Descompacta o arquivo ZIP no diretório especificado."""
-        try:
-            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-                zip_ref.extractall(extract_to)
-        except zipfile.BadZipFile as e:
-            sys.stderr.write(f"Erro ao descompactar o arquivo: {e}\n")
-            raise
-        finally:
-            os.remove(zip_path)
-
-    def remove_file(self, file_path: str):
-        """Remove o arquivo ou diretório especificado."""
-        if os.path.exists(file_path):
-            try:
-                shutil.rmtree(file_path, onerror=self.handle_remove_readonly)
-            except Exception as e:
-                print(f"Erro ao remover {file_path}: {e}")
-                raise
-
-    def install_bins(self):
-        """Instala o ffmpeg baixando e descompactando o binário apropriado."""
-        zip_path = os.path.join(self.INSTALL_DIR, "ffmpeg.zip")
-        os.makedirs(self.INSTALL_DIR, exist_ok=True)
-        self.__download_file(self.FFMPEG_URL, zip_path)
-        self.__extract_zip(zip_path, self.INSTALL_DIR)
-        self.remove_file(zip_path)
-        os.environ["PATH"] += os.pathsep + self.INSTALL_DIR
-        return
-
-    def handle_remove_readonly(self, func, path, exc_info):
-        """Callback para lidar com arquivos somente leitura."""
-        os.chmod(path, stat.S_IWRITE)
-        func(path)
-
-
-if __name__ == "__main__":
-    FFmpegExceptions("erro de runtime...")

ffmpeg_for_python/__init__.py

@@ -1,8 +0,0 @@
-# ffmpeg-and-python/__init__.py
-
-from .ffmpeg import FFmpeg
-from .exeptions import FFmpegExceptions
-
-__all__ = ['FFmpeg', 'FFmpegExceptions']
-if __name__ == '__main__':
-    raise RuntimeError("no escope!")

ffmpeg_for_python/__utils.py

@@ -1,78 +0,0 @@
-import platform
-import os
-
-URL_PLATAFOMR = ''
-
-
-def get_processor_info():
-    system = platform.system()
-    architecture = platform.architecture()[0]
-    processor = ''
-    if system == "Windows":
-        processor = platform.processor()
-    elif system in ["Linux", "Darwin"]:  # Darwin é o nome do sistema para macOS
-        try:
-            if system == "Linux":
-                # Obtém informações detalhadas do processador no Linux
-                with open("/proc/cpuinfo") as f:
-                    cpuinfo = f.read()
-                    if "model name" in cpuinfo:
-                        processor = cpuinfo.split("model name")[1].split(":")[1].split("\n")[0].strip()
-                    else:
-                        processor = "Unknown"
-            elif system == "Darwin":
-                # Obtém informações detalhadas do processador no macOS
-                processor = os.popen("sysctl -n machdep.cpu.brand_string").read().strip()
-        except FileNotFoundError:
-            processor = "Unknown"
-    d = (f"System: {system} "
-         f"Architecture: {architecture} "
-         f"Processor: {processor} ")
-    return d
-
-
-# Processa a informação do processador e limpa a string
-data = (get_processor_info().replace('Architecture:', '').replace('System:', '').
-        replace('Processor:', '').strip().split())
-
-# Remove entradas vazias e limpa espaços em branco
-cleaned_data = [item.strip() for item in data if item.strip()]
-
-# Garantindo que há pelo menos três elementos
-if len(cleaned_data) >= 2:
-    system = cleaned_data[0]
-    architecture = cleaned_data[1]
-    processor = ' '.join(cleaned_data[2:])  # Junta o restante como o processador
-
-    URL_BASE_REPO = "https://raw.githubusercontent.com/PauloCesar-dev404/binarios/main/"
-    # Mapeamento para Linux
-    linux_mapping = {
-        "x86_64": "amd64",
-        "i686": "i686",
-        "arm64": "arm64",
-        "armhf": "armhf",
-        "armel": "armel"
-    }
-    # Formata a URL com base no sistema e arquitetura
-    if system == "Linux" and ('intel' in processor.lower() or 'amd' in processor.lower()):
-        url = f"{URL_BASE_REPO}linux/ffmpeg-7.0.2-{linux_mapping.get('x86_64')}.zip"
-    elif system == "Linux" and 'i686' in architecture.lower():
-        url = f"{URL_BASE_REPO}linux/ffmpeg-7.0.2-{linux_mapping.get('i686')}.zip"
-    elif system == "Linux" and 'arm64' in architecture.lower():
-        url = f"{URL_BASE_REPO}linux/ffmpeg-7.0.2-{linux_mapping.get('arm64')}.zip"
-    elif system == "Linux" and 'armhf' in architecture.lower():
-        url = f"{URL_BASE_REPO}linux/ffmpeg-7.0.2-{linux_mapping.get('armhf')}.zip"
-    elif system == "Linux" and 'armel' in architecture.lower():
-        url = f"{URL_BASE_REPO}linux/ffmpeg-7.0.2-{linux_mapping.get('armel')}.zip"
-    elif system == "Windows" and architecture == '64bit':
-        url = f"{URL_BASE_REPO}windows/win-ffmpeg-7.0.2-full-amd64-intel64.zip"
-    else:
-        url = f"Unsupported system or architecture"
-
-    URL_PLATAFOMR = url
-
-else:
-    raise DeprecationWarning("Não foi possível obter seu sistema ....consulte o desenvolvedor!")
-
-if __name__ == '__main__':
-    raise RuntimeError("este é uma função interna!")

ffmpeg_for_python/__version__.py

@@ -1,6 +0,0 @@
-__version__ = '0.3.5'
-__lib_name__ = 'ffmpeg_for_python'
-__autor__ = 'PauloCesar-dev404'
-__repo__ = 'https://github.com/PauloCesar-dev404/ffmpeg-for-python'
-__lib__ = f'https://raw.githubusercontent.com/PauloCesar-dev404/ffmpeg-for-python/main/{__lib_name__}-{__version__}-py3-none-any.whl'
-__source__ = f'https://raw.githubusercontent.com/PauloCesar-dev404/ffmpeg-for-python/main/{__lib_name__}-{__version__}.tar.gz'

ffmpeg_for_python/exeptions.py

@@ -1,91 +0,0 @@
-import time
-
-INPUT_ERROR = [
-    'Error opening input: No such file or directory',
-    'Error opening input: Permission denied',
-    'Error opening input: Invalid argument',
-    'Error opening input: Protocol not found',
-    'Error opening input: Unsupported protocol',
-    'Error opening input: File format not recognized',
-    'Error opening input: Could not open file',
-    'Error opening input: Invalid data found when processing input',
-    'Error opening input: Input stream is empty',
-    'Error opening input: Cannot open file for reading',
-    'Error opening input: File is too short',
-    'Error opening input: End of file while parsing input',
-    'Error opening input: Codec not found',
-    'Error opening input: No decoder for codec',
-    'Error opening input: Stream not found',
-    'Error opening input: Stream codec not found',
-    'Error opening input: Stream index out of range',
-    'Error opening input: Invalid timestamp',
-    'Error opening input: Corrupt file',
-    'Error opening input: Unsupported codec',
-    'Error opening input: Failed to initialize filter',
-    'Error opening input: Error while opening codec',
-    'Error opening input: Device not found',
-    'Error opening input: Device or resource busy',
-    'Error opening input: Invalid option',
-    'Error opening input: Unable to seek',
-    'Error opening input: Input format not found'
-]
-OUTPUT_ERROR = [
-    'Error opening output file: No such file or directory',
-    'Error opening output file: Permission denied',
-    'Error opening output file: Invalid argument',
-    'Error opening output file: Unsupported protocol',
-    'Error opening output file: Protocol not found',
-    'Error opening output file: File format not recognized',
-    'Error opening output file: Could not open file for writing',
-    'Error opening output file: Disk full or quota exceeded',
-    'Error opening output file: Cannot create file',
-    'Error opening output file: Invalid data found when processing output',
-    'Error opening output file: Output stream not found',
-    'Error opening output file: Cannot write to file',
-    'Error opening output file: File already exists',
-    'Error opening output file: Unsupported codec',
-    'Error opening output file: Codec not found',
-    'Error opening output file: Cannot open codec for writing',
-    'Error opening output file: Failed to initialize filter',
-    'Error opening output file: Invalid option',
-    'Error opening output file: Invalid timestamp',
-    'Error opening output file: Corrupt file',
-    'Error opening output file: Device or resource busy',
-    'Error opening output file: Cannot seek',
-    'Error opening output file: Stream index out of range',
-    'Error opening output file: Stream codec not found'
-]
-ERROS = []
-for er in INPUT_ERROR:
-    ERROS.append(er)
-for er in OUTPUT_ERROR:
-    ERROS.append(er)
-
-
-class FFmpegExceptions(Exception):
-    def __init__(self, message: str):
-        super().__init__(message)
-
-    def __str__(self):
-        """
-        Retorna a representação em string da exceção.
-
-        Returns:
-            str: Mensagem de erro formatada com detalhes adicionais, se presentes.
-        """
-
-        return super().__str__()
-
-
-def wraper_erros(line: str):
-    """Verifica se a linha de saida do ffmpeg está no dict de erros e retorna sua categoria"""
-
-    if "Error" in line:
-        erro = line.split('Error')[1]
-        return erro.strip()
-    elif 'already exists. Overwrite? [y/N]' in line:
-        erro = line.split('File')[1]
-        return erro.strip()
-
-
-