Afhandelen van Presentatiewaarschuwingen in Python via Java

Waar deze pagina over gaat

Leer hoe u waarschuwingen kunt verzamelen, classificeren en behandelen tijdens het laden, renderen, converteren en opslaan van presentaties met Aspose.Slides voor Python via Java.

Overzicht

Aspose.Slides kan herstelbare problemen melden tijdens het laden, renderen, converteren of opslaan van een presentatie. Voorbeelden zijn beschadigde bronrecords, inhoud die niet bewaard kan blijven, lettertype‑vervanging en beperkingen van een doelformaat. Een waarschuwings‑callback stelt een toepassing in staat deze omstandigheden te registreren en te bepalen of de huidige bewerking kan worden voortgezet.

Implementeer de IWarningCallback‑interface via jpype.JProxy en bekijk de waarden van getWarningType en getDescription die via IWarningInfo worden geleverd. Retourneer ReturnAction.Continue om de waarschuwing te accepteren of ReturnAction.Abort om de bewerking te stoppen.

Gebruik LoadOptions.setWarningCallback voor waarschuwingen die worden gegenereerd bij het openen van een presentatie. Rendering‑ en exportoptie‑klassen erven SaveOptions.setWarningCallback, die waarschuwingen ontvangt van slide‑rendering, conversie en opslaan. Omdat de waarschuwing zelf de toepassingsbewerking niet identificeert, koppel je elke callback‑instantie aan een bewerkingsfase bij het opstellen van een gecombineerd rapport.

Waarschuwingen en uitzonderingen

Een waarschuwing beschrijft een situatie waarvan Aspose.Slides kan herstellen als de callback ReturnAction.Continue retourneert. Een uitzondering betekent dat de gevraagde bewerking niet normaal kan worden voltooid; uitzonderingen worden niet omgezet in waarschuwingen en kunnen niet door een waarschuwings‑policy worden afgehandeld.

Wanneer ReturnAction.Abort wordt geretourneerd, vraagt de waarschuwingsdispatcher de huidige bewerking te beëindigen door een uitzondering te werpen. De openbare uitzondering hangt af van de bewerking en het presentatiefomaat. Bijvoorbeeld, bij het laden kan een PptxReadException of PptReadException optreden, terwijl bij het opslaan of exporteren een PptxException kan verschijnen. Handel de uitzondering af aan de grens van de bewerking en gebruik het waarschuwingsrapport om te bepalen of het beleid van de toepassing de beëindiging heeft veroorzaakt in plaats van te vertrouwen op één subtype of bericht van de uitzondering. De callback registreert de waarschuwing voordat ReturnAction.Abort wordt geretourneerd, zodat de reden beschikbaar blijft voor de toepassing.

Waarschuwingscategorieën

De klasse WarningType biedt gehele‑cijfer‑constanten voor de volgende categorieën:

Waarschuwingstype	Betekenis	Typisch beleid
SourceFileCorruption	De bronpresentatie bevat corruptie die een document dat in het originele formaat is opgeslagen onbruikbaar kan maken.	Afbreken.
DataLoss	Tekst, grafieken, afbeeldingen of andere gegevens kunnen ontbreken na het laden of opslaan.	Afbreken.
MajorFormattingLoss	De presentatie kan belangrijke opmaak verliezen.	Afbreken in strikte validatiemodus; anders registreren en doorgaan.
MinorFormattingLoss	Een beperkte opmaakverschil kan optreden.	Registreren voor diagnostiek en doorgaan.
CompatibilityIssue	Het resultaat kan in sommige toepassingen of oudere versies niet openen of correct functioneren.	Loggen en doorgaan tenzij compatibiliteit verplicht is.
UnexpectedContent	De bron bevat niet‑ondersteunde of niet‑herkende inhoud waarvan het effect nog onbekend kan zijn.	Registreren en doorgaan, of behandelen als een fout in een strikt beleid.

De categorie moet de beleidsbeslissing sturen. Sla de waarde die door getDescription wordt geretourneerd op voor diagnostiek, maar baseer de toepassingslogica niet op de bewoording omdat de berichttekst kan variëren tussen waarschuwingsscenario’s en productversies.

Verzamel en classificeer waarschuwingen

Het volgende voorbeeld gebruikt één toepassings‑niveau rapport voor de volledige verwerkingspijplijn. Een afzonderlijke callback‑instantie labelt waarschuwingen van laden, renderen, PDF‑conversie en PPTX‑opslaan. Het beleid beëindigt bij bron‑corruptie of gegevensverlies, stopt eventueel bij grote opmaakverlies, en gaat door voor andere waarschuwingen.

import sys
from dataclasses import dataclass
from enum import Enum

import jpype
import asposeslides

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

from asposeslides.api import ImageFormat, LoadOptions, PdfOptions, PptxOptions, Presentation, RenderingOptions, ReturnAction, SaveFormat, WarningType


class OperationStage(Enum):
    Loading = "Loading"
    Rendering = "Rendering"
    Conversion = "Conversion"
    Saving = "Saving"


@dataclass(frozen=True)
class WarningEntry:
    stage: OperationStage
    type: int
    description: str


class WarningReport:
    def __init__(self):
        self._entries = []

    def get_entries(self):
        return tuple(self._entries)

    def add(self, stage, warning):
        entry = WarningEntry(stage, warning.getWarningType(), str(warning.getDescription()))
        self._entries.append(entry)


class WarningPolicy:
    def __init__(self, abort_on_major_formatting_loss):
        self.abort_on_major_formatting_loss = abort_on_major_formatting_loss

    def get_action(self, warning_type):
        if warning_type in (WarningType.SourceFileCorruption, WarningType.DataLoss):
            return ReturnAction.Abort
        if warning_type == WarningType.MajorFormattingLoss and self.abort_on_major_formatting_loss:
            return ReturnAction.Abort
        return ReturnAction.Continue


class ReportingWarningCallback:
    def __init__(self, stage, report, policy):
        self.stage = stage
        self.report = report
        self.policy = policy

    def warning(self, warning):
        self.report.add(self.stage, warning)
        return self.policy.get_action(warning.getWarningType())


def process_presentation(input_path, report, policy):
    try:
        load_options = LoadOptions()
        handler = ReportingWarningCallback(OperationStage.Loading, report, policy)
        callback = jpype.JProxy("com.aspose.slides.IWarningCallback", inst=handler)
        load_options.setWarningCallback(callback)
        presentation = Presentation(input_path, load_options)
        try:
            if not render_first_slide(presentation, report, policy):
                return False
            if not convert_to_pdf(presentation, report, policy):
                return False
            return save_validated_copy(presentation, report, policy)
        finally:
            presentation.dispose()
    except Exception as exception:
        print(f"Loading stopped: {exception}", file=sys.stderr)
        return False


def render_first_slide(presentation, report, policy):
    if presentation.getSlides().size() == 0:
        print("Rendering stopped: the presentation has no slides.", file=sys.stderr)
        return False
    try:
        options = RenderingOptions()
        handler = ReportingWarningCallback(OperationStage.Rendering, report, policy)
        callback = jpype.JProxy("com.aspose.slides.IWarningCallback", inst=handler)
        options.setWarningCallback(callback)
        image = presentation.getSlides().get_Item(0).getImage(options)
        try:
            image.save("slide-1.png", ImageFormat.Png)
            return True
        finally:
            image.dispose()
    except Exception as exception:
        print(f"Rendering stopped: {exception}", file=sys.stderr)
        return False


def convert_to_pdf(presentation, report, policy):
    try:
        options = PdfOptions()
        handler = ReportingWarningCallback(OperationStage.Conversion, report, policy)
        callback = jpype.JProxy("com.aspose.slides.IWarningCallback", inst=handler)
        options.setWarningCallback(callback)
        presentation.save("converted.pdf", SaveFormat.Pdf, options)
        return True
    except Exception as exception:
        print(f"Conversion stopped: {exception}", file=sys.stderr)
        return False


def save_validated_copy(presentation, report, policy):
    try:
        options = PptxOptions()
        handler = ReportingWarningCallback(OperationStage.Saving, report, policy)
        callback = jpype.JProxy("com.aspose.slides.IWarningCallback", inst=handler)
        options.setWarningCallback(callback)
        presentation.save("validated-output.pptx", SaveFormat.Pptx, options)
        return True
    except Exception as exception:
        print(f"Saving stopped: {exception}", file=sys.stderr)
        return False


def warning_type_name(warning_type):
    names = {
        WarningType.SourceFileCorruption: "SourceFileCorruption",
        WarningType.DataLoss: "DataLoss",
        WarningType.MajorFormattingLoss: "MajorFormattingLoss",
        WarningType.MinorFormattingLoss: "MinorFormattingLoss",
        WarningType.CompatibilityIssue: "CompatibilityIssue",
        WarningType.UnexpectedContent: "UnexpectedContent",
    }
    return names.get(warning_type, f"Unknown ({warning_type})")


report = WarningReport()
policy = WarningPolicy(True)
completed = process_presentation("input.pptx", report, policy)

print("Processing completed." if completed else "Processing stopped.")
for entry in report.get_entries():
    type_name = warning_type_name(entry.type)
    print(f"[{entry.stage.value}] {type_name}: {entry.description}")

Geef False op voor abort_on_major_formatting_loss bij het construeren van WarningPolicy als grote opmaakverschillen acceptabel zijn. Compatibiliteitsproblemen, klein opmaakverlies en onverwachte inhoud blijven nog steeds in het rapport behouden, zelfs wanneer de bewerking wordt voortgezet. Breid WarningPolicy.get_action uit als de toepassing een van deze categorieën moet afwijzen.

Veelvoorkomende waarschuwingsscenario’s

Waarschuwingen kunnen optreden in verschillende fasen van een workflow:

Digitale handtekeningen: Een ondertekende presentatie kan bij het laden een waarschuwing genereren dat de handtekening verloren gaat tijdens de verwerking. Aspose.Slides meldt deze DataLoss‑conditie via IPresentationSignedWarningInfo. Een callback in de laadfase stelt de toepassing in staat het bestand te weigeren of het gemelde verlies expliciet te accepteren.
Lettertype‑vervanging: Een niet‑beschikbaar lettertype kan worden vervangen tijdens het renderen of exporteren van een dia. Waarschuwingen over lettertype‑vervanging worden gemeld als DataLoss, waardoor het strikte beleid hierboven afbreekt, zelfs als de toepassing een bepaalde vervanging visueel acceptabel zou vinden. Om dit gedrag te observeren, gebruik een invoerpresentatie met tekst in een lettertype dat niet beschikbaar is voor de runtime. De waarschuwingsbeschrijving identificeert de vervanging; configureer de vereiste lettertypen of font substitution rules voordat u het opnieuw probeert.
Niet‑ondersteunde of onverwachte inhoud: Een loader kan presentatie‑records of functies tegenkomen die hij niet herkent. Dergelijke waarschuwingen kunnen UnexpectedContent gebruiken, of een ernstigere categorie wanneer gegevens of opmaak bekend is aangetast.
Formaat‑compatibiliteit: Opslaan naar een ander presentatiefomaat kan functies weglaten of een resultaat opleveren dat zich anders gedraagt in sommige toepassingen. Bijvoorbeeld, een presentatie met meer dan acht horizontale of acht verticale tekengidsen opslaan naar een legacy PPT meldt een CompatibilityIssue. De callback in de opslaanfase kan het verlies registreren en doorgaan, of het afwijzen als het behouden van alle gidsen vereist is.
Laadgedrag: Laadopties en legacy‑gedragingen kunnen eveneens waarschuwingen genereren. Bijvoorbeeld, IObsoletePresLockingBehaviorWarningInfo identificeert het gebruik van een verouderd presentatie‑vergrendelingsgedrag als een CompatibilityIssue.

Waarschuwingen hangen af van het bron‑document, het doelformaat, de bewerking en de versie van Aspose.Slides. Ga niet ervan uit dat elk bestand een waarschuwing oplevert of dat een scenario altijd aan slechts één categorie gekoppeld is.

Afgebroken bewerkingen veilig afhandelen

Wanneer een callback ReturnAction.Abort retourneert, gebruik dan geen object dat niet geladen kon worden en ga niet ervan uit dat een render‑ of opslaag‑output compleet is. De bewerking kan beëindigen nadat een uitvoerbestand is aangemaakt maar vóórdat het voltooid is.

Sla gevalideerde resultaten op naar een apart pad, bijvoorbeeld validated-output.pptx. Vervang een bestaande presentatie pas nadat de bewerking succesvol is afgerond, het waarschuwingsrapport voldoet aan het beleids‑van de toepassing, en de output geopend en gecontroleerd kan worden. Dit voorkomt het overschrijven van een geldig bronbestand met een gedeeltelijk of afgewezen resultaat.

Een leeg waarschuwingsrapport biedt geen garantie dat elke bron‑eigenschap behouden is gebleven. Pas eventuele extra inhouds‑ en visuele controles toe die de toepassing vereist. Zie ook Open Presentations en Save Presentations.

FAQ

Kan een waarschuwings‑callback elke Aspose.Slides‑fout afhandelen?

Nee. Het handelt herstelbare situaties af die worden gerapporteerd als waarschuwingen. Uitzonderingen die onafhankelijk van de callback optreden, moeten door de toepassing worden afgehandeld rond het laad‑, render‑, conversie‑ of opslaag‑oproep.

Garandeert het retourneren van ReturnAction.Continue identieke output?

Nee. Het staat alleen toe de verwerking voort te zetten. De gerapporteerde situatie kan nog steeds data‑, opmaak‑ of compatibiliteitsverschillen veroorzaken, dus controleer de verzamelde waarschuwings‑typen en beschrijvingen.

Hoe kan een toepassing de bewerking identificeren die een waarschuwing heeft veroorzaakt?

Maak voor elke bewerking een callback‑instantie aan en sla een door de toepassing gedefinieerde fase op samen met de waarden die door getWarningType en getDescription worden geretourneerd, zoals in het voorbeeld wordt getoond.

Voorkom bewerking van presentaties met vormvergrendelingen De volledige slide-achtergrond uit een presentatie als afbeelding ophalen