Asspose.Tex's Input Interface | Python tramite .NET

Per definizioni formali dell’implementazione I/O in Aspose.TeX per Python, consultare il riferimento API.

L’idea alla base della directory di input

Dato che i primitivi I/O della lingua tex possono solo gestire i nomi dei file, aspose.tex per Python definisce una directory come una mappatura tra nomi e raccolte di dati. Queste raccolte di dati possono essere file, flussi, array o qualsiasi altro tipo. L’API consente una specifica separata di directory di lavoro input e output. Fornisce la classe generale inputworkingdirectory, che gli utenti possono implementare per le loro esigenze specifiche. Inoltre, l’API fornisce implementazioni integrate, che saranno discusse più avanti. L’interfaccia include il metodo get_file(), che recupera il flusso di dati e determina il nome completo in base a un nome dato, che funge da tasto di mappatura.

Recupero input di file dal file system disco

Ecco l’approccio che adotteremmo:

Impostare ASPOSE_TEX_OUTPUT_DIR sulla directory di output (predefinita: output). Applicare prima una licenza. Licensing.

# Read a TeX file from a file system working directory.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice

input_dir = Path(os.environ.get("ASPOSE_TEX_INPUT_DIR", "input")).resolve()
if not (input_dir / "hello-world.tex").is_file():
    raise FileNotFoundError(input_dir / "hello-world.tex")
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_tex())
options.interaction = Interaction.NONSTOP_MODE
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
options.input_working_directory = InputFileSystemDirectory(str(input_dir))
device = XpsDevice()
job_result = TeXJob("hello-world.tex", device, options).run()

Impostare ASPOSE_TEX_INPUT_DIR sulla cartella con hello-world.tex (predefinita: input). L’esempio usa plain TeX con TeXConfig.object_tex() e genera hello-world.xps e hello-world.log. Input:

Hello, World!
\end

Recupero input di file da un archivio zip

Un’altra opzione è archiviare i file di input in un archivio ZIP e trattarli come una directory di input. In tale scenario, dovrebbero essere seguiti i seguenti passaggi:

# Read a TeX file from a subdirectory inside a ZIP archive.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputZipDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
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_zip = Path(os.environ.get("ASPOSE_TEX_INPUT_ZIP", "zip-in.zip")).resolve()

# Keep the binary ZIP stream open until the job finishes.
with input_zip.open("rb") as input_stream:
    options = TeXOptions.console_app_options(TeXConfig.object_tex())
    options.interaction = Interaction.NONSTOP_MODE
    options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
    options.terminal_out = OutputMemoryTerminal()
    # Resolve hello-world.tex inside the in/ directory of the archive.
    options.input_working_directory = InputZipDirectory(input_stream, "in")
    device = XpsDevice()
    job_result = TeXJob("hello-world.tex", device, options).run()

ASPOSE_TEX_INPUT_ZIP indica un archivio con in/hello-world.tex (predefinito: zip-in.zip). Aprirlo in modalità binaria rb e mantenere aperto il flusso fino al termine del lavoro.

Per iniziare, creiamo il flusso contenente il file ZIP. Successivamente, dopo aver creato le opzioni di conversione, assegniamo un’istanza della classe InputZipDirectory alla proprietà input_working_directory. Il secondo parametro del costruttore rappresenta il percorso di base all’interno dell’archivio. Se desideriamo che l’intero archivio funzioni come directory di input, dobbiamo fornire una stringa vuota come argomento.

L’idea alla base del terminale di input

Ora consideriamo il concetto di input terminale. Aspose.TeX per Python definisce l’interfaccia generale iinputterminal specificamente a questo scopo, che include una singola proprietà che restituisce un’istanza di TerminalReader. Le implementazioni disponibili saranno discusse in seguito.

Ottenere l’input del terminale dalla console

Per raggiungere questo obiettivo, dobbiamo assegnare un’istanza della classe inputConsoleterminal all’opzione terminale_in.

# Read a line from the console while processing a TeX stream.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from io import BytesIO
from aspose.tex.io import InputConsoleTerminal, OutputConsoleTerminal, OutputFileSystemDirectory
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)

options = TeXOptions.console_app_options(TeXConfig.object_tex())
options.interaction = Interaction.SCROLL_MODE
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_in = InputConsoleTerminal()
options.terminal_out = OutputConsoleTerminal()
# Enter a line of text when TeX requests input.
with BytesIO(br"\read-1 to \answer \answer\par\end") as input_stream:
    job_result = TeXJob(input_stream, XpsDevice(), options).run()

L’esempio legge una riga con \read e la scrive in texput.xps. Digitare, ad esempio, Terminal input works! nel terminale o fornire la riga tramite input standard. SCROLL_MODE consente questa richiesta di input.