param_file_to_json_config.py

Go to the documentation of this file.

#!/usr/bin/env python3
 
import argparse
import json
import shlex
import sys
from pathlib import Path
 
 
REJECT_OPTION_NAMES = {
    "json_config",
    "param_file",
    "meshsets_config",
}
 
DEFAULT_PRIMARY_MESH_FILE = "mesh.h5m"
 
# FIXME: one might need to edit this if custom prefix is defined for petsc options
PETSC_PREFIXES = {
    "dm",
    "eps",
    "fieldsplit",
    "ksp",
    "mat",
    "mg",
    "pc",
    "pep",
    "snes",
    "st",
    "sub",
    "svd",
    "tao",
    "ts",
}
 
# Broadly reusable MoFEM options observed across tutorials and atom tests.
# Keep this list focused on generic framework/example controls rather than
# module-specific physics/material parameters.
MOFEM_OPTION_NAMES = {
    "atom_test",
    "base",
    "base_order",
    "calculate_reactions",
    "field_eval_coords",
    "geom_order",
    "is_atom_test",
    "is_partitioned",
    "log_no_color",
    "log_quiet",
    "log_sl",
    "log_view",
    "mofem_mg_coarse_order",
    "mofem_mg_levels",
    "mofem_mg_verbose",
    "my_geom_order",
    "my_is_partitioned",
    "my_order",
    "my_order_p",
    "my_order_u",
    "my_ref",
    "my_ref_order",
    "no_output",
    "order",
    "output_mesh_file",
    "post_proc_skin",
    "post_proc_vol",
    "project_geometry",
    "regression_test",
    "save_every",
    "save_step",
    "space",
    "space_order",
    "test",
    "test_num",
    "test_tol",
}
 
 
def parse_scalar(value):
    lower = value.lower()
    if lower == "true":
        return True
    if lower == "false":
        return False
 
    try:
        return int(value, 10)
    except ValueError:
        pass
 
    try:
        return float(value)
    except ValueError:
        return value
 
 
def is_number_token(token):
    try:
        int(token, 10)
        return True
    except ValueError:
        pass
 
    try:
        float(token)
        return True
    except ValueError:
        return False
 
 
def is_option_token(token):
    return token.startswith("-") and not is_number_token(token)
 
 
def classify_option(name):
    prefix = name.split("_", 1)[0]
    if prefix in PETSC_PREFIXES:
        return "petsc"
    if name in MOFEM_OPTION_NAMES:
        return "mofem"
    return None
 
 
def warn(message):
    print(f"warning: {message}", file=sys.stderr)
 
 
def expand_inline_option_strings(tokens):
    expanded = []
    for token in tokens:
        stripped = token.strip()
        if not stripped:
            continue
 
        if " " in token and stripped.startswith("-"):
            try:
                nested_tokens = shlex.split(token, posix=True)
            except ValueError:
                nested_tokens = []
            if nested_tokens and nested_tokens[0].startswith("-"):
                expanded.extend(nested_tokens)
                continue
 
        expanded.append(token)
 
    return expanded
 
 
def set_nested_option(tree, name, value):
    parts = [part for part in name.split("_") if part]
    if not parts:
        raise ValueError("empty option name")
 
    node = tree
    for part in parts[:-1]:
        existing = node.get(part)
        if existing is None:
            node[part] = {}
            node = node[part]
            continue
        if not isinstance(existing, dict):
            raise ValueError(
                f"cannot create nested option '{name}' because '{part}' is already scalar"
            )
        node = existing
 
    last = parts[-1]
    existing = node.get(last)
    if isinstance(existing, dict):
        raise ValueError(
            f"cannot assign scalar option '{name}' because it is already an object"
        )
    node[last] = value
 
 
def parse_tokens(tokens):
    parsed = []
    index = 0
    while index < len(tokens):
        token = tokens[index]
        if not token.startswith("-"):
            raise ValueError(f"unexpected token '{token}'")
 
        name = token.lstrip("-")
        if not name:
            raise ValueError("encountered empty option name")
 
        value = True
        if index + 1 < len(tokens) and not is_option_token(tokens[index + 1]):
            value = parse_scalar(tokens[index + 1])
            index += 1
 
        parsed.append((name, value))
        index += 1
 
    return parsed
 
 
def parse_param_file(path):
    options = []
    with path.open("r", encoding="utf-8") as handle:
        for line_number, raw_line in enumerate(handle, start=1):
            stripped = raw_line.strip()
            if not stripped or stripped.startswith("#"):
                continue
 
            lexer = shlex.shlex(raw_line, posix=True)
            lexer.whitespace_split = True
            lexer.commenters = "#"
            try:
                tokens = list(lexer)
            except ValueError as exc:
                warn(f"{path}:{line_number}: failed to tokenize line: {exc}")
                continue
 
            if not tokens:
                continue
            tokens = expand_inline_option_strings(tokens)
 
            try:
                options.extend(parse_tokens(tokens))
            except ValueError as exc:
                warn(f"{path}:{line_number}: {exc}")
                continue
 
    return options
 
 
def parse_inline_options(text, source="<inline options>"):
    lexer = shlex.shlex(text, posix=True)
    lexer.whitespace_split = True
    lexer.commenters = "#"
    try:
        tokens = list(lexer)
    except ValueError as exc:
        warn(f"{source}: failed to tokenize input: {exc}")
        return []
 
    if not tokens:
        return []
 
    tokens = expand_inline_option_strings(tokens)
 
    try:
        return parse_tokens(tokens)
    except ValueError as exc:
        warn(f"{source}: {exc}")
        return []
 
 
def build_config(options, version):
    primary_mesh_file = DEFAULT_PRIMARY_MESH_FILE
    used_placeholder_mesh = True
    python_script_files = []
    config = {
        "version": version,
        "meshes": [],
        "petsc": {},
        "mofem": {},
    }
 
    for name, value in options:
        if name == "file_name":
            primary_mesh_file = str(value)
            used_placeholder_mesh = False
            continue
 
        if name == "sdf_file":
            python_script_files.append(str(value))
            continue
 
        if name in REJECT_OPTION_NAMES:
            raise ValueError(
                f"option '-{name}' is not supported by the converter; "
                "remove it and configure that part manually"
            )
 
        section = classify_option(name)
        if section is None:
            warn(f"skipping unsupported option '-{name}' with value '{value}'")
            continue
        try:
            set_nested_option(config[section], name, value)
        except ValueError as exc:
            warn(f"skipping '-{name}' with value '{value}': {exc}")
            continue
 
    config["meshes"].append(
        {
            "name": "primary",
            "type": "MOAB_MESH",
            "file_name": primary_mesh_file,
        }
    )
 
    for index, python_script_file in enumerate(python_script_files, start=1):
        config["meshes"].append(
            {
                "name": f"python_script_{index}",
                "type": "PYTHON_SCRIPT",
                "file_name": python_script_file,
            }
        )
 
    return config, used_placeholder_mesh
 
 
def create_argument_parser():
    parser = argparse.ArgumentParser(
        description=(
            "Convert a PETSc/MoFEM param file or raw option string into a JSON "
            "config skeleton. The primary MOAB mesh comes from -file_name or "
            "defaults to mesh.h5m."
        )
    )
    parser.add_argument(
        "input",
        nargs="?",
        help="input PETSc param file path or raw option string",
    )
    parser.add_argument(
        "-o",
        "--output",
        type=Path,
        help="write JSON config to this file instead of stdout",
    )
    parser.add_argument(
        "--version",
        default="0.15",
        help="JSON config version to write (default: %(default)s)",
    )
    parser.add_argument(
        "--indent",
        type=int,
        default=2,
        help="JSON indentation level (default: %(default)s)",
    )
    return parser
 
 
def main():
    script_option_names = {"-h", "--help", "-o", "--output", "--version", "--indent"}
    raw_argv = sys.argv[1:]
 
    if raw_argv and raw_argv[0].startswith("-") and raw_argv[0] not in script_option_names:
        args = argparse.Namespace(output=None, version="0.15", indent=2)
        input_arg = " ".join(raw_argv)
    else:
        parser = create_argument_parser()
        args, unknown_args = parser.parse_known_args()
 
        input_arg = args.input
        if input_arg is None and unknown_args:
            input_arg = " ".join(unknown_args)
 
        if input_arg is None:
            parser.error("the following arguments are required: input")
 
    try:
        input_path = Path(input_arg)
        if input_path.exists():
            options = parse_param_file(input_path)
        else:
            options = parse_inline_options(input_arg)
        config, used_placeholder_mesh = build_config(options, args.version)
    except ValueError as exc:
        print(exc, file=sys.stderr)
        return 1
 
    output = json.dumps(config, indent=args.indent)
    if args.output:
        args.output.write_text(output + "\n", encoding="utf-8")
    else:
        print(output)
 
    if used_placeholder_mesh:
        print(
            f"no '-file_name' found; using placeholder primary mesh '{DEFAULT_PRIMARY_MESH_FILE}'",
            file=sys.stderr,
        )
 
    return 0
 
 
if __name__ == "__main__":
    raise SystemExit(main())