""" 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 tiramisu_cmdline_parser import TiramisuCmdlineParser from tiramisu.error import PropertiesOptionError from tiramisu import Config from rougail import Rougail 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) else: manage_warnings(rougailconfig["cli.warnings"]) config, err_warn = load_user_datas(rougailconfig) output = get_output(rougailconfig, 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, display_warnings=cmd_config.option("cli.warnings").value.get(), raise_on_error=False, _arguments=arguments, _generate=False) # replays to display errors if needed if not cmd_config.option("cli.versions").value.get(): 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.remove("not_for_commandline") cmd_config.property.read_only() 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): try: user_data_names = rougailconfig["step.user_data"] except PropertiesOptionError: user_data_names = [] # structural if rougailconfig["cli.load_config"]: rougail = Rougail(rougailconfig) config = rougail.run() config.property.read_write() else: config = None # data user user_datas = [] for user_data_name in user_data_names: 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( config, rougailconfig=rougailconfig, ).run() ) if user_datas: err_warn = rougail.user_datas(user_datas) else: err_warn = {"errors": [], "warnings": []} return config, err_warn def get_output(rougailconfig, 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"], ) 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))