Aspose.Words for Python via .NET 23.12 Release Notes

class PdfSaveOptions
 @property
    def page_layout(self) -> aspose.words.saving.PdfPageLayout:
        """Specifies the page layout to be used when the document is opened in a PDF reader.
        
        The default value is :attr:`PdfPageLayout.SINGLE_PAGE`."""
        ...
    
    @page_layout.setter
    def page_layout(self, value: aspose.words.saving.PdfPageLayout):
        ...

class PdfPageLayout(Enum):
    """Specifies the page layout to be used when the document is opened in a PDF reader."""
    
    """Display one page at a time."""
    SINGLE_PAGE: int
    
    """Display the pages in one column."""
    ONE_COLUMN: int
    
    """Display the pages in two columns, with odd-numbered pages on the left."""
    TWO_COLUMN_LEFT: int
    
    """Display the pages in two columns, with odd-numbered pages on the right."""
    TWO_COLUMN_RIGHT: int
    
    """Display the pages two at a time, with odd-numbered pages on the left."""
    TWO_PAGE_LEFT: int
    
    """Display the pages two at a time, with odd-numbered pages on the right."""
    TWO_PAGE_RIGHT: int
    

from aspose.words import Document
from aspose.words.saving import PdfPageLayout, PdfSaveOptions
doc = Document("Big document.docx")

# Display the pages two at a time, with odd - numbered pages on the left.
save_options = PdfSaveOptions()
save_options.page_layout = PdfPageLayout.TWO_PAGE_LEFT

doc.save("PdfSaveOptions.PageLayout.pdf", save_options)

@staticmethod
    def merge_docs(input_documents: List[aspose.words.Document], merge_format_mode: aspose.words.lowcode.MergeFormatMode) -> aspose.words.Document:
        """Merges the given input documents into a single document and returns :class:`aspose.words.Document` instance of the final document.
        
        :param input_documents: The input documents.
        :param merge_format_mode: Specifies how to merge formatting that clashes."""
        ...

from aspose.words import DocumentBuilder
from aspose.pydrawing import Color
from aspose.words.lowcode import Merger, MergeFormatMode

first_doc = DocumentBuilder()
first_doc.font.size = 16
first_doc.font.color = Color.blue
first_doc.write("Hello first word!")

second_doc = DocumentBuilder()
second_doc.write("Hello second word!")

merged_doc = Merger.merge_docs([first_doc.document, second_doc.document], MergeFormatMode.KEEP_SOURCE_LAYOUT)

self.assertEqual("Hello first word!\fHello second word!\f", merged_doc.get_text())

class OoxmlSaveOptions
 @property
    def zip_64_mode(self) -> aspose.words.saving.Zip64Mode:
        """Specifies whether or not to use ZIP64 format extensions for the output document.
        The default value is :attr:`Zip64Mode.NEVER`."""
        ...
    
    @zip_64_mode.setter
    def zip_64_mode(self, value: aspose.words.saving.Zip64Mode):
        ...

class Zip64Mode(Enum):
    """Specifies when to use ZIP64 format extensions for OOXML files.
    
    OOXML file is a ZIP-archive that has a 4 GB (2^32 bytes) limit on uncompressed size of a file,
    compressed size of a file, and total size of the archive, as well as a limit of 65,535 (2^16-1) files in archive.
    ZIP64 format extensions increase the limits to 2^64."""
    
    """Do not use ZIP64 format extensions."""
    NEVER: int
    
    """If necessary use ZIP64 format extensions."""
    IF_NECESSARY: int
    
    """Always use ZIP64 format extensions."""
    ALWAYS: int

import io
import random
from aspose.words import DocumentBuilder
from aspose.pydrawing import Color, Graphics, Bitmap
from aspose.pydrawing.imaging import ImageFormat
from aspose.words.saving import OoxmlSaveOptions, Zip64Mode

builder = DocumentBuilder()
for i in range(0, 10000):
    bmp = Bitmap(5, 5)
    g = Graphics.from_image(bmp)
    g.clear(Color.from_argb(random.randint(0, 254), random.randint(0, 254), random.randint(0, 254)))
    data = io.BytesIO()
    bmp.save(data, ImageFormat.bmp)
    builder.insert_image(data)
    data.close()

options = OoxmlSaveOptions()
options.zip_64_mode = Zip64Mode.ALWAYS
builder.document.save("OoxmlSaveOptions.Zip64ModeOption.docx")

from aspose.words import Document, DocumentBuilder
doc = Document()
builder = DocumentBuilder(doc)

builder.insert_image("WebP image.webp")
doc.save("Image.InsertWebpImage.docx")

from aspose.words import Document, NodeType
from aspose.words.drawing import ImageType

doc = Document("Document with WebP image.docx")
shape = doc.get_child(NodeType.SHAPE, 0, True).as_shape()

self.assertEqual(ImageType.WEB_P, shape.image_data.image_type)