docmumentação da api

`EncryptSuport`

suporte a operações de criptografia AES-128 relacionadas a M3U8.

Fornece métodos para obter a URL da chave de criptografia e o IV (vetor de inicialização) associado, necessários para descriptografar conteúdos M3U8 protegidos por AES-128.

Métodos

get_url_key_m3u8: Extrai a URL da chave de criptografia e o IV de um conteúdo M3U8.

`get_url_key_m3u8(m3u8_content, player, headers=None)` `staticmethod`

Extrai a URL da chave de criptografia AES-128 e o IV (vetor de inicialização) de um conteúdo M3U8.

Este método analisa o conteúdo M3U8 para localizar a URL da chave de criptografia e o IV, se disponível. Em seguida, faz uma requisição HTTP para obter a chave em formato hexadecimal.

Parameters:

Name	Type	Description	Default
`m3u8_content`	`str`	String contendo o conteúdo do arquivo M3U8.	required
`player`	`str`	URL base para formar o URL completo da chave, se necessário.	required
`headers`	`dict`	Cabeçalhos HTTP opcionais para a requisição da chave. Se não fornecido, cabeçalhos padrão serão utilizados.	`None`

Returns:

Name	Type	Description
`dict`		Um dicionário contendo as seguintes chaves: - 'key' (str): A chave de criptografia em hexadecimal. - 'iv' (str): O vetor de inicialização (IV) em hexadecimal, se disponível.
		Caso não seja possível extrair a URL da chave ou o IV, retorna None.

Examples:

m3u8_content = '''
#EXTM3U
#EXT-X-KEY:METHOD=AES-128,URI="https://example.com/key.bin",IV=0x1234567890abcdef
#EXTINF:10.0,
http://example.com/segment1.ts
'''
player = "https://example.com"
result = EncryptSuport.get_url_key_m3u8(m3u8_content, player)
print(result)
# Saída esperada:
# {'key': 'aabbccddeeff...', 'iv': '1234567890abcdef'}

# Com cabeçalhos personalizados
headers = {
    "Authorization": "Bearer your_token"
}
result = EncryptSuport.get_url_key_m3u8(m3u8_content, player, headers=headers)
print(result)

Raises:

Type	Description
`HTTPError`	Se a requisição HTTP para a chave falhar.

`M3U8Playlist`

análise de maneira mais limpa de m3u8

`__get_version_manifest(content)`

Obtém a versão do manifesto #EXTM em uma playlist m3u8.

EXT-X-VERSION:4

EXT-X-VERSION:3

etc... :param content: Conteúdo da playlist m3u8. :return: A versão do manifesto encontrada ou None se não for encontrado.

`__load_playlist()`

Método privado para carregar a playlist a partir de uma URL ou arquivo.

`filter_resolution(filtering)`

Filtra e retorna a URL do segmento com a resolução especificada.

Parameters:

Name	Type	Description	Default
`filtering`	`str`	Resolução desejada (ex: '1920x1080').	required

Returns:

Type	Description
	Optional[str]: URL do segmento correspondente à resolução, ou None se não encontrado.

`get_codecs()`

obter codecs na playlist

`get_resolutions()`

Retorna as resoluções disponíveis na playlist M3U8.

Returns:

Name	Type	Description
`list`		Lista de resoluções.

`info()`

Retorna informações básicas sobre a playlist.

Returns:

Name	Type	Description
`dict`		Informações sobre a URL, versão do manifesto, número de segmentos, tipo da playlist, se é criptografada e URIs dos segmentos.

`number_segments()`

Retorna o número total de segmentos na playlist.

Returns:

Name	Type	Description
`int`		Número de segmentos.

`playlist_type()`

Retorna o tipo da playlist M3U8.

Returns:

Name	Type	Description
`str`		Tipo da playlist.

`this_encrypted()`

Verifica se a playlist M3U8 está criptografada.

Returns:

Name	Type	Description
`bool`		True se a playlist estiver criptografada, False caso contrário.

`uris()`

Retorna a lista de URIs dos segmentos.

Returns:

Name	Type	Description
`list`		Lista de URIs dos segmentos.

`version_manifest()`

Retorna a versão do manifesto da playlist M3U8.

Returns:

Name	Type	Description
`str`		Versão do manifesto.

`M3u8Analyzer`

`init()`

análise e manipulação de streams M3U8 de maneira bruta

`get_audio_playlist(m3u8_content)` `staticmethod`

Extrai o URL da playlist de áudio de um conteúdo M3U8.

Este método analisa o conteúdo fornecido de um arquivo M3U8 e retorna o URL da playlist de áudio incluída na playlist M3U8. O método busca a linha que contém a chave #EXT-X-MEDIA e extrai a URL associada ao áudio.

Parameters:

Name	Type	Description	Default
`m3u8_content`	`str`	Conteúdo da playlist M3U8 como uma string. Deve incluir informações sobre áudio se disponíveis.	required

Returns:

Name	Type	Description
`str`		URL da playlist de áudio encontrada no conteúdo M3U8. Retorna `None` se a URL da playlist de áudio não for encontrada.

Examples:

# Exemplo 1
content = '''
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="English",DEFAULT=YES,URI="http://example.com/audio.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=256000,AUDIO="audio"
http://example.com/stream.m3u8
'''
url = M3u8Analyzer.get_audio_playlist(content)
print(url)  # Saída esperada: 'http://example.com/audio.m3u8'

# Exemplo 2
content = '''
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="French",DEFAULT=NO,URI="http://example.com/french_audio.m3u8"
#EXT-X-STREAM-INF:BANDWIDTH=256000,AUDIO="audio"
http://example.com/stream.m3u8
'''
url = M3u8Analyzer.get_audio_playlist(content)
print(url)  # Saída esperada: 'http://example.com/french_audio.m3u8'

# Exemplo 3
content = '''
#EXTM3U
#EXT-X-VERSION:3
#EXT-X-STREAM-INF:BANDWIDTH=256000
http://example.com/stream.m3u8
'''
url = M3u8Analyzer.get_audio_playlist(content)
print(url)  # Saída esperada: None

`get_high_resolution(m3u8_content)` `staticmethod`

Obtém a maior resolução disponível em um arquivo M3U8 e o URL correspondente.

Este método analisa o conteúdo de um arquivo M3U8 para identificar a maior resolução disponível entre os fluxos de vídeo listados. Também retorna o URL associado a essa maior resolução, se disponível.

Parameters:

Name	Type	Description	Default
`m3u8_content`	`str`	O conteúdo do arquivo M3U8 como uma string. Este conteúdo deve incluir as tags e atributos típicos de uma playlist HLS.	required

Returns:

Name	Type	Description
`tuple`		Uma tupla contendo: - str: A maior resolução disponível no formato 'Largura x Altura' (ex.: '1920x1080'). - str: O URL correspondente à maior resolução. Se o URL não for encontrado, retorna None. Se o tipo de playlist não contiver resoluções, retorna uma mensagem indicando o tipo de playlist.

Raises:

Type	Description
`ValueError`	Se o conteúdo do M3U8 não contiver resoluções e a função não conseguir determinar o tipo de playlist.

Examples:

m3u8_content = '''
#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=500000,RESOLUTION=640x360
http://example.com/360p.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1000000,RESOLUTION=1280x720
http://example.com/720p.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=3000000,RESOLUTION=1920x1080
http://example.com/1080p.m3u8
'''
result = M3u8Analyzer.get_high_resolution(m3u8_content)
print(result)  # Saída esperada: ('1920x1080', 'http://example.com/1080p.m3u8')

m3u8_content_no_resolutions = '''
#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=500000
http://example.com/360p.m3u8
'''
result = M3u8Analyzer.get_high_resolution(m3u8_content_no_resolutions)
print(result)  # Saída esperada: 'Playlist type: <TIPO DA PLAYLIST> not resolutions...'

`get_m3u8(url_m3u8, headers=None, save_in_file=None, timeout=None)` `staticmethod`

Obtém o conteúdo de um arquivo M3U8 a partir de uma URL HLS.

Este método permite acessar, visualizar ou salvar playlists M3U8 utilizadas em transmissões de vídeo sob demanda.

Args: url_m3u8 (str): A URL do arquivo M3U8 que você deseja acessar. headers (dict, optional): Cabeçalhos HTTP opcionais para a requisição. Se não forem fornecidos, serão usados cabeçalhos padrão. save_in_file (str, optional): Nome do arquivo para salvar o conteúdo M3U8. Se fornecido, o conteúdo da playlist será salvo no diretório atual com a extensão .m3u8. timeout (int, optional): Tempo máximo (em segundos) para aguardar uma resposta do servidor. O padrão é 20 segundos.

Returns:

Name	Type	Description
`str`		O conteúdo do arquivo M3U8 como uma string se a requisição for bem-sucedida.
`None`		Se a requisição falhar ou se o servidor não responder com sucesso.

Raises:

Type	Description
`ValueError`	Se a URL não for válida ou se os headers não forem um dicionário.
`ConnectionAbortedError`	Se o servidor encerrar a conexão inesperadamente.
`ConnectionRefusedError`	Se a conexão for recusada pelo servidor.
`TimeoutError`	Se o tempo de espera pela resposta do servidor for excedido.
`ConnectionError`	Se não for possível se conectar ao servidor por outros motivos.

Example

from m3u8_analyzer import M3u8Analyzer

url = "https://example.com/playlist.m3u8"
headers = {"User-Agent": "Mozilla/5.0"}
playlist_content = M3u8Analyzer.get_m3u8(url, headers=headers, save_in_file="minha_playlist", timeout=30)

if playlist_content:
    print("Playlist obtida com sucesso!")
else:
    print("Falha ao obter a playlist.")

`get_player_playlist(m3u8_url)` `staticmethod`

Obtém o caminho do diretório base do arquivo M3U8, excluindo o nome do arquivo.

Este método analisa a URL fornecida do arquivo M3U8 e retorna o caminho do diretório onde o arquivo M3U8 está localizado. A URL deve ser uma URL completa e o método irá extrair o caminho do diretório base.

Parameters:

Name	Type	Description	Default
`m3u8_url`	`str`	A URL completa do arquivo M3U8. Pode incluir o nome do arquivo e o caminho do diretório.	required

Returns:

Name	Type	Description
`str`	`str`	O caminho do diretório onde o arquivo M3U8 está localizado. Se a URL não contiver um arquivo M3U8, retornará uma string vazia.

Examples:

# Exemplo 1
url = 'http://example.com/videos/playlist.m3u8'
path = M3u8Analyzer.get_player_playlist(url)
print(path)  # Saída esperada: 'http://example.com/videos/'

# Exemplo 2
url = 'https://cdn.example.com/streams/segment.m3u8'
path = M3u8Analyzer.get_player_playlist(url)
print(path)  # Saída esperada: 'https://cdn.example.com/streams/'

# Exemplo 3
url = 'https://example.com/playlist.m3u8'
path = M3u8Analyzer.get_player_playlist(url)
print(path)  # Saída esperada: 'https://example.com/'

# Exemplo 4
url = 'https://example.com/videos/'
path = M3u8Analyzer.get_player_playlist(url)
print(path)  # Saída esperada: ''

`get_segments(content)` `staticmethod`

Extrai URLs de segmentos de uma playlist M3U8 e fornece informações detalhadas sobre os segmentos.

Este método analisa o conteúdo de uma playlist M3U8 para extrair URLs de segmentos, identificar resoluções associadas, e retornar um dicionário com informações sobre as URLs dos segmentos, a quantidade total de segmentos, e a ordem de cada URI.

Parameters:

Name	Type	Description	Default
`content`	`str`	Conteúdo da playlist M3U8 como uma string. Não deve ser uma URL. Deve incluir as informações sobre segmentos e, opcionalmente, informações sobre resoluções e URLs de stream.	required

Returns:

Name	Type	Description
`dict`	`Dict[str, List[Tuple[str, str]]]`	Um dicionário com as seguintes chaves: - 'uris' (List[str]): Lista de URLs dos segmentos. - 'urls' (List[str]): Lista de URLs de stream extraídas do conteúdo. - 'len' (int): Contagem total de URLs de stream encontradas. - 'enumerated_uris' (List[Tuple[int, str]]): Lista de tuplas contendo a ordem e o URL de cada segmento. - 'resolutions' (Dict[str, str]): Dicionário mapeando resoluções para suas URLs correspondentes.

Raises:

Type	Description
`ValueError`	Se o conteúdo fornecido for uma URL em vez de uma string de conteúdo M3U8.

Examples:

# Exemplo 1: Conteúdo simples de M3U8 com URLs de segmentos e stream
content = '''
#EXTM3U
#EXTINF:10.0,
http://example.com/segment1.ts
#EXTINF:10.0,
http://example.com/segment2.ts
#EXT-X-STREAM-INF:BANDWIDTH=256000,RESOLUTION=1280x720
http://example.com/stream_720p.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=512000,RESOLUTION=1920x1080
http://example.com/stream_1080p.m3u8
'''
result = M3u8Analyzer.get_segments(content)
print(result)
# Saída esperada:
# {
#     'uris': ['http://example.com/segment1.ts', 'http://example.com/segment2.ts'],
#     'urls': ['http://example.com/stream_720p.m3u8', 'http://example.com/stream_1080p.m3u8'],
#     'len': 2,
#     'enumerated_uris': [(1, 'http://example.com/segment1.ts'), (2, 'http://example.com/segment2.ts')],
#     'resolutions': {'1280x720': 'http://example.com/stream_720p.m3u8', '1920x1080': 'http://example.com/stream_1080p.m3u8'}
# }

# Exemplo 2: Conteúdo sem informações de resolução
content = '''
#EXTM3U
#EXTINF:10.0,
http://example.com/segment1.ts
#EXTINF:10.0,
http://example.com/segment2.ts
'''
result = M3u8Analyzer.get_segments(content)
print(result)
# Saída esperada:
# {
#     'uris': ['http://example.com/segment1.ts', 'http://example.com/segment2.ts'],
#     'urls': [],
#     'len': 0,
#     'enumerated_uris': [(1, 'http://example.com/segment1.ts'), (2, 'http://example.com/segment2.ts')],
#     'resolutions': {}
# }

`get_type_m3u8_content(m3u8_content)` `staticmethod`

Determina o tipo de conteúdo de um arquivo M3U8 (Master ou Segmentos).

Este método analisa o conteúdo de um arquivo M3U8 para identificar se ele é do tipo 'Master', 'Master encrypted', 'Segments', 'Segments encrypted', 'Segments Master', ou 'Desconhecido'. A identificação é baseada na presença de tags e chaves específicas no conteúdo da playlist M3U8.

Parameters:

Name	Type	Description	Default
`m3u8_content`	`str`	O conteúdo do arquivo M3U8 como uma string. Pode ser uma URL ou o próprio conteúdo da playlist.	required

Returns:

Name	Type	Description
`str`	`str`	O tipo de conteúdo identificado. Os possíveis valores são: - 'Master': Playlist mestre sem criptografia. - 'Master encrypted': Playlist mestre com criptografia. - 'Segments': Playlist de segmentos sem criptografia. - 'Segments encrypted': Playlist de segmentos com criptografia. - 'Segments .ts': Playlist de segmentos com URLs terminando em '.ts'. - 'Segments .m4s': Playlist de segmentos com URLs terminando em '.m4s'. - 'Segments Master': Playlist de segmentos com URLs variadas. - 'Desconhecido': Se o tipo não puder ser identificado.

Examples:

m3u8_content_master = '''
#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=500000
http://example.com/master.m3u8
'''
result = M3u8Analyzer.get_type_m3u8_content(m3u8_content_master)
print(result)  # Saída esperada: 'Master'

m3u8_content_master_encrypted = '''
#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=500000
#EXT-X-KEY:METHOD=AES-128,URI="http://example.com/key.key"
http://example.com/master.m3u8
'''
result = M3u8Analyzer.get_type_m3u8_content(m3u8_content_master_encrypted)
print(result)  # Saída esperada: 'Master encrypted'

m3u8_content_segments = '''
#EXTM3U
#EXTINF:10,
http://example.com/segment1.ts
#EXTINF:10,
http://example.com/segment2.ts
'''
result = M3u8Analyzer.get_type_m3u8_content(m3u8_content_segments)
print(result)  # Saída esperada: 'Segments .ts'

m3u8_content_unknown = '''
#EXTM3U
#EXTINF:10,
http://example.com/unknown_segment
'''
result = M3u8Analyzer.get_type_m3u8_content(m3u8_content_unknown)
print(result)  # Saída esperada: 'Segments Master'

Raises:

Type	Description
`Exception`	Em caso de erro durante o processamento do conteúdo, o método retornará uma mensagem de erro descritiva.

`M3u8Downloader`

Requer que o ffmpeg esteja em seu ambiente

`__clear_line()` `staticmethod`

Limpa a linha atual no terminal de forma compatível com diferentes sistemas.

Essa função utiliza o caractere de retrocesso para mover o cursor para o início da linha e sobrescreve o conteúdo da linha com espaços em branco, limpando assim a linha no terminal.

`__descriptografar_segmento(path, key, iv, logs=None)` `staticmethod`

Descriptografa um segmento de vídeo se necessário.

Parameters:

Name	Type	Description	Default
`path`	`str`	Caminho do arquivo a ser descriptografado.	required
`key`	`bytes`	Chave de descriptografia em bytes.	required
`iv`	`bytes`	IV (vetor de inicialização) em bytes.	required
`logs`	`bool`	Se True, exibe a barra de progresso.	`None`

Returns: None

`__ffmpeg_concatener(output, extension)` `staticmethod`

Concatena os segmentos de vídeo em um único arquivo de vídeo usando FFmpeg.

Parameters:

Name	Type	Description	Default
`output`	`str`	Caminho de saída para o vídeo final, incluindo o nome do arquivo e extensão (ex: 'dir/nome.mp4').	required
`extension`	`str`	Extensão dos arquivos de vídeo a serem concatenados (ex: '.ts').	required

Returns:

Type	Description
	None

`__filter_ffmpeg_output(line, index)` `staticmethod`

Filtra e imprime apenas as linhas que contêm a palavra 'Opening' na saída do ffmpeg. Args: line(bytes): Linha de saída do ffmpeg. index(int): Índice de progresso. Returns: None

`__filter_ffmpeg_stdout(line, filtering)` `staticmethod`

Filtra apenas as linhas que contêm o filtro na saída do ffmpeg. Args: line(bytes): Linha de saída do ffmpeg. filtering(str): o filtro desejado Returns: o valor da linha

`__handle_remove_readonly(func, path, exc_info)` `staticmethod`

Função de callback para lidar com arquivos somente leitura.

`__ocute_terminal()` `staticmethod`

Verifica o sistema operacional do usuário e retorna uma inicial correspondente.

O método utiliza a biblioteca platform para identificar o sistema operacional e retorna: - 'w' para Windows - 'l' para Linux ou macOS (Darwin) - 'null' para outros sistemas operacionais não suportados

Returns:

Name	Type	Description
`str`		Inicial correspondente ao sistema operacional do usuário.

Example

os_initial = M3U8Analyzer.__ocute_terminal()
print(os_initial)

'w','l', ou 'null', dependendo do sistema operacional

`__verific_path_bin(binPath, typePath)` `staticmethod`

Esta função verifica se um caminho de arquivo ou diretório existe e retorna True ou False.

Parameters:

Name	Type	Description	Default
`binPath`	`str`	O caminho a ser verificado.	required
`typePath`	`str`	O tipo de caminho a verificar ('file' para arquivo, 'dir' para diretório).	required

Returns:

Name	Type	Description
`bool`		True se o caminho existir e for do tipo especificado, False caso contrário.

`__verificar_audio(path)` `staticmethod`

Verifica se o vídeo contém faixas de áudio usando ffmpeg.

Parameters:

Name	Type	Description	Default
`path`	`str`	Caminho do arquivo de vídeo.	required

Returns:

Name	Type	Description
`bool`	`bool`	True se o vídeo contiver áudio, False caso contrário.

`__verificar_video(path)` `staticmethod`

Verifica se o vídeo contém faixas de vídeo usando ffmpeg.

Parameters:

Name	Type	Description	Default
`path`	`str`	Caminho do arquivo de vídeo.	required

Returns:

Name	Type	Description
`bool`	`bool`	True se o vídeo contiver vídeo, False caso contrário.

`downloader_and_remuxer_segments(url_playlist, output, key_hex=None, iv_hex=None, player=None, headers=None, segmentsType=None, logs=None)` `staticmethod`

Baixa os segmentos de uma playlist M3U8, opcionalmente descriptografa-os, e os combina em um arquivo de vídeo.

Este método faz o download dos segmentos de uma playlist M3U8, possibilita a descriptografia dos segmentos usando uma chave e um IV fornecidos, e combina os segmentos em um único arquivo de vídeo. O tipo de segmento (por exemplo, '.ts' ou '.m4s') pode ser especificado. Após o processamento, o método remove os arquivos temporários criados durante o processo.

Parameters:

Name	Type	Description	Default
`url_playlist`	`str`	URL da playlist M3U8 contendo a lista de segmentos.	required
`output`	`str`	Caminho para o arquivo de saída final (por exemplo, 'dir/nome.mp4').	required
`key_hex`	`Optional[str]`	Chave de descriptografia em formato hexadecimal (opcional).	`None`
`iv_hex`	`Optional[str]`	IV (vetor de inicialização) em formato hexadecimal (opcional).	`None`
`player`	`Optional[str]`	URL base para os segmentos, se necessário para formar URLs completas.	`None`
`headers`	`Optional[dict]`	Cabeçalhos HTTP adicionais para as requisições (opcional).	`None`
`segmentsType`	`Optional[str]`	Tipo de segmento de saída, como '.ts' ou '.m4s' (opcional).	`None`
`logs`	`Optional[bool]`	Se True, exibe a saída do processo de download e concatenação.	`None`

Returns:

Type	Description
`None`	None

Raises:

Type	Description
`ValueError`	Se a URL da playlist não for válida ou se não houver URL base para os segmentos quando necessário.
`OSError`	Se houver erros ao remover arquivos temporários ou o diretório temporário.
`RequestException`	Se ocorrer um erro ao fazer a requisição HTTP.

Examples:

url_playlist = "https://example.com/playlist.m3u8"
output = "output/video.mp4"
key_hex = "00112233445566778899aabbccddeeff"
iv_hex = "00112233445566778899aabbccddeeff"
player = "https://example.com/"
headers = {
    "Accept": "application/json",
    "User-Agent": "CustomAgent/1.0"
}
segmentsType = ".ts"

M3u8Analyzer.downloader_and_remuxer_segments(
    url_playlist=url_playlist,
    output=output,
    key_hex=key_hex,
    iv_hex=iv_hex,
    player=player,
    headers=headers,
    segmentsType=segmentsType,
    logs=True
)

Notes

O método cria um diretório temporário para armazenar os segmentos baixados e, em seguida, remove-o após a concatenação.
Se ocorrer um erro durante a requisição HTTP ou o processo de concatenação, o método tentará remover arquivos temporários criados.
A chave e o IV fornecidos são usados para descriptografar os segmentos se fornecidos; caso contrário, os segmentos são baixados diretamente.

`ffmpegImage(commands, logs=None, callback=None)` `staticmethod`

Executa comandos personalizados no FFmpeg e processa a saída.

Este método permite executar comandos FFmpeg fornecidos pelo usuário e oferece a opção de visualizar a saída do FFmpeg em tempo real. Além disso, é possível fornecer uma função de callback que será chamada com cada linha de saída gerada pelo FFmpeg.

Parameters:

Name	Type	Description	Default
`commands`	`list`	Lista de argumentos de comando para o FFmpeg. O binário do FFmpeg será adicionado automaticamente no início da lista de comandos fornecida.	required
`logs`	`Optional[bool]`	Se True, exibe a saída do FFmpeg no console. Se False ou None, a saída é suprimida.	`None`
`callback`	`Optional[callable]`	Função opcional que será chamada com cada linha de saída gerada pelo FFmpeg. A função deve aceitar um argumento, que é a linha de saída como uma string.	`None`

Returns:

Type	Description
`None`	None

Raises:

Type	Description
`TypeError`	Se o parâmetro 'commands' não for uma lista.

Examples:

# Para executar um comando FFmpeg e exibir a saída
ffmpegImage(
    commands=['-i', 'input.mp4', '-vf', 'scale=1280:720', 'output.mp4'],
    logs=True
)

# Para executar um comando FFmpeg com uma função de callback para processar a saída
def process_output(line):
    print(f"Saída do FFmpeg: {line}")

ffmpegImage(
    commands=['-i', 'input.mp4', '-vf', 'scale=1280:720', 'output.mp4'],
    callback=process_output
)

Notes

O parâmetro commands deve ser uma lista de argumentos de linha de comando válidos para o FFmpeg. O binário do FFmpeg é automaticamente adicionado à lista de comandos.
Se logs for True, a saída do FFmpeg será exibida no console, removendo as linhas em branco.
Se callback for fornecido, a função será chamada com cada linha de saída do FFmpeg, permitindo processamento personalizado da saída.
O método é capaz de ocultar a janela do terminal no Windows e suprimir a saída no Linux conforme a configuração do terminal.

`ffmpeg_donwloader(input_url, output, type_playlist, resolution=None, logs=None)` `staticmethod`

Baixa um vídeo ou áudio usando FFmpeg a partir de uma URL de playlist M3U8.

Este método utiliza FFmpeg para baixar e salvar vídeo ou áudio de uma URL M3U8. Dependendo do tipo de playlist ('audio' ou 'video'), o método pode especificar a resolução para vídeos ou escolher um formato padrão para áudios.

Parameters:

Name	Type	Description	Default
`input_url`	`str`	URL da playlist M3U8 contendo os segmentos de vídeo ou áudio.	required
`output`	`str`	Caminho para o arquivo final a ser salvo, com extensão apropriada (por exemplo, 'dir/nome.mp4' ou 'dir/nome.mp3').	required
`type_playlist`	`str`	Tipo da playlist, deve ser 'audio' ou 'video'.	required
`resolution`	`Optional[str]`	Define a resolução desejada para o vídeo ('lower', 'medium', 'high'). Ignorado para áudio.	`None`
`logs`	`Optional[bool]`	Se True, exibe a saída do FFmpeg. Se False ou None, a saída é suprimida.	`None`

Returns:

Type	Description
`None`	None

Raises:

Type	Description
`SyntaxError`	Se o parâmetro 'type_playlist' não for fornecido como string.
`ValueError`	Se o tipo de playlist fornecido não for 'audio' ou 'video'.

Examples:

# Para baixar um vídeo com resolução 'medium'
ffmpeg_donwloader(
    input_url="https://example.com/video_playlist.m3u8",
    output="output/video.mp4",
    type_playlist="video",
    resolution="medium",
    logs=True
)

# Para baixar áudio sem especificar resolução
ffmpeg_donwloader(
    input_url="https://example.com/audio_playlist.m3u8",
    output="output/audio.mp3",
    type_playlist="audio",
    logs=False
)

Notes

O comando FFmpeg é executado de forma oculta no Windows e Linux para evitar exibição de terminal.
O parâmetro resolution é usado somente para vídeos, e o padrão é 'high' se a resolução não for reconhecida.
A saída do FFmpeg pode ser controlada com o parâmetro logs, que, se definido como True, exibe as mensagens de progresso e erros.

`remuxer_audio_and_video(audioPath, videoPath, outputPath, logs=None)` `staticmethod`

Remuxa um arquivo de áudio e um arquivo de vídeo em um único arquivo MP4 usando FFmpeg.

Este método combina um arquivo de áudio e um arquivo de vídeo em um único arquivo MP4 sem recodificação dos streams, o que preserva a qualidade original dos arquivos de entrada.

Parameters:

Name	Type	Description	Default
`audioPath`	`str`	Caminho para o arquivo de áudio que será combinado.	required
`videoPath`	`str`	Caminho para o arquivo de vídeo que será combinado.	required
`outputPath`	`str`	Caminho de saída para o arquivo remuxado, por exemplo, 'dir/nome.mp4'.	required
`logs`	`Optional[bool]`	Se True, exibe a saída do FFmpeg durante o processamento. Se False ou None, a saída é suprimida.	`None`

Returns:

Type	Description
`None`	None

Raises:

Type	Description
`ValueError`	Se os caminhos dos arquivos de áudio ou vídeo não existirem.

Examples:

# Para remuxar áudio e vídeo em um único arquivo MP4 com logs ativados
remuxer_audio_and_video(
    audioPath="path/to/audio.mp3",
    videoPath="path/to/video.mp4",
    outputPath="output/combined.mp4",
    logs=True
)

# Para remuxar áudio e vídeo em um arquivo MP4 sem exibir logs
remuxer_audio_and_video(
    audioPath="path/to/audio.mp3",
    videoPath="path/to/video.mp4",
    outputPath="output/combined.mp4"
)

Notes

O comando FFmpeg usa a opção -c copy para copiar os streams de áudio e vídeo sem recodificação, o que preserva a qualidade original.
A remoção dos arquivos de áudio e vídeo de entrada após o remuxing é tentada, mas qualquer falha na remoção é ignorada.
O comportamento da exibição de logs é controlado pelo parâmetro logs. Se logs for True, as mensagens de saída do FFmpeg são impressas no console.

`Wrapper`

Classe para parsear playlists M3U8.

`parsing_m3u8(url, headers=None)` `staticmethod`

Cria uma instância de M3U8Playlist a partir de uma URL de playlist M3U8.

Este método estático é utilizado para inicializar e retornar um objeto da classe M3U8Playlist, que fornece funcionalidades para análise e manipulação de playlists M3U8.

Parameters:

Name	Type	Description	Default
`url`	`str`	URL da playlist M3U8 que deve ser parseada.	required
`headers`	`Optional[dict]`	Cabeçalhos HTTP adicionais para a requisição (opcional).	`None`

Returns:

Name	Type	Description
`M3U8Playlist`	`M3U8Playlist`	Uma instância da classe `M3U8Playlist` inicializada com a URL fornecida.

Raises:

Type	Description
`ValueError`	Se a URL não for uma URL válida.

Examples:

url_playlist = "https://example.com/playlist.m3u8"
headers = {
    "User-Agent": "CustomAgent/1.0"
}

playlist = ParsingM3u8.parsing_m3u8(url=url_playlist, headers=headers)

print(playlist.info())

Notes

Certifique-se de que a URL fornecida é uma URL válida e acessível.
Se os cabeçalhos forem fornecidos, eles serão utilizados na requisição para obter o conteúdo da playlist.

docmumentação da api

EncryptSuport

get_url_key_m3u8(m3u8_content, player, headers=None) staticmethod

M3U8Playlist

__get_version_manifest(content)

EXT-X-VERSION:4

EXT-X-VERSION:3

__load_playlist()

filter_resolution(filtering)

get_codecs()

get_resolutions()

info()

number_segments()

playlist_type()

this_encrypted()

uris()

version_manifest()

M3u8Analyzer

__init__()

get_audio_playlist(m3u8_content) staticmethod

get_high_resolution(m3u8_content) staticmethod

get_m3u8(url_m3u8, headers=None, save_in_file=None, timeout=None) staticmethod

get_player_playlist(m3u8_url) staticmethod

get_segments(content) staticmethod

get_type_m3u8_content(m3u8_content) staticmethod

M3u8Downloader

__clear_line() staticmethod

__descriptografar_segmento(path, key, iv, logs=None) staticmethod

__ffmpeg_concatener(output, extension) staticmethod

__filter_ffmpeg_output(line, index) staticmethod

__filter_ffmpeg_stdout(line, filtering) staticmethod

__handle_remove_readonly(func, path, exc_info) staticmethod

__ocute_terminal() staticmethod

__verific_path_bin(binPath, typePath) staticmethod

__verificar_audio(path) staticmethod

__verificar_video(path) staticmethod

downloader_and_remuxer_segments(url_playlist, output, key_hex=None, iv_hex=None, player=None, headers=None, segmentsType=None, logs=None) staticmethod

ffmpegImage(commands, logs=None, callback=None) staticmethod

ffmpeg_donwloader(input_url, output, type_playlist, resolution=None, logs=None) staticmethod

remuxer_audio_and_video(audioPath, videoPath, outputPath, logs=None) staticmethod

Wrapper

parsing_m3u8(url, headers=None) staticmethod

`EncryptSuport`

`get_url_key_m3u8(m3u8_content, player, headers=None)` `staticmethod`

`M3U8Playlist`

`__get_version_manifest(content)`

`__load_playlist()`

`filter_resolution(filtering)`

`get_codecs()`

`get_resolutions()`

`info()`

`number_segments()`

`playlist_type()`

`this_encrypted()`

`uris()`

`version_manifest()`

`M3u8Analyzer`

`init()`

`get_audio_playlist(m3u8_content)` `staticmethod`

`get_high_resolution(m3u8_content)` `staticmethod`

`get_m3u8(url_m3u8, headers=None, save_in_file=None, timeout=None)` `staticmethod`

`get_player_playlist(m3u8_url)` `staticmethod`

`get_segments(content)` `staticmethod`

`get_type_m3u8_content(m3u8_content)` `staticmethod`

`M3u8Downloader`

`__clear_line()` `staticmethod`

`__descriptografar_segmento(path, key, iv, logs=None)` `staticmethod`

`__ffmpeg_concatener(output, extension)` `staticmethod`

`__filter_ffmpeg_output(line, index)` `staticmethod`

`__filter_ffmpeg_stdout(line, filtering)` `staticmethod`

`__handle_remove_readonly(func, path, exc_info)` `staticmethod`

`__ocute_terminal()` `staticmethod`

`__verific_path_bin(binPath, typePath)` `staticmethod`

`__verificar_audio(path)` `staticmethod`

`__verificar_video(path)` `staticmethod`

`downloader_and_remuxer_segments(url_playlist, output, key_hex=None, iv_hex=None, player=None, headers=None, segmentsType=None, logs=None)` `staticmethod`

`ffmpegImage(commands, logs=None, callback=None)` `staticmethod`

`ffmpeg_donwloader(input_url, output, type_playlist, resolution=None, logs=None)` `staticmethod`

`remuxer_audio_and_video(audioPath, videoPath, outputPath, logs=None)` `staticmethod`

`Wrapper`

`parsing_m3u8(url, headers=None)` `staticmethod`