Andere TeX-Verwaltungsoptionen | Python

Die Beispiele erzeugen XPS-Dateien. Wenden Sie zuerst eine Lizenz an und setzen Sie ASPOSE_TEX_OUTPUT_DIR auf den Ausgabeordner (Standard: output). Verwenden Sie für jedes Beispiel einen eigenen Ausgabeordner, um alle Ergebnisse aufzubewahren.

Festlegen des Interaktionsmodus

Wie im Abschnitt zur TeX-Interaktion erwähnt, bietet Aspose.TeX für Python die Möglichkeit, den anfänglichen Interaktionsmodus festzulegen, in dem die Engine startet. Hier ist ein Beispiel, wie es gemacht werden kann:

# Process a LaTeX document without interactive error prompts.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\begin{document}Hello, World!\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()

Festlegen des Jobnamens

Wenn die Haupteingabedatei als Dateiname angegeben wird, haben die resultierenden Ausgabedateien denselben Namen, jedoch mit unterschiedlichen Erweiterungen. Die TeX-Engine bezeichnet den Namen der Eingabedatei als Jobnamen und verwendet ihn für die Ausgabedateien. Eine Ausnahme bilden Hilfsdateien mit explizit angegebenen Dateinamen. Wenn die Haupteingabedatei jedoch als stream übergeben wird, verwendet die TeX-Engine den Standard-Jobnamen, der texput ist. In beiden Szenarien ist das Überschreiben des Jobnamens durch Zuweisen der entsprechenden Konvertierungsoption möglich.

# Override the output job name.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
options.job_name = "my-job-name"
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\begin{document}Hello, World!\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()

„Die Zeit anhalten“

Um aus bestimmten Definitionen in der Präambel automatisch einen Titel zu generieren, bietet LaTeX eine Funktion, die typischerweise das aktuelle Datum einbezieht. Es kann jedoch vorkommen, dass wir das Datum auf einen bestimmten Wert festlegen möchten. Hier ist eine Methode, um das zu erreichen:

# Fix the date used by LaTeX.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
from datetime import datetime
options.date_time = datetime(2022, 12, 18)
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\begin{document}\today\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()

Fehlende Pakete werden ignoriert

Wenn wir über eine LaTeX-Datei verfügen, die Verweise auf Pakete enthält, die von der Bibliothek Aspose.TeX für Python nicht unterstützt werden, wird die TeX-Engine beim Versuch, diese Pakete zu laden, auf einen Fehler stoßen und anhalten. Um dies zu verhindern, können wir folgende Möglichkeit nutzen:

# Skip an unavailable LaTeX package.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
options.ignore_missing_packages = True
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\usepackage{asposeexamplemissingpackage}\begin{document}Hello, World!\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()

So vermeiden Sie die Bildung von Ligaturen

Standardmäßig erstellt die TeX-Engine Ligaturen für bestimmte Zeichenpaare, wenn die Schriftart die erforderlichen Daten enthält. Wir können die Engine jedoch mit dem folgenden Code anweisen, die Ligaturkonstruktion zu umgehen:

# Disable construction of typographic ligatures.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
options.no_ligatures = True
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\begin{document}office efficient affine\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()

Den Auftrag wiederholen

Wie im Absatz „LaTeX-Eingabedatei“, Beschriftungen und Referenzen erwähnt, gibt es Situationen, in denen wir denselben Job möglicherweise zweimal ausführen müssen. Hier ist eine Methode, um das zu erreichen:

# Resolve a forward reference by repeating the job.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
options.repeat = True
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\begin{document}See Section \ref{sec:target}.\section{Target}\label{sec:target}\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()

Mathematische Formeln in Rasterbilder umwandeln

Wenn die Notwendigkeit besteht, mathematische Formeln in Rasterbilder umzuwandeln, anstatt sie mit Schriftarten darzustellen, kann zu diesem Zweck die folgende Option verwendet werden:

# Render math formulas as raster images.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
save_options.rasterize_formulas = True
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\begin{document}Formula: $x^2+y^2=z^2$\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()

Grafiken in Rasterbilder umwandeln

Die ObjectTeX-Engine bietet die Möglichkeit, Grafikdateien in Rasterformaten wie PNG und JPG sowie den Formaten PS (EPS) und XPS (OXPS) einzubinden. Die beiden letztgenannten Formate enthalten typischerweise Vektorelemente und Text. Wenn wir sie rastern und als Vollbilder einbinden möchten, können wir die folgende Option nutzen:

# Rasterize an included vector EPS graphic.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
save_options.rasterize_included_graphics = True
input_root = Path(os.environ.get("ASPOSE_TEX_INPUT_DIR", "input")).resolve()
options.input_working_directory = InputFileSystemDirectory(str(input_root / "Typesetting"))
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\usepackage{graphicx}\begin{document}\includegraphics{triangle.eps}\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()

Das Grafikbeispiel liest Typesetting/triangle.eps unter ASPOSE_TEX_INPUT_DIR (Standard: input). Behalten Sie dieses Unterverzeichnis bei der Vorbereitung der Ressourcen bei.

Unterteilung von Schriftarten

Wenn wir die Größe der Ausgabedatei verringern möchten, können wir die Unterteilung von Schriftarten verwenden. Dies bedeutet, dass die Schriftarten im resultierenden Dokument keine Daten für die Glyphen enthalten, die im Dokument nicht vorhanden sind. Hier ist eine Lösung, um dies zu erreichen:

# Embed only the used font glyphs.
import os
from pathlib import Path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice, XpsSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.interaction = Interaction.NONSTOP_MODE
save_options = XpsSaveOptions()
save_options.subset_fonts = True
options.save_options = save_options
device = XpsDevice()
source = r"\documentclass{article}\begin{document}Hello, World!\end{document}"
with BytesIO(source.encode("ascii")) as stream:
    result = TeXJob(stream, device, options).run()