ffmpeg-for-python 0.3__py3-none-any.whl

ffmpeg_for_python/__config__.py

@@ -0,0 +1,147 @@
+import struct
+import sys
+import os
+import requests
+import zipfile
+import shutil
+import stat
+from .exeptions import *
+from .__utils import URL_PLATAFOMR,system
+
+lib_name = 'ffmpeg_for_python'
+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(self.is_venv, lib_name, 'ffmpeg-bin')
+        os.makedirs(PATH, exist_ok=True)
+        dirpath = PATH
+        self.INSTALL_DIR = os.getenv('INSTALL_DIR', dirpath)
+        self.VENV_PATH = os.getenv('VENV_PATH', self.INSTALL_DIR)
+        self.configure()
+
+    @property
+    def is_venv(self):
+        """Verifica se o script está sendo executado em um ambiente virtual e retorna o diretório de bibliotecas globais.
+     Se estiver em um ambiente virtual, retorna o diretório de bibliotecas do ambiente virtual. Caso contrário, retorna
+     o diretório de bibliotecas globais do Python global."""
+        if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+            # Retorna o diretório de bibliotecas do ambiente virtual
+            return os.path.join(os.path.dirname(os.path.abspath(sys.executable)), 'Lib',
+                                'site-packages') if os.name == 'nt' else os.path.join \
+                (os.path.dirname(os.path.abspath(sys.executable)), 'lib',
+                 'python{0.major}.{0.minor}'.format(sys.version_info), 'site-packages')
+        else:
+            # Retorna o diretório de bibliotecas globais do Python global
+            return os.path.join(os.path.dirname(os.path.abspath(sys.executable)), 'Lib',
+                                'site-packages') if os.name == 'nt' else os.path.join \
+                (os.path.dirname(os.path.abspath(sys.executable)), 'lib',
+                 'python{0.major}.{0.minor}'.format(sys.version_info), 'site-packages')
+
+    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
+
+                    sys.stdout.write(
+                        f"\rBaixando Binários do ffmpeg: {percent_done:.2f}% | Velocidade: {speed_kbps:.2f} KB/s | "
+                        f"Tempo decorrido: {int(elapsed_time)}s")
+                    sys.stdout.flush()
+                sys.stdout.write("\nDownload completo.\n")
+                sys.stdout.flush()
+
+        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)
+        bina = os.path.join(self.INSTALL_DIR, self.FFMPEG_BINARY)
+        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'
+__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,178 @@
+import os
+import platform
+import subprocess
+import time
+from typing import List, Optional
+from .exeptions import wraper_erros, FFmpegExceptions
+from .__config__ import Configurate
+
+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 padrão e de erro.
+
+        Returns:
+            Optional[str]: A saída do comando, se capturada. Caso contrário, None.
+        """
+
+        configs = self.__oculte_comands_your_system.get('startupinfo')
+        # Armazenar a saída completa, se for necessário capturá-la
+        output = []
+
+        # 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:
+            # Lê a saída de erro padrão (stderr) em tempo real
+            for linha in process.stderr:
+                time.sleep(0.01)
+                linha_filtrada = wraper_erros(linha)
+                if linha_filtrada:
+                    process.terminate()
+                    raise FFmpegExceptions(message=f'Erro na execução do ffmpeg: "{linha_filtrada}"')
+                else:
+                    if capture_output:
+                        print(linha.strip())
+
+            # Espera o processo terminar e captura a saída padrão (stdout)
+            stdout, stderr = process.communicate()
+
+            if capture_output:
+                output.extend(stdout.splitlines())
+                return '\n'.join(output)
+            else:
+                return stdout.strip() if stdout else None
+
+    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 copy(self) -> 'FFmpeg':
+        """Adiciona o parâmetro '-c copy' ao comando FFm"""
+        self.__command.extend(['-c', 'copy'])
+        return self
+
+    @property
+    def reset(self) -> 'FFmpeg':
+        """Reseta o comando para reutilização do objeto."""
+        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):
+        """Identifica o sistema do usuário e cria um dicionário de parâmetros para ocultar saídas de janelas."""
+        system_user = platform.system()
+        startupinfo_options = {}
+
+        if system_user == "Windows":
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+            startupinfo.wShowWindow = subprocess.SW_HIDE
+            startupinfo_options['startupinfo'] = startupinfo
+
+        elif system_user in ["Linux", "Darwin"]:
+            startupinfo_options['stdout'] = subprocess.DEVNULL
+            startupinfo_options['stderr'] = subprocess.DEVNULL
+            startupinfo_options['stdin'] = subprocess.DEVNULL
+
+        else:
+            raise NotImplementedError(f"System {system_user} not supported")
+
+        return startupinfo_options
+
+

ffmpeg_for_python-0.3.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: ffmpeg-for-python
+Version: 0.3
+Summary: Wrapper para o binário FFmpeg
+Author: PauloCesar-dev404
+Author-email: paulocesar0073dev404@gmail.com
+License: MIT
+Project-URL: Código Fonte, https://raw.githubusercontent.com/PauloCesar-dev404/ffmpeg-for-python/main/ffmpeg_for_python-0.3.tar.gz
+Project-URL: lib, https://raw.githubusercontent.com/PauloCesar-dev404/ffmpeg-for-python/main/ffmpeg_for_python-0.3-py3-none-any.whl
+Project-URL: GitHub, https://github.com/PauloCesar-dev404/ffmpeg-for-python
+Project-URL: Bugs/Melhorias, https://github.com/PauloCesar-dev404/ffmpeg-for-python/issues
+Project-URL: Documentação, https://github.com/PauloCesar-dev404/ffmpeg-for-python/wiki
+Keywords: ffmpeg
+Platform: any
+Requires: requests
+Description-Content-Type: text/markdown
+
+# ffmpeg-for-python
+
+Wrapper para o binário FFmpeg, permitindo o uso de comandos FFmpeg via Python. Para saber como usar FFmpeg, consulte a documentação no [site oficial](https://ffmpeg.org/ffmpeg.html)
+
+
+---
+
+
+**conversão básica**
+```python
+
+from ffmpeg_for_python import FFmpeg, FFmpegExceptions
+
+# Cria uma instância do wrapper FFmpeg
+ffmpeg = FFmpeg()
+# Caminho do arquivo de entrada e saída
+input_video = 'input_video.mp4'
+output_video = 'output_video.mkv'
+
+# Define o arquivo de entrada e o arquivo de saída
+(ffmpeg
+        .overwrite_output  # Sobrescrever se existir
+        .input(input_video)  # Vídeo de entrada
+        .output(output_video)  # Vídeo final
+)
+
+    # Executa o comando FFmpeg e exibe a saída
+try:
+        ffmpeg.run(capture_output=True)
+except FFmpegExceptions as e:
+        print("Erro ao executar FFmpeg:", e)
+```
+---
+**remux audio e video**
+```python
+from ffmpeg_for_python import FFmpeg, FFmpegExceptions
+# Cria uma instância do wrapper FFmpeg
+ffmpeg = FFmpeg()
+# Caminho dos arquivos de entrada e saída
+input_video = 'input_video.mp4'
+input_audio = 'input_audio.mp4'
+output_video = 'output_video.mp4'
+# Define os arquivos de entrada e o arquivo de saída
+(ffmpeg
+        .overwrite_output  # Sobrescrever se existir
+        .input(input_video)  # Vídeo de entrada
+        .input(input_audio)  # Áudio
+        .args(arguments=['-c:a', 'copy', '-c:v', 'copy'])  # Parâmetros de cópia de áudio e vídeo
+        .output(output_video)  # Vídeo final
+)
+
+# Executa o comando FFmpeg e exibe a saída
+try:
+        ffmpeg.run(capture_output=True)
+except FFmpegExceptions as e:
+        print("Erro ao executar FFmpeg:", e)
+```
+---

ffmpeg_for_python-0.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+ffmpeg_for_python/__config__.py,sha256=B2LF1nf7v0FcJ3DDKCZRVPHUodU4XNfvnJwuIK0gF2U,6548
+ffmpeg_for_python/__init__.py,sha256=-BMtoX8Yof_pnHra2OzoV3faxMubpMvUedMy8TqI8dc,214
+ffmpeg_for_python/__utils.py,sha256=Qy3J5f4lOIPcSNbTwiawfiHjYPdZ_tq7hafStnnqwA4,3263
+ffmpeg_for_python/__version__.py,sha256=uMlC0HJUZrkivMWKDpg07pgatHEw9b_n8TZevsGw4mk,420
+ffmpeg_for_python/exeptions.py,sha256=tg-TBdaq_NHxZOCAhkMttzwtJVILPAQPLOKqofe5PPA,3627
+ffmpeg_for_python/ffmpeg.py,sha256=KExeNnI1Qjq-lsQsc-ZeEY7gPCmQaLaoHE6RuBKMAk8,6536
+ffmpeg_for_python/ffmpeg-bin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ffmpeg_for_python/ffmpeg-bin/readme.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ffmpeg_for_python-0.3.dist-info/METADATA,sha256=pfc4-8H1mfXzEyHaSggyJFB3JbgcHAllnvaXYgFsEgE,2539
+ffmpeg_for_python-0.3.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+ffmpeg_for_python-0.3.dist-info/top_level.txt,sha256=7do-X2t_RBNs6_hpK7PTWKiLk1ZPGi3Y066m0xigWFU,18
+ffmpeg_for_python-0.3.dist-info/RECORD,,

ffmpeg_for_python-0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ffmpeg_for_python-0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+ffmpeg_for_python