Gestionar BLOBs de presentación en Python mediante Java para un uso eficiente de la memoria

De qué trata esta página

Gestionar datos BLOB en Aspose.Slides para Python mediante Java para optimizar las operaciones con archivos PowerPoint y OpenDocument y lograr un manejo eficiente de presentaciones.

Descripción general

Aspose.Slides proporciona manejo basado en BLOB para datos binarios grandes en presentaciones, lo que ayuda a reducir el consumo de memoria al trabajar con imágenes, audio, vídeo y archivos de presentación de gran tamaño.

Este artículo muestra cómo usar el procesamiento basado en BLOB para añadir medios grandes a una presentación, exportar medios grandes desde una presentación y cargar presentaciones grandes de manera más eficiente. También explica cómo se pueden usar archivos temporales durante el procesamiento y cómo cambiar la carpeta utilizada para almacenarlos.

Acerca de BLOB

Un BLOB (Binary Large Object) suele ser un elemento grande (foto, presentación, documento o medio) guardado en formatos binarios.

Aspose.Slides for Python via Java le permite utilizar BLOBs para objetos de forma que se reduzca el consumo de memoria cuando se manejan archivos grandes.

Nota

Para sortear ciertas limitaciones al interactuar con flujos, Aspose.Slides puede copiar el contenido del flujo. Cargar una presentación grande a través de su flujo provocará la copia del contenido de la presentación y causará una carga lenta. Por lo tanto, cuando tenga la intención de cargar una presentación grande, le recomendamos encarecidamente que utilice la ruta del archivo de la presentación y no su flujo.

Usar BLOBs para reducir el consumo de memoria

Añadir un archivo grande a una presentación usando BLOBs

Aspose.Slides for Python via Java le permite añadir archivos grandes (en este caso, un archivo de vídeo grande) mediante un proceso que involucra BLOBs para reducir el consumo de memoria.

Este código Python le muestra cómo añadir un archivo de vídeo grande mediante el proceso BLOB a una presentación:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import LoadingStreamBehavior, Presentation, SaveFormat
from java.io import FileInputStream

path_to_very_large_video = "veryLargeVideo.avi"

# Crear una nueva presentación a la que se añadirá el vídeo.
presentation = Presentation()
try:
    file_stream = FileInputStream(path_to_very_large_video)
    try:
        # Mantener el flujo bloqueado porque no pretendemos acceder al archivo de vídeo.
        video = presentation.getVideos().addVideo(file_stream, LoadingStreamBehavior.KeepLocked)
        presentation.getSlides().get_Item(0).getShapes().addVideoFrame(0, 0, 480, 270, video)

        # Guardar la presentación manteniendo bajo el consumo de memoria.
        presentation.save("presentationWithLargeVideo.pptx", SaveFormat.Pptx)
    finally:
        file_stream.close()
finally:
    presentation.dispose()

Exportar un archivo grande desde una presentación usando BLOBs

Aspose.Slides for Python via Java le permite exportar archivos grandes (por ejemplo, un archivo de audio o vídeo) mediante un proceso que involucra BLOBs desde presentaciones. Por ejemplo, puede necesitar extraer un archivo de medio grande de una presentación pero no desea que el archivo se cargue en la memoria de su ordenador. Al exportar el archivo mediante el proceso BLOB, mantiene bajo el consumo de memoria.

Este código en Python demuestra la operación descrita:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import LoadOptions, Presentation, PresentationLockingBehavior

huge_presentation_file = "LargeVideoFileTest.pptx"

load_options = LoadOptions()
# Bloquear el archivo de origen en lugar de cargarlo en memoria.
load_options.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked)

presentation = Presentation(huge_presentation_file, load_options)
try:
    # Transferir los datos de vídeo a través de un búfer para mantener bajo el consumo de memoria.
    buffer = jpype.JArray(jpype.JByte)(8 * 1024)

    for index in range(presentation.getVideos().size()):
        video = presentation.getVideos().get_Item(index)

        # Usar el flujo en lugar de cargar todo el vídeo en un array de bytes.
        video_stream = video.getStream()
        try:
            with open(f"video{index}.avi", "wb") as output_stream:
                bytes_read = video_stream.read(buffer, 0, len(buffer))
                while bytes_read > 0:
                    chunk = bytes(buffer[:bytes_read])
                    output_stream.write(chunk)
                    bytes_read = video_stream.read(buffer, 0, len(buffer))
        finally:
            video_stream.close()
    # Si es necesario, aplicar los mismos pasos a los archivos de audio.
finally:
    presentation.dispose()

Añadir una imagen como BLOB a una presentación

Con los métodos de la clase ImageCollection puede añadir una imagen grande como flujo para que se trate como un BLOB.

Este código Python le muestra cómo añadir una imagen grande mediante el proceso BLOB:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import LoadingStreamBehavior, Presentation, SaveFormat, ShapeType
from java.io import FileInputStream

path_to_large_image = "large_image.jpg"

# Crear una nueva presentación a la que se añadirá la imagen.
presentation = Presentation()
try:
    file_stream = FileInputStream(path_to_large_image)
    try:
        # Mantener el flujo bloqueado porque no pretendemos acceder al archivo de imagen.
        image = presentation.getImages().addImage(file_stream, LoadingStreamBehavior.KeepLocked)
        presentation.getSlides().get_Item(0).getShapes().addPictureFrame(ShapeType.Rectangle, 0, 0, 300, 200, image)

        # Guardar la presentación manteniendo bajo el consumo de memoria.
        presentation.save("presentationWithLargeImage.pptx", SaveFormat.Pptx)
    finally:
        file_stream.close()
finally:
    presentation.dispose()

Memoria y presentaciones grandes

Normalmente, para cargar una presentación grande, los equipos requieren mucha memoria temporal. Todo el contenido de la presentación se carga en memoria y el archivo (del que se cargó la presentación) deja de usarse.

Considere una presentación PowerPoint grande (large.pptx) que contiene un archivo de vídeo de 1,5 GB. El método estándar para cargar la presentación se describe en este código Python:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, SaveFormat

presentation = Presentation("large.pptx")
try:
    presentation.save("large.pdf", SaveFormat.Pdf)
finally:
    presentation.dispose()

Pero este método consume alrededor de 1,6 GB de memoria temporal.

Cargar una presentación grande como BLOB

Usando el manejo de BLOBs, puede cargar una presentación grande empleando poca memoria. Este código Python muestra cómo usar el manejo de BLOBs para cargar un archivo de presentación grande (large.pptx):

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import LoadOptions, Presentation, PresentationLockingBehavior, SaveFormat

load_options = LoadOptions()
load_options.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked)
load_options.getBlobManagementOptions().setTemporaryFilesAllowed(True)

presentation = Presentation("large.pptx", load_options)
try:
    presentation.save("large.pdf", SaveFormat.Pdf)
finally:
    presentation.dispose()

Cambiar la carpeta para archivos temporales

Cuando se usa el proceso BLOB, su equipo crea archivos temporales en la carpeta predeterminada para archivos temporales. Si desea que los archivos temporales se guarden en una carpeta diferente, puede cambiar la configuración de almacenamiento usando BlobManagementOptions.setTempFilesRootPath:

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import LoadOptions, PresentationLockingBehavior

load_options = LoadOptions()
load_options.getBlobManagementOptions().setPresentationLockingBehavior(PresentationLockingBehavior.KeepLocked)
load_options.getBlobManagementOptions().setTemporaryFilesAllowed(True)
load_options.getBlobManagementOptions().setTempFilesRootPath("temp")

Nota

Al usar BlobManagementOptions.setTempFilesRootPath, Aspose.Slides no crea automáticamente una carpeta para almacenar los archivos temporales. Debe crear la carpeta manualmente.

Eliminar los objetos Presentation para liberar memoria

Al procesar presentaciones grandes, asegúrese de que la instancia de Presentation se elimine correctamente para que se libere la memoria que ocupaba. Llame a Presentation.dispose después de haber terminado de usar la presentación para liberar los recursos no administrados.

import jpype
import asposeslides

if not jpype.isJVMStarted():
    jpype.startJVM()

from asposeslides.api import Presentation, SaveFormat

presentation = Presentation("large.pptx")
try:
    # ...procesar la presentación...
    presentation.save("large.pdf", SaveFormat.Pdf)
finally:
    # Liberar los recursos explícitamente.
    presentation.dispose()

FAQ

¿Qué datos en una presentación de Aspose.Slides se tratan como BLOB y están controlados por opciones de BLOB?

Objetos binarios grandes como imágenes, audio y vídeo se tratan como BLOBs. El archivo completo de la presentación también implica manejo de BLOB cuando se carga o guarda. Estos objetos están gobernados por políticas de BLOB que le permiten gestionar el uso de memoria y volcar a archivos temporales cuando sea necesario.

¿Dónde configuro las reglas de manejo de BLOB durante la carga de una presentación?

Utilice LoadOptions con BlobManagementOptions. Allí establece el límite en memoria para los BLOBs, permite o prohibe archivos temporales, elige la ruta raíz para los archivos temporales y selecciona el comportamiento de bloqueo de la fuente.

¿Los ajustes de BLOB afectan al rendimiento y cómo equilibrar velocidad vs memoria?

Sí. Mantener los BLOBs en memoria maximiza la velocidad pero incrementa el consumo de RAM; reducir el límite de memoria traslada más trabajo a archivos temporales, reduciendo la RAM a costa de I/O adicional. Use el método setMaxBlobsBytesInMemory para alcanzar el equilibrio adecuado para su carga de trabajo y entorno.

¿Las opciones de BLOB ayudan al abrir presentaciones extremadamente grandes (por ejemplo, varios gigabytes)?

Sí. BlobManagementOptions está diseñado para esos escenarios: habilitar archivos temporales y usar bloqueo de fuente puede reducir significativamente el uso máximo de RAM y estabilizar el procesamiento de presentaciones muy grandes.

¿Puedo usar políticas de BLOB al cargar desde flujos en lugar de archivos en disco?

Sí. Las mismas reglas se aplican a los flujos: la instancia de presentación puede poseer y bloquear el flujo de entrada (según el modo de bloqueo seleccionado), y se usan archivos temporales cuando están permitidos, manteniendo predecible el uso de memoria durante el procesamiento.

Gestionar hipervínculos de presentación en Python a través de Java