Otros formatos de salida de conversión TeX | Python

Es poco probable que actualmente necesites convertir un archivo TeX escrito en un formato que no sea LaTeX. Sin embargo, si por algún motivo estás estudiando el lenguaje TeX o las partes internas de TeX, todavía es posible. En cualquier caso, Aspose.TeX para Python le permite convertir archivos escritos en formato Plain TeX y también le permite crear formatos personalizados y componer documentos diseñados en estos formatos.

Para comenzar, crearemos un formato personalizado.

Creando un formato personalizado

Un archivo de formato es una representación binaria del estado interno del motor TeX. Aplique primero una licencia. Coloque customtex.tex en el subdirectorio CustomTeXFormat de ASPOSE_TEX_INPUT_DIR (predeterminado: input). ASPOSE_TEX_OUTPUT_DIR indica la carpeta de salida (predeterminada: output), donde el primer ejemplo crea customtex.fmt.

# Create a reusable custom TeX format.
import os
from pathlib import Path
from os import path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, InputZipDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.resourceproviders import FormatProvider
from aspose.tex.presentation.xps import XpsDevice

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)
input_dir = Path(os.environ.get("ASPOSE_TEX_INPUT_DIR", "input")).resolve() / "CustomTeXFormat"
# Create TeX engine options for no format upon ObjectTeX engine extension.
options = TeXOptions.console_app_options(TeXConfig.object_ini_tex)
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
# Specify a file system working directory for the input.
options.input_working_directory = InputFileSystemDirectory(str(input_dir))
# Specify a file system working directory for the output.
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))

# Run format creation.
TeXJob.create_format("customtex", options)

# For further output to look fine.
options.terminal_out.writer.write_line()

Como puede ver, el código se parece al código para convertir un archivo TeX. Sin embargo, hay algunas distinciones.

En primer lugar, en este caso, utilizamos la configuración del trabajo TeXConfig.object_ini_tex. Esta configuración garantiza que el estado del motor sea “virgen”, lo que significa que los parámetros internos tienen sus valores predeterminados y el conjunto de secuencias de control se alinea con el conjunto de primitivas. En nuestro ejemplo, el conjunto de primitivas se amplía en el artículo Aspose.TeX y Object TeX.

A continuación, procedemos a configurar los directorios de trabajo de entrada y salida como de costumbre. El directorio de trabajo de entrada debe incluir el archivo fuente del formato principal y todas sus dependencias.

Y la segunda gran diferencia es el método mediante el cual ejecutamos el trabajo. En este caso, utilizamos el método estático create_format(), que, junto con las opciones, requiere que el nombre del archivo fuente principal sea idéntico al nombre del formato.

Componer un archivo TeX en su formato personalizado

El siguiente ejemplo crea primero customtex.fmt para poder ejecutarse de forma independiente. Después carga el formato y compone el texto de un flujo binario en typeset-with-custom-format.xps.

# Typeset text using a custom TeX format.
import os
from pathlib import Path
from os import path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, InputZipDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.resourceproviders import FormatProvider
from aspose.tex.presentation.xps import XpsDevice

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)
input_dir = Path(os.environ.get("ASPOSE_TEX_INPUT_DIR", "input")).resolve() / "CustomTeXFormat"

format_options = TeXOptions.console_app_options(TeXConfig.object_ini_tex)
format_options.input_working_directory = InputFileSystemDirectory(str(input_dir))
format_options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
format_options.interaction = Interaction.NONSTOP_MODE
format_options.terminal_out = OutputMemoryTerminal()
TeXJob.create_format("customtex", format_options)
# Create the format provider using the file system input working directory.
# We use the project output directory as our custom format file is supposed to be located there.
with FormatProvider(InputFileSystemDirectory(str(output_dir)), "customtex") as format_provider:
    # Create conversion options for a custom format upon ObjectTeX engine extension.
    options = TeXOptions.console_app_options(TeXConfig.object_tex(format_provider))
    options.interaction = Interaction.NONSTOP_MODE
    options.terminal_out = OutputMemoryTerminal()
    options.job_name = "typeset-with-custom-format"
    # Specify the input working directory. This is not required here as we are providing the main input as a stream.
    # But it is required when the main input has dependencies (e.g. images).
    options.input_working_directory = InputFileSystemDirectory(str(input_dir))
    # Specify a file system working directory for the output.
    options.output_working_directory = OutputFileSystemDirectory(str(output_dir))

    # Run the job.
    TeXJob(BytesIO("Congratulations! You have successfully typeset this text with your own TeX format!\\end".encode('ascii')),
           XpsDevice(), options).run()

    # For further output to look fine.
    options.terminal_out.writer.write_line()

Para especificar el formato, necesitamos crear una instancia de la clase FormatProvider. En el constructor de opciones, usamos la configuración TeXConfig.object_tex(), que requiere nuestro proveedor de formato como argumento y carga el formato encima del estado “virgen” del motor.

El código restante debería resultarle familiar, ya que utiliza las funciones que se analizaron anteriormente en esta guía.

Composición tipográfica de un archivo TeX en formato Plain TeX

Si eliminamos el proveedor de formato del código mostrado arriba, el motor cargará el formato predeterminado, que es Object TeX en su cuarto sentido. Por lo tanto, si tiene un archivo TeX escrito en formato Plain TeX, puede convertirlo a cualquier formato de destino compatible utilizando este enfoque.