Data Structures
class	_Action

class	_ArgSpec

class	ArgumentParser

class	DriverName

class	NormalOption

class	SchemaReport

class	TargetOption

Functions
	_install_onelib_shim ()

Tuple[List[_ArgSpec], SchemaReport]	_load_schema (str file_path)

bool	_has_action (List[_ArgSpec] args, type action_type)

bool	_has_any_name (List[_ArgSpec] args, List[str] names)

List[str]	_check_codegen_contract (List[_ArgSpec] args)

Tuple[List[str], List[str]]	_check_profile_contract (List[_ArgSpec] args)

Dict[str, str]	_read_ini (str path)

	_resolve_paths (str root, str target, str backend, bool installed)

	main ()

Detailed Description

Validator for ONE global target configuration packages.

What this script checks:
1) Target INI existence & minimal required keys (TARGET, BACKEND).
2) Command schema files (codegen.py, profile.py) exist for BACKEND.
3) Command schema is importable without ONE runtime by shimming `onelib.argumentparse`.
4) "Required" arguments are present in schemas:
   - codegen: DriverName, TargetOption, input{,_path}, output{,_path}
   - profile: DriverName, TargetOption, input{,_path}

Usage:
  python tools/validate_global_conf.py --root . \
      --target {TARGET_NAME} --backend {BACKEND_NAME}

You can also point to the "installed" layout:
  python tools/validate_global_conf.py --installed \
      --target {TARGET_NAME} --backend {BACKEND_NAME}

Function Documentation

◆ _check_codegen_contract()

List[str] validate_global_conf._check_codegen_contract ( List[_ArgSpec] args )

protected

Definition at line 157 of file validate_global_conf.py.

def _check_codegen_contract(args: List[_ArgSpec]) -> List[str]:
    errs = []
    if not _has_action(args, DriverName):
        errs.append("Missing DriverName action.")
    if not _has_action(args, TargetOption):
        errs.append("Missing TargetOption action.")
    if not _has_any_name(args, ["input", "input_path"]):
        errs.append("Missing input/input_path argument.")
    if not _has_any_name(args, ["--output", "--output_path"]):
        errs.append("Missing --output/--output_path option.")
    return errs
 
 

References _has_action(), and _has_any_name().

Referenced by main().

◆ _check_profile_contract()

Tuple[List[str], List[str]] validate_global_conf._check_profile_contract ( List[_ArgSpec] args )

protected

Definition at line 170 of file validate_global_conf.py.

def _check_profile_contract(args: List[_ArgSpec]) -> Tuple[List[str], List[str]]:
    errs, warns = [], []
    if not _has_action(args, DriverName):
        errs.append("Missing DriverName action.")
    if not _has_action(args, TargetOption):
        errs.append("Missing TargetOption action.")
    if not _has_any_name(args, ["input", "input_path"]):
        errs.append("Missing input/input_path argument.")
    return errs, warns
 
 

References _has_action(), and _has_any_name().

Referenced by main().

◆ _has_action()

bool validate_global_conf._has_action	(	List[_ArgSpec]	args,
		type	action_type
	)

protected

Definition at line 145 of file validate_global_conf.py.

def _has_action(args: List[_ArgSpec], action_type: type) -> bool:
    return any(a.action is action_type for a in args)

Referenced by _check_codegen_contract(), and _check_profile_contract().

◆ _has_any_name()

bool validate_global_conf._has_any_name	(	List[_ArgSpec]	args,
		List[str]	names
	)

protected

Definition at line 149 of file validate_global_conf.py.

def _has_any_name(args: List[_ArgSpec], names: List[str]) -> bool:
    for a in args:
        for n in a.names:
            if n in names:
                return True
    return False
 
 

Referenced by _check_codegen_contract(), and _check_profile_contract().

◆ _install_onelib_shim()

validate_global_conf._install_onelib_shim ( )

protected

Definition at line 87 of file validate_global_conf.py.

def _install_onelib_shim():
    mod_onelib = types.ModuleType("onelib")
    mod_argparse = types.ModuleType("onelib.argumentparse")
    mod_argparse.ArgumentParser = ArgumentParser
    mod_argparse.DriverName = DriverName
    mod_argparse.TargetOption = TargetOption
    mod_argparse.NormalOption = NormalOption
 
    # Both import styles are used in examples:
    #   from onelib import argumentparse
    #   from onelib.argumentparse import DriverName, ...
    sys.modules["onelib"] = mod_onelib
    sys.modules["onelib.argumentparse"] = mod_argparse
    mod_onelib.argumentparse = mod_argparse
 
 
# -----------------------------
# Utilities
# -----------------------------
@dataclass

Referenced by _load_schema().

◆ _load_schema()

Tuple[List[_ArgSpec], SchemaReport] validate_global_conf._load_schema ( str file_path )

protected

Definition at line 113 of file validate_global_conf.py.

def _load_schema(file_path: str) -> Tuple[List[_ArgSpec], SchemaReport]:
    rep = SchemaReport(file_path=file_path, ok=False)
    if not os.path.isfile(file_path):
        rep.messages.append(f"Missing schema file: {file_path}")
        return [], rep
 
    _install_onelib_shim()
    spec = importlib.util.spec_from_file_location("schema_module", file_path)
    mod = importlib.util.module_from_spec(spec)
    try:
        assert spec and spec.loader
        spec.loader.exec_module(mod)  # type: ignore
    except Exception as e:
        rep.messages.append(f"Import error: {e}")
        return [], rep
    if not hasattr(mod, "command_schema"):
        rep.messages.append("Schema module has no `command_schema()` function.")
        return [], rep
    try:
        parser = mod.command_schema()
    except Exception as e:
        rep.messages.append(f"command_schema() execution failed: {e}")
        return [], rep
    if not isinstance(parser, ArgumentParser):
        rep.messages.append(
            "command_schema() did not return an ArgumentParser instance (shim).")
        return [], rep
 
    rep.ok = True
    return parser.args, rep
 
 

References _install_onelib_shim().

Referenced by main().

◆ _read_ini()

Dict[str, str] validate_global_conf._read_ini ( str path )

protected

Definition at line 181 of file validate_global_conf.py.

def _read_ini(path: str) -> Dict[str, str]:
    # configparser with ; as comment
    parser = configparser.ConfigParser(strict=False,
                                       interpolation=None,
                                       delimiters=("=", ))
    # Treat keys as case-sensitive; normalize ourselves by not lowercasing
    parser.optionxform = str  # preserve case
    with io.open(path, "r", encoding="utf-8") as f:
        # Place everything in DEFAULT to keep simple key=value structure
        content = "[DEFAULT]\n" + f.read()
    parser.read_string(content)
    return dict(parser["DEFAULT"])
 
 

Referenced by main().

◆ _resolve_paths()

validate_global_conf._resolve_paths	(	str	root,
		str	target,
		str	backend,
		bool	installed
	)

protected

Definition at line 195 of file validate_global_conf.py.

def _resolve_paths(root: str, target: str, backend: str, installed: bool):
    if installed:
        target_ini = f"/usr/share/one/target/{target}.ini"
        codegen_py = f"/usr/share/one/backends/command/{backend}/codegen.py"
        profile_py = f"/usr/share/one/backends/command/{backend}/profile.py"
    else:
        target_ini = os.path.join(root, "target", target, f"{target}.ini")
        codegen_py = os.path.join(root, "backend", backend, "one-cmds", "codegen.py")
        profile_py = os.path.join(root, "backend", backend, "one-cmds", "profile.py")
    return target_ini, codegen_py, profile_py
 
 

Referenced by main().

◆ main()

validate_global_conf.main ( void )

Definition at line 207 of file validate_global_conf.py.

def main():
    ap = argparse.ArgumentParser(
        description="Validate ONE global target configuration package.")
    ap.add_argument("--root", default=".", help="Repo root (for source-tree validation).")
    ap.add_argument("--target", required=True, help="Target name, e.g., Rose")
    ap.add_argument("--backend", required=True, help="Backend name, e.g., dummy")
    ap.add_argument("--installed",
                    action="store_true",
                    help="Validate installed paths instead of source tree.")
    args = ap.parse_args()
 
    target_ini, codegen_py, profile_py = _resolve_paths(args.root, args.target,
                                                        args.backend, args.installed)
 
    print("== ONE Global Conf Validator ==")
    print(f"Mode      : {'installed' if args.installed else 'source-tree'}")
    print(f"Target INI: {target_ini}")
    print(f"Codegen   : {codegen_py}")
    print(f"Profile   : {profile_py}")
    print("")
 
    # 1) INI
    if not os.path.isfile(target_ini):
        print(f"[ERROR] Target INI not found: {target_ini}")
        return 2
    kv = _read_ini(target_ini)
    errors = []
    for k in ("TARGET", "BACKEND"):
        if k not in kv or not kv[k].strip():
            errors.append(f"Missing required key {k} in INI.")
    if errors:
        for e in errors:
            print(f"[ERROR] {e}")
        return 2
 
    target_val = kv["TARGET"].strip()
    backend_val = kv["BACKEND"].strip()
    if target_val != args.target:
        print(f"[WARN] TARGET in INI is '{target_val}' but --target is '{args.target}'")
    if backend_val != args.backend:
        print(
            f"[WARN] BACKEND in INI is '{backend_val}' but --backend is '{args.backend}'")
 
    # 2) Load schemas
    codegen_args, codegen_rep = _load_schema(codegen_py)
    profile_args, profile_rep = _load_schema(profile_py)
 
    ok = True
 
    def print_report(name: str, rep: SchemaReport):
        nonlocal ok
        status = "OK" if rep.ok else "FAIL"
        print(f"[{name}] {rep.file_path}: {status}")
        for m in rep.messages:
            print(f"  - {m}")
        if not rep.ok:
            ok = False
 
    print_report("SCHEMA", codegen_rep)
    print_report("SCHEMA", profile_rep)
 
    # 3) Contracts
    if codegen_rep.ok:
        cerrs = _check_codegen_contract(codegen_args)
        for e in cerrs:
            print(f"[ERROR] codegen schema: {e}")
        ok = ok and not cerrs
    if profile_rep.ok:
        perrs, pwrns = _check_profile_contract(profile_args)
        for e in perrs:
            print(f"[ERROR] profile schema: {e}")
        for w in pwrns:
            print(f"[WARN] profile schema: {w}")
        ok = ok and not perrs
 
    print("")
    if ok:
        print("[PASS] Validation succeeded.")
        return 0
    else:
        print("[FAIL] Validation failed.")
        return 2
 
 

References _check_codegen_contract(), _check_profile_contract(), _load_schema(), _read_ini(), _resolve_paths(), and main().

Referenced by main().

Data Structures

Functions

Detailed Description

Function Documentation

◆ _check_codegen_contract()

◆ _check_profile_contract()

◆ _has_action()

◆ _has_any_name()

◆ _install_onelib_shim()

◆ _load_schema()

◆ _read_ini()

◆ _resolve_paths()

◆ main()