""" Silique (https://www.silique.fr) Copyright (C) 2024-2025 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Mtools is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Mtools. If not, see . """ import os from warnings import filterwarnings from pathlib import Path from sys import exit from warnings import warn from tiramisu_cmdline_parser import TiramisuCmdlineParser from tiramisu.error import PropertiesOptionError from tiramisu import MetaConfig from rougail import Rougail from rougail.user_datas import UserDatas from rougail.config import get_rougail_config from rougail.utils import load_modules from rougail.error import RougailWarning try: from rougail.user_data_yaml import RougailUserDataYaml except ImportError: RougailUserDataYaml = None try: from rougail.user_data_environment import RougailUserDataEnvironment except ImportError: RougailUserDataEnvironment = None from .rougailconfig import load as rougailconfig_load from .i18n import _ ENV_PREFIX = "ROUGAILCLI" def _main(arguments, do_not_print): global print_traceback rougailconfig = get_rougail_config( backward_compatibility=False, add_extra_options=False ) cmd_config = load_cmd_user_datas(rougailconfig, arguments) print_traceback = rougailconfig["cli.debug"] if rougailconfig["cli.versions"]: versions = display_version(cmd_config) if do_not_print: return list(versions) for version in versions: print(version) exit() metaconfig, config, err_warn = load_user_datas(rougailconfig) output = get_output(rougailconfig, metaconfig, config, err_warn) if do_not_print: return output.run() ret = output.print() if ret is False: exit(1) def load_cmd_user_datas(rougailconfig, arguments): rougailconfig.generate_config() cmd_config = rougailconfig.config origin_prop = cmd_config.property.default("read_write", "append") cmd_config.property.setdefault( frozenset(origin_prop | {"not_for_commandline"}), "read_write", "append" ) cmd_config.property.read_write() config_file = None if RougailUserDataYaml: _config_file = os.environ.pop(f"{ENV_PREFIX}_CLI.CONFIG_FILE", None) if not _config_file: _config_file = cmd_config.forcepermissive.option("cli.config_file").value.get() if Path(_config_file).is_file(): config_file = _config_file if RougailUserDataEnvironment: env_prefix = ENV_PREFIX else: env_prefix = None user_data = rougailconfig_load(rougailconfig, config_file, env_prefix, True, _arguments=arguments, _generate=False, _add_help=False) display_warnings = rougailconfig["cli.warnings"] manage_warnings(display_warnings) if not cmd_config.option("cli.versions").value.get(): if display_warnings and user_data["warnings"]: for warning in user_data["warnings"]: warn(warning) if manage_warnings: # replays to display errors if needed parser = TiramisuCmdlineParser( cmd_config, short_name_max_len=2, ) parser.parse_args(arguments) if user_data["errors"]: raise Exception(user_data["errors"][0]) cmd_config.property.setdefault(origin_prop, "read_write", "append") cmd_config.property.read_only() cmd_config.property.remove("not_for_commandline") return cmd_config def display_version(cmd_config): versions = [] from tiramisu import __version__ yield(f"tiramisu: {__version__}") from tiramisu_cmdline_parser import __version__ yield(f"tiramisu-cmdline-parser: {__version__}") from rougail import __version__ yield(f"rougail: {__version__}") from . import __version__ yield(f"rougail-cli: {__version__}") for step in ["structural", "user_data", "output"]: display_step = step.replace("_", "-") for step_name in sorted(cmd_config.unrestraint.option(f"step.{step}").value.list()): path = ( Path(__file__).parent.parent / (step + "_" + step_name) / "__init__.py" ) if path.is_file(): try: module = load_modules( "rougail." + step + "_" + step_name, str(path) ) yield( f"rougail-{display_step}-{step_name}: {module.__version__}" ) except Exception as err: pass def manage_warnings(warnings): if not warnings: filterwarnings("ignore", category=DeprecationWarning) filterwarnings("ignore", category=RougailWarning) else: filterwarnings("default", category=DeprecationWarning) filterwarnings("default", category=RougailWarning) def load_user_datas(rougailconfig): if not rougailconfig["cli.load_config"]: return None, {"errors": [], "warnings": []} try: user_data_names = rougailconfig["step.user_data"] except PropertiesOptionError: user_data_names = [] if rougailconfig["cli.layers"]: layers = [[ud] for ud in user_data_names] last_layers = len(layers) - 1 else: layers = [user_data_names] last_layers = 0 rougail = Rougail(rougailconfig) layer_name = "_".join(layers[-1]) config = rougail.run(name=layer_name) metaconfig = config if last_layers: for layer in layers[:-1]: layer_name = "_".join(layer) metaconfig = MetaConfig([metaconfig], name=layer_name) metaconfig.owner.set(metaconfig.path()) subconfig = metaconfig err_warn = {"errors": [], "warnings": []} for idx, layer in enumerate(layers): if idx: subconfig = subconfig.config("_".join(layer)) config.owner.set(subconfig.path()) subconfig.property.read_write() # data user user_datas = [] for user_data_name in layer: path = ( Path(__file__).parent.parent / ("user_data_" + user_data_name) / "__init__.py" ) if not path.is_file(): raise Exception( _('cannot find "user_data" module "{0}"').format(user_data_name) ) module = load_modules("rougail.user_data_" + user_data_name, str(path)) user_datas.extend( module.RougailUserData( subconfig, rougailconfig=rougailconfig, ).run() ) if user_datas: new_err_warn = UserDatas(subconfig).user_datas(user_datas) for level, datas in new_err_warn.items(): if datas: err_warn[level].updates(datas) subconfig = metaconfig for idx, layer in enumerate(layers): if idx: subconfig = subconfig.config("_".join(layer)) return metaconfig, config, err_warn def get_output(rougailconfig, metaconfig, config, err_warn): # output if config and (not rougailconfig["cli.load_config"] or not rougailconfig["cli.read_write"]): config.property.read_only() output_name = rougailconfig["step.output"] path = Path(__file__).parent.parent / ("output_" + output_name) / "__init__.py" if not path.is_file(): raise Exception( _('cannot find cli file for "output_name" module "{0}"').format(output_name) ) module = load_modules("rougail.output_" + output_name, str(path)) output = module.RougailOutput( config=config, rougailconfig=rougailconfig, user_data_errors=err_warn["errors"], user_data_warnings=err_warn["warnings"], config_owner_is_path=True, metaconfig=metaconfig, ) return output def main(arguments=None, do_not_print=False): global print_traceback print_traceback = True try: return _main(arguments, do_not_print) except Exception as err: if print_traceback: import traceback traceback.print_exc() exit(_("ERROR: {0}").format(err))