Altre opzioni di gestione Tex | Python tramite .NET

Gli esempi generano file XPS. Applicare prima una licenza e impostare ASPOSE_TEX_OUTPUT_DIR sulla cartella di output (predefinita: output). Usare una cartella distinta per ogni esempio per conservare tutti i risultati.

Impostazione della modalità di interazione

Come accennato in Tex Interaction Parapraph, Aspose.TeX per Python fornisce la capacità di impostare la modalità di interazione iniziale in cui si avvia il motore. Ecco un esempio di come può essere fatto:

# 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()

Impostazione del nome del lavoro

Quando il file di input principale viene fornito come nome di file, i file di output risultanti avranno lo stesso nome ma con estensioni diverse. Il motore TEX si riferisce al nome del file di input come * nome del lavoro * e lo utilizza per i file di output. L’eccezione sono file ausiliari con nomi di file esplicitamente specificati. Tuttavia, quando il file di input principale viene passato come stream, il motore TEX utilizza il nome del lavoro predefinito, che è texput. In entrambi gli scenari, è possibile annullare il nome del lavoro assegnando l’opzione di conversione appropriata.

# 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()

“Tempo di fermo”

Per generare automaticamente un titolo da determinate definizioni nel preambolo, il LaTeX offre una funzione che in genere include la data corrente. Tuttavia, potrebbero esserci casi in cui vogliamo fissare la data su un valore specifico. Ecco un metodo per raggiungere questo:

# 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()

Ignorando i pacchetti mancanti

Se abbiamo un file LaTeX che include riferimenti a pacchetti che non sono supportati dalla libreria aspy.tex per la libreria Python, il motore TEX incontrerà un errore e si fermerà quando si tenta di caricare questi pacchetti. Per evitare questo, possiamo utilizzare la seguente opzione:

# 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()

Come evitare di costruire legature

Per impostazione predefinita, il motore TEX costruisce ligature per coppie di caratteri specifiche se il carattere contiene i dati necessari. Tuttavia, possiamo istruire il motore a bypassare la costruzione della legatura usando il seguente codice:

# 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()

Ripetendo il lavoro

Come accennato nel paragrafo del file di input in LaTeX, etichette e riferimenti, ci sono situazioni in cui potremmo dover eseguire due volte lo stesso lavoro. Ecco un metodo per farlo:

# 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()

Trasformare le formule di matematica in immagini raster

Se è necessario convertire le formule di matematica in immagini raster invece di renderle con i caratteri, la seguente opzione può essere utilizzata a questo scopo:

# 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()

Trasformare la grafica in immagini raster

Il motore ObjectTex fornisce la capacità di includere i file grafici in formati raster come PNG e JPG, nonché formati PS (EPS) e XPS (OXPS). Questi ultimi due formati contengono in genere elementi vettoriali e testo. Se vogliamo rasterosi e includerli come immagini solide, possiamo utilizzare la seguente opzione:

# 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()

L’esempio grafico legge Typesetting/triangle.eps in ASPOSE_TEX_INPUT_DIR (predefinita: input). Conservare questa sottocartella quando si preparano le risorse.

Caratteri di sottolineare

Se desideriamo ridurre le dimensioni del file di output, possiamo impiegare il sottoinsieme dei caratteri, il che implica che i caratteri nel documento risultante non includeranno dati per quei glifi che non sono presenti nel documento. Ecco una soluzione per raggiungere questo obiettivo:

# 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()