"""`pyvista convert file.in file.out` CLI.""" from __future__ import annotations from pathlib import Path from typing import Annotated import warnings from cyclopts import Parameter from rich.progress import BarColumn from rich.progress import MofNCompleteColumn from rich.progress import Progress from rich.progress import TextColumn from rich.progress import TimeElapsedColumn from rich.progress import TimeRemainingColumn import pyvista as pv from .app import app from .utils import HELP_FORMATTER from .utils import _check_paths_exist from .utils import _console_error from .utils import _filter_multiblock_children def _is_extension_only(file_out: str) -> bool: """Return ``True`` when ``file_out`` specifies only an extension (``.pv`` or ``dir/.pv``).""" path = Path(file_out) return not path.suffix and path.stem.startswith('.') def _validate_out_has_extension(file_out: str) -> None: """Raise ``ValueError`` when ``file_out`` is missing a file extension.""" if not Path(file_out).suffix and not _is_extension_only(file_out): msg = 'Output file must have a file extension.' raise ValueError(msg) @app.command( usage=f'Usage: [bold]{pv.__name__} convert FILE-IN [FILE-IN...] FILE-OUT', help_formatter=HELP_FORMATTER, ) def _convert( files: Annotated[ list[str], Parameter( name='files', consume_multiple=True, negative='', help=( 'One or more input files followed by the output spec. ' 'Inputs may include glob patterns (e.g. ``*.vtu``) and must be readable ' 'with ``pyvista.read``. The final token is the output: a full filename ' '(``bar.xyz``) when converting a single input, or an extension-only spec ' '(``.xyz`` or ``dir/.xyz``) which reuses each input stem. A bare ``.xyz`` ' 'writes adjacent to each input; ``dir/.xyz`` writes into ``dir/``.' ), ), ], ) -> None: """Convert a mesh file to another format. One or more inputs may be supplied, and glob patterns are expanded. When multiple inputs are given, the output must be an extension-only spec (``.xyz`` or ``dir/.xyz``) so each input's stem is reused. A bare ``.xyz`` writes the output adjacent to each input; ``dir/.xyz`` writes into the given ``dir``. MultiBlock files (``.vtm``/``.vtmb``) are paired on disk with a sibling sidecar directory (e.g. ``parent.vtm`` -> ``parent/parent_0.vtp``). Pass the parent ``.vtm`` directly to convert a MultiBlock as a single output; a recursive glob like ``**/*`` may also pick up the sidecar children. When both a parent and its sidecar children appear in the input list the children are dropped automatically to preserve the 1:1 input/output mapping. Sample usage: ```bash pyvista convert foo.abc bar.xyz Saved: bar.xyz pyvista convert foo.abc .xyz Saved: foo.xyz pyvista convert sub/*.vtu .pv # Writes sub/a.pv, sub/b.pv, ... next to each input pyvista convert sub/*.vtu out/.pv # Writes out/a.pv, out/b.pv, ... into the explicit out directory ``` """ if len(files) < 2: _console_error( app=app, message='convert requires at least one input file and an output spec.', ) file_out = files[-1] file_in_tokens = files[:-1] try: _validate_out_has_extension(file_out) except ValueError as e: _console_error(app=app, message=str(e)) try: input_paths = _check_paths_exist(file_in_tokens) except ValueError as e: _console_error(app=app, message=str(e)) input_paths, dropped = _filter_multiblock_children(input_paths) if dropped: n = len(dropped) listed = ', '.join(str(p) for p in dropped[:5]) if n > 5: listed += f', ... ({n - 5} more)' app.console.print( f'[yellow]Skipping {n} file(s) inside MultiBlock sidecar directories:[/yellow] ' f'{listed}' ) path_out = Path(file_out) ext_only = _is_extension_only(file_out) if not ext_only and len(input_paths) > 1: _console_error( app=app, message=( f'Cannot write {len(input_paths)} inputs to a single named output ' f'{file_out!r}. Use an extension-only output spec (e.g. ' f"'{path_out.suffix}') to reuse each input's stem." ), ) if len(input_paths) > 1: _convert_many(input_paths, path_out) else: _convert_one(input_paths[0], path_out, ext_only=ext_only, announce=True) def _read_mesh(path_in: Path) -> pv.DataObject: """Read ``path_in`` while suppressing :class:`pv.InvalidMeshWarning`.""" with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=pv.InvalidMeshWarning) return pv.read(path_in) def _resolve_out_path(path_in: Path, path_out: Path, *, ext_only: bool) -> Path: """Compute the per-input output path. A bare extension-only spec (``.pv``) is written next to each input. An extension-only spec with an explicit parent (``out/.pv``) is written into that parent. """ if not ext_only: return path_out out_dir = path_in.parent if str(path_out.parent) == '.' else path_out.parent return out_dir / f'{path_in.stem}{path_out.stem}' def _convert_one( path_in: Path, path_out: Path, *, ext_only: bool, announce: bool, ) -> None: """Read a single input, save it under the resolved output path, and optionally announce.""" out_path = _resolve_out_path(path_in, path_out, ext_only=ext_only) out_path.parent.mkdir(parents=True, exist_ok=True) try: mesh = _read_mesh(path_in) except Exception as e: # noqa: BLE001 _console_error(app=app, message=f'Failed to read input file: {path_in}\n{e}') try: mesh.save(out_path) except Exception as e: # noqa: BLE001 _console_error(app=app, message=f'Failed to save output file: {out_path}\n{e}') if announce: app.console.print(f'[green]Saved:[/green] {out_path}') def _convert_many(input_paths: list[Path], path_out: Path) -> None: """Convert each input under a progress bar and report the destination directory(s).""" columns = ( TextColumn('[progress.description]{task.description}'), BarColumn(), MofNCompleteColumn(), TextColumn('•'), TimeElapsedColumn(), TextColumn('<'), TimeRemainingColumn(), ) out_dirs: set[Path] = set() with Progress(*columns, console=app.console, transient=False) as progress: task = progress.add_task('Converting', total=len(input_paths)) for path_in in input_paths: progress.update(task, description=f'Converting [cyan]{path_in.name}[/cyan]') out_path = _resolve_out_path(path_in, path_out, ext_only=True) out_dirs.add(out_path.parent) _convert_one(path_in, path_out, ext_only=True, announce=False) progress.update(task, advance=1) if len(out_dirs) == 1: app.console.print( f'[green]Saved {len(input_paths)} files to:[/green] {next(iter(out_dirs))}/' ) else: app.console.print( f'[green]Saved {len(input_paths)} files across {len(out_dirs)} directories.[/green]' )