src/latex_include/main.py

def latexInclude(inFile:typing.TextIO, outFile:typing.TextIO, includeDir:pl.Path|str|None=None) -> None:
    """Start recursively resolving inputs/includes

    Args:
        inFile:     An open read text file object to read input LaTeX code from
        outFile:    An open write text file object to write resolved LaTeX code to
        includeDir: Optional dir to resolve includes from. If omitted the current
                    dir is used.
    """
    if not includeDir:
        includeDir = pl.Path.cwd()
    _recursion(inFile, outFile, pl.Path(includeDir))

def latexIncludeFiles(inPath:pl.Path|str, outPath:pl.Path|str|None=None, overwrite:bool=False) -> None:
    """Open files and call `latexInclude` with them using `inPath`'s parent as `includeDir`

    Both files can be given as `pathlib.Path` or string.

    We require `inPath` instead of defaulting to `stdin`, because we need
    its directory to resolve relative input/include paths in the LaTeX code

    Args:
        inPath:    path of input file
        outPath:   optional name of output file, if omitted `stdout` is used instead
        overwrite: overwrite existing output file if `True`

    Raises:
        OSError:           If a file cannot be opened.
        FileNotFoundError: If `inPath` is not found.
        FileExistsError:   If `outPath` exists and `overwrite` is `False`.

    Note:
        `FileNotFoundError` and `FileExistsError` are specializations of `OSError`,
        so catch them before `OSError`.
    """
    inPath = pl.Path(inPath)
    if not inPath.is_file():
        raise FileNotFoundError(inPath)

    inPathAbs = inPath.absolute()
    if outPath:
        # Mode 'x' raises FileExistsError if file exists
        mode = 'w' if overwrite else 'x'
        outPathAbs = pl.Path(outPath).absolute()
        output:contextlib.AbstractContextManager[typing.TextIO] = contextlib.closing(outPathAbs.open(mode))
    else:
        output = contextlib.nullcontext(sys.stdout)

    with inPathAbs.open() as inFile:
        with output as outFile:
            latexInclude(inFile, outFile, inPathAbs.parent)

def main() -> None:
    """Called from command line

    Parses command line for input and output and calls `latexIncludeFiles` with them.

    If output exists an additional command line flag is required to overwrite it.
    """
    parser = argparse.ArgumentParser(description="Resolve input/include commands in a LaTeX file to a single file")

    # See latexIncludeFiles documentation, why --input is required
    parser.add_argument('-i', '--input', required=True, type=pl.Path, help="Main LaTeX file to resolve")
    parser.add_argument('-o', '--output', type=pl.Path, help="Output file, default is stdout")
    parser.add_argument('-w', '--overwrite', action='store_true', help="Silently overwrite existing diff (default: %(default)s)")
    parser.add_argument('--version', action='version', version=importlib.metadata.version('latex-include'), help="Show version number and exit")
    args = parser.parse_args()

    try:
        latexIncludeFiles(args.input, args.output, overwrite=args.overwrite)
    except FileNotFoundError as ex:
        print(f"Input file not found: {ex}")
        exit(1)
    except FileExistsError as ex:
        print(f"Output exists. Delete it or set option --overwrite (-w) to overwrite it: {ex}")
        exit(1)
    except OSError as ex:
        ic(ex)
        print(f"Cannot open input or output file: {ex}")
        exit(1)