Comprima documentos de cualquier tamaño aplicando paralelismo a través de Python.Net

Descripción general

Paralelización de archivos BZIP2, LZIP y XZ

El número de subprocesos de compresión se puede establecer a través de la propiedad "subprocesos de compresión" de la clase de configuración correspondiente. El valor predeterminado es 1 y, por lo tanto, la compresión se realiza en un solo subproceso. Sin embargo, si establece un valor mayor que uno, el algoritmo utilizará el número correspondiente de núcleos de procesador.

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

En estos ejemplos, los fragmentos de código de Python realizan acciones similares para crear archivos, diferenciándose únicamente en los formatos de compresión utilizados. Por lo general, siguen estos pasos:

• Crear un objeto de configuración específico para el formato de archivo.
• Establecer el número de flujos de paralelismo para la compresión.
• Se crea un objeto de archivo en el contexto con, lo que garantiza el cierre automático del archivo una vez completadas las operaciones.
• Especifique la fuente de datos que se agregará al archivo.
• Guarde el archivo en el formato apropiado usando los ajustes configurados.

Compresión LZMA2 y subprocesos múltiples en archivos 7Z

Este ejemplo demuestra cómo crear un archivo 7z utilizando el archivo data.bin. Utilizamos el algoritmo de compresión LZMA2 con cuatro flujos para comprimir datos de manera eficiente.

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 crea un archivo 7z leyendo los datos del archivo data.bin, usando SevenZipLZMA2CompressionSettings en lugar de las configuraciones para Bzip2, Lzip o XZ, y el algoritmo de compresión LZMA2 con cuatro subprocesos para la compresión. Utiliza el método create_entry de SevenZipArchive en lugar del método set_source.

Acelere el archivado ZIP con compresión paralela

La creación de un archivo ZIP se puede paralelizar en el nivel básico. Para hacer esto, use la instancia de ParallelOptions y sus propiedades.

    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)

Las características principales son:

• Usar ParallelOptions para configurar la compresión paralela en memoria.
• Usar ArchiveSaveOptions para configuraciones generales de guardado.
• Emplear el método create_entries para agregar archivos desde el directorio ~/Data al archivo.