udemy-userAPI 0.3.5__py3-none-any.whl → 0.3.6__py3-none-any.whl

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()
-
-
-

ffmpeg_for_python/ffmpeg.py

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