udemy-userAPI 0.3.7__py3-none-any.whl → 0.3.8__py3-none-any.whl

animation_consoles/__init__.py

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

animation_consoles/animation.py

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,8 @@
+# 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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,6 @@
+__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

@@ -0,0 +1,91 @@
+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()
+
+
+

ffmpeg_for_python/ffmpeg.py

@@ -0,0 +1,203 @@
+import os
+import platform
+import subprocess
+import time
+from typing import List
+from .__config__ import Configurate
+from .exeptions import wraper_erros, FFmpegExceptions
+
+parser = Configurate()
+parser.configure()
+ffmpeg_binarie = os.path.join(parser.INSTALL_DIR, parser.FFMPEG_BINARY)
+
+
+def ffmpeg(cls):
+    """Decorador que instancia automaticamente a classe FFmpeg."""
+
+    def wrapper(*args, **kwargs):
+        # Cria e retorna uma instância da classe FFmpeg
+        instance = cls(*args, **kwargs)
+        return instance
+
+    return wrapper
+
+
+@ffmpeg
+class FFmpeg:
+    """Wrapper para o binário FFmpeg, permitindo o uso de comandos FFmpeg via Python."""
+
+    def __init__(self):
+        # Verifica se o binário do FFmpeg existe
+        if not self.__verify_path(bin_path=ffmpeg_binarie, path_type='file'):
+            parser.install_bins()
+        self.__ffmpeg_path = str(ffmpeg_binarie)
+        self.__command = [self.__ffmpeg_path]
+        self.__overwrite_output = False
+
+    def args(self, arguments: List[str]) -> 'FFmpeg':
+        """Adiciona múltiplos argumentos personalizados ao comando FFmpeg."""
+        if not all(isinstance(arg, str) for arg in arguments):
+            raise TypeError("All arguments should be provided as strings.")
+        self.__command.extend(arguments)
+        return self
+
+    def run(self, capture_output: bool = False):
+        """Executa o comando FFmpeg construído.
+
+        Args:
+            capture_output (bool): Se verdadeiro, captura a saída e printa no console.
+                                   Se False, a saída é retornada assincronamente em tempo real.
+
+        Yields:
+            str: Cada linha da saída filtrada do FFmpeg quando capture_output é False.
+        """
+
+        configs = self.__oculte_comands_your_system.get('startupinfo')
+
+        # Executa o comando utilizando subprocess
+        with subprocess.Popen(
+                self.__command,
+                startupinfo=configs,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                stdin=subprocess.PIPE,
+                text=True,
+                bufsize=1,  # Linha por linha
+                universal_newlines=True  # Garante que novas linhas sejam interpretadas corretamente
+        ) as process:
+            try:
+                # Lê a saída de erro padrão (stderr) em tempo real
+                for linha in process.stderr:
+                    time.sleep(0.01)  # Simulação de latência, opcional
+
+                    # Filtra a linha de erro padrão
+                    linha_filtrada = wraper_erros(linha)
+
+                    if linha_filtrada:
+                        # Se houver um erro detectado, o processo é encerrado
+                        process.terminate()
+                        raise FFmpegExceptions(message=f'Erro na execução do ffmpeg: "{linha_filtrada}"')
+                    else:
+                        if capture_output:
+                            # Se `capture_output` estiver ativado, imprime a saída
+                            print(linha.strip())
+                        else:
+                            # Retorna a linha assincronamente quando capture_output é False
+                            yield linha.strip()
+
+                # Aguarda a conclusão do processo
+                process.wait()
+
+            except Exception as e:
+                process.terminate()
+                raise FFmpegExceptions(message=f'Erro no processo FFmpeg: {str(e)}')
+
+    def input(self, file_path: str) -> 'FFmpeg':
+        """Define o arquivo de entrada para o FFmpeg."""
+        cmd = ['-i', file_path]
+        self.args(cmd)
+        return self
+
+    def output(self, output_path: str) -> 'FFmpeg':
+        """Define o arquivo de saída para o FFmpeg e verifica se a sobrescrita está permitida."""
+        if os.path.exists(output_path):
+            if not self.__overwrite_output:
+                raise FFmpegExceptions(f"O arquivo de saída '{output_path}' já existe! Use 'overwrite_output' para "
+                                       f"sobrescrevê-lo.")
+
+        # Adiciona o arquivo de saída ao comando
+        cmd = [output_path]
+        self.args(cmd)
+        return self
+
+    @property
+    def overwrite_output(self):
+        """
+        Adiciona o parâmetro '-y' ao comando FFmpeg, o que permite sobrescrever o arquivo de saída
+        caso ele já exista.
+
+        Importante: Esta propriedade deve ser definida antes dos parâmetros de entrada e saída
+        para garantir que o comando FFmpeg seja construído corretamente. Caso contrário, o comando
+        pode não ser executado como esperado.
+
+        Returns:
+            FFmpeg: Retorna a instância atual para encadeamento de métodos.
+        """
+        self.__overwrite_output = True
+        cmd = ['-y']
+        self.args(cmd)
+        return self
+
+    @property
+    def hide_banner(self) -> 'FFmpeg':
+        """oculta o baner do ffmpeg"""
+        self.__command.extend(['-hide_banner'])
+        return self
+
+    @property
+    def copy(self) -> 'FFmpeg':
+        """Adiciona o parâmetro '-c copy"""
+        self.__command.extend(['-c', 'copy'])
+        return self
+
+    @property
+    def copy_codecs(self):
+        """para remuxar"""
+        self.__command.extend(['-c:a', 'copy', '-c:v', 'copy'])
+        return self
+
+    def reset_ffmpeg(self) -> 'FFmpeg':
+        """Reseta o comando para reutilização do objeto,isso é necessário em caso de uso em loops,
+        a cada execução execute o reset para ter certeza que estar limpo o cache de comandos"""
+        self.__command = [self.__ffmpeg_path]
+        return self
+
+    @staticmethod
+    def __verify_path(bin_path, path_type: str) -> bool:
+        """
+        Verifica se um caminho de arquivo ou diretório existe.
+
+        Args:
+            bin_path : O caminho a ser verificado.
+            path_type (str): O tipo de caminho ('file' para arquivo, 'dir' para diretório).
+
+        Returns:
+            bool: True se o caminho existir e for do tipo especificado, False caso contrário.
+        """
+        if path_type == 'file':
+            return os.path.isfile(bin_path)
+        elif path_type == 'dir':
+            return os.path.isdir(bin_path)
+        else:
+            raise ValueError("Invalid path_type. Use 'file' or 'dir'.")
+
+    @property
+    def __oculte_comands_your_system(self) -> dict:
+        """Identifica o sistema do usuário e cria um dicionário de parâmetros para ocultar saídas de janelas e do
+        terminal."""
+        system_user = platform.system()
+        startupinfo_options = {}
+
+        if system_user == "Windows":
+            # Configuração específica para ocultar o terminal no Windows
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+            startupinfo.wShowWindow = subprocess.SW_HIDE
+            startupinfo_options['startupinfo'] = startupinfo
+
+            # Definindo stdout, stderr e stdin para DEVNULL para esconder saídas
+            startupinfo_options['stdout'] = subprocess.DEVNULL
+            startupinfo_options['stderr'] = subprocess.DEVNULL
+            startupinfo_options['stdin'] = subprocess.DEVNULL
+
+        elif system_user in ["Linux", "Darwin"]:
+            # Para Linux e macOS, ocultar stdout, stderr e stdin
+            startupinfo_options['stdout'] = subprocess.DEVNULL
+            startupinfo_options['stderr'] = subprocess.DEVNULL
+            startupinfo_options['stdin'] = subprocess.DEVNULL
+
+        else:
+            # Exceção para sistemas não suportados
+            raise NotImplementedError(f"O sistema {system_user} não é suportado para ocultação de comandos.")
+
+        return startupinfo_options