Compacte documentos de qualquer tamanho aplicando paralelismo via Python.Net

Visão geral

Paralelizando arquivos BZIP2, LZIP e XZ

O número de threads de compactação pode ser definido através da propriedade "threads de compactação" da classe de configurações correspondente. O valor padrão é 1 e, portanto, a compactação é executada em um único thread. No entanto, se você definir um valor maior que um, o algoritmo usará o número correspondente de núcleos do processador

Parallel compression to BZIP2

    save_options =  zp.bzip2.Bzip2SaveOptions()
    save_options.compression_threads = 4
    with zp.bzip2.Bzip2Archive() as archive:
        archive.set_source("data.bin")
        archive.save("archive.bz2", save_options)

Parallel compression to LZIP

    # Will use 16Mb for dictionary:
    settings = zp.lzip.LzipArchiveSettings(0x1000000)
    settings.compression_threads = 4
    with zp.lzip.LzipArchive(settings) as archive:
        archive.set_source("data.bin")
        archive.save("archive.lz")

Parallel compression to XZ

    settings = zp.xz.settings.XzArchiveSettings()
    settings.compression_threads = 4
    with zp.xz.XzArchive(settings) as archive:
        archive.set_source("data.bin")
        archive.save("archive.xz")

Nestes exemplos, os trechos de código Python realizam ações semelhantes para a criação de arquivos, diferindo apenas nos formatos de compactação utilizados. Eles normalmente seguem estas etapas:

• Crie um objeto de configurações específico para o formato de arquivo.
• Defina o número de fluxos de paralelismo para compactação.
• Um objeto de arquivo é criado no contexto com, o que garante o fechamento automático do arquivo após a conclusão das operações.
• Especifique a fonte de dados a ser adicionada ao arquivo.
• Salve o arquivo no formato apropriado usando as configurações definidas.

Compressão LZMA2 e multithreading em arquivos 7Z

Este exemplo demonstra como criar um arquivo 7z usando o arquivo data.bin. Usamos o algoritmo de compactação LZMA2 com quatro fluxos para compactar dados com eficiência.

Parallel compression to 7Z LZMA2

    compression_settings = zp.saving.SevenZipLZMA2CompressionSettings()
    compression_settings.compression_threads = 4
    entry_settings = zp.saving.SevenZipEntrySettings(compression_settings)
    with zp.sevenzip.SevenZipArchive(entry_settings) as archive:
        archive.create_entry("data.bin", "data.bin")
        archive.save("result.7z")

Este código cria um arquivo 7z lendo os dados do arquivo data.bin, usando SevenZipLZMA2CompressionSettings em vez das configurações para Bzip2, Lzip ou XZ e o algoritmo de compactação LZMA2 com quatro threads para compactação. Ele usa o método create_entry do SevenZipArchive em vez do método set_source.

Acelere o arquivamento ZIP com compactação paralela

A criação de um arquivo ZIP pode ser paralelizada no nível de entrada. Para fazer isso, use a instância ParallelOptions e suas propriedades

    parallel_opt = zp.saving.ParallelOptions()
    parallel_opt.parallel_compress_in_memory =  zp.saving.ParallelCompressionMode.AUTO
    save_opt =  zp.saving.ArchiveSaveOptions()
    save_opt.parallel_options = parallel_opt
    with zp.Archive as archive:
        archive.create_entries("~/Data")
        archive.Save("archive.zip", save_opt)

Os principais recursos são:

• Usar ParallelOptions para configurar compactação paralela na memória.
• Usar ArchiveSaveOptions para configurações gerais de salvamento.
• Empregar o método create_entries para adicionar arquivos de o diretório ~/Data para o arquivo.