feat: Added the rendercv_settings block

rendercv/cli/commands.py

@@ -3,9 +3,10 @@
 commands of RenderCV.
 """
 
+import inspect
 import os
 import pathlib
-from typing import Annotated, Literal, Optional
+from typing import Annotated, Optional
 
 import typer
 from rich import print
@@ -98,23 +99,23 @@ def cli_command_render(
             help="Copy the PNG file to the given path.",
         ),
     ] = None,
-    dont_generate_markdown: Annotated[
+    no_markdown: Annotated[
         bool,
         typer.Option(
             "--dont-generate-markdown",
             "-nomd",
             help="Don't generate the Markdown and HTML file.",
         ),
     ] = False,
-    dont_generate_html: Annotated[
+    no_html: Annotated[
         bool,
         typer.Option(
             "--dont-generate-html",
             "-nohtml",
             help="Don't generate the HTML file.",
         ),
     ] = False,
-    dont_generate_png: Annotated[
+    no_png: Annotated[
         bool,
         typer.Option(
             "--dont-generate-png",
@@ -141,57 +142,90 @@ def cli_command_render(
     input_file_path: pathlib.Path = utilities.string_to_file_path(
         input_file_name
     )  # type: ignore
-    output_directory = pathlib.Path.cwd() / output_folder_name
-
-    paths: dict[
-        Literal["latex", "pdf", "markdown", "html", "png"], Optional[pathlib.Path]
-    ] = {
-        "latex": utilities.string_to_file_path(latex_path),
-        "pdf": utilities.string_to_file_path(pdf_path),
-        "markdown": utilities.string_to_file_path(markdown_path),
-        "html": utilities.string_to_file_path(html_path),
-        "png": utilities.string_to_file_path(png_path),
+
+    # dictionary for command line arguments:
+    cli_args = {
+        "use_local_latex_command": use_local_latex_command,
+        "output_folder_name": output_folder_name,
+        "latex_path": utilities.string_to_file_path(latex_path),
+        "pdf_path": utilities.string_to_file_path(pdf_path),
+        "markdown_path": utilities.string_to_file_path(markdown_path),
+        "html_path": utilities.string_to_file_path(html_path),
+        "png_path": utilities.string_to_file_path(png_path),
+        "no_markdown": no_markdown,
+        "no_html": no_html,
+        "no_png": no_png,
+    }
+
+    # Use inspect to get the default values of the arguments:
+    sig = inspect.signature(cli_command_render)
+    cli_args_default = {
+        k: v.default
+        for k, v in sig.parameters.items()
+        if v.default is not inspect.Parameter.empty
     }
 
+    # keep the current working directory:
+    working_directory = pathlib.Path.cwd()
+
     # change the current working directory to the input file's directory (because
     # the template overrides are looked up in the current working directory):
     os.chdir(input_file_path.parent)
 
     # compute the number of steps
-    # 1. read and validate the input file
+    # 0. read the input file
+    # 1. validate the input file
     # 2. generate the LaTeX file
     # 3. render the LaTeX file to a PDF
     # 4. render PNG files from the PDF
     # 5. generate the Markdown file
     # 6. render the Markdown file to a HTML (for Grammarly)
+
+    data_as_a_dict = data.read_a_yaml_file(input_file_path)
+
+    # update the data if there are extra override arguments:
+    if extra_data_model_override_argumets:
+        key_and_values = dict()
+        key_and_values = utilities.parse_render_command_override_arguments(
+            extra_data_model_override_argumets
+        )
+        data_as_a_dict = utilities.set_or_update_values(data_as_a_dict, key_and_values)
+
+    # update the data of the rendercv settings:
+    render_cv_settings = data_as_a_dict.get("rendercv_settings", dict())
+    if render_cv_settings is None:
+        render_cv_settings = dict()
+
+    # get the render options:
+    render_options = render_cv_settings.get("render", dict())
+    render_options = utilities.update_render_settings(
+        render_options, cli_args, cli_args_default
+    )
+
+    # update the data model with the rendercv settings:
+    render_cv_settings["render"] = render_options
+    data_as_a_dict["rendercv_settings"] = render_cv_settings
+
+    # Calculate the number of steps:
     number_of_steps = 6
-    if dont_generate_png:
-        number_of_steps = number_of_steps - 1
-    if dont_generate_markdown:
-        # if the Markdown file is not generated, then the HTML file is not generated
-        number_of_steps = number_of_steps - 2
+    if data_as_a_dict["rendercv_settings"]["render"]["no_png"]:
+        number_of_steps -= 1
+    if data_as_a_dict["rendercv_settings"]["render"]["no_markdown"]:
+        number_of_steps -= 2
     else:
-        if dont_generate_html:
-            number_of_steps = number_of_steps - 1
-
-    with printer.LiveProgressReporter(number_of_steps) as progress:
-        progress.start_a_step("Reading and validating the input file")
-        data_as_a_dict = data.read_a_yaml_file(input_file_path)
-
-        # update the data if there are extra override arguments:
-        if extra_data_model_override_argumets:
-            key_and_values = dict()
-            key_and_values = utilities.parse_render_command_override_arguments(
-                extra_data_model_override_argumets
-            )
-            data_as_a_dict = utilities.set_or_update_values(
-                data_as_a_dict, key_and_values
-            )
+        if data_as_a_dict["rendercv_settings"]["render"]["no_html"]:
+            number_of_steps -= 1
+
+    with printer.LiveProgressReporter(number_of_steps=number_of_steps) as progress:
+        progress.start_a_step("Validating the input file")
 
         data_model = data.validate_input_dictionary_and_return_the_data_model(
             data_as_a_dict
         )
 
+        render_options = data_model.rendercv_settings.render
+        output_directory = working_directory / render_options.output_folder_name
+
         progress.finish_the_current_step()
 
         progress.start_a_step("Generating the LaTeX file")
@@ -200,47 +234,60 @@ def cli_command_render(
                 data_model, output_directory
             )
         )
-        if paths["latex"]:
-            utilities.copy_files(latex_file_path_in_output_folder, paths["latex"])
+        if render_options.latex_path:
+            utilities.copy_files(
+                latex_file_path_in_output_folder,
+                render_options.latex_path,
+            )
         progress.finish_the_current_step()
 
         progress.start_a_step("Rendering the LaTeX file to a PDF")
         pdf_file_path_in_output_folder = renderer.render_a_pdf_from_latex(
             latex_file_path_in_output_folder, use_local_latex_command
         )
-        if paths["pdf"]:
-            utilities.copy_files(pdf_file_path_in_output_folder, paths["pdf"])
+        if render_options.pdf_path:
+            utilities.copy_files(
+                pdf_file_path_in_output_folder,
+                render_options.pdf_path,
+            )
         progress.finish_the_current_step()
 
-        if not dont_generate_png:
+        if not render_options.no_png:
             progress.start_a_step("Rendering PNG files from the PDF")
             png_file_paths_in_output_folder = renderer.render_pngs_from_pdf(
                 pdf_file_path_in_output_folder
             )
-            if paths["png"]:
-                utilities.copy_files(png_file_paths_in_output_folder, paths["png"])
+            if render_options.png_path:
+                utilities.copy_files(
+                    png_file_paths_in_output_folder,
+                    render_options.png_path,
+                )
             progress.finish_the_current_step()
 
-        if not dont_generate_markdown:
+        if not render_options.no_markdown:
             progress.start_a_step("Generating the Markdown file")
             markdown_file_path_in_output_folder = renderer.create_a_markdown_file(
                 data_model, output_directory
             )
-            if paths["markdown"]:
+            if render_options.markdown_path:
                 utilities.copy_files(
-                    markdown_file_path_in_output_folder, paths["markdown"]
+                    markdown_file_path_in_output_folder,
+                    render_options.markdown_path,
                 )
             progress.finish_the_current_step()
 
-            if not dont_generate_html:
+            if not render_options.no_html:
                 progress.start_a_step(
                     "Rendering the Markdown file to a HTML (for Grammarly)"
                 )
                 html_file_path_in_output_folder = renderer.render_an_html_from_markdown(
                     markdown_file_path_in_output_folder
                 )
-                if paths["html"]:
-                    utilities.copy_files(html_file_path_in_output_folder, paths["html"])
+                if render_options.html_path:
+                    utilities.copy_files(
+                        html_file_path_in_output_folder,
+                        render_options.html_path,
+                    )
                 progress.finish_the_current_step()
 
 

rendercv/cli/utilities.py

@@ -260,3 +260,41 @@ def parse_render_command_override_arguments(
         key_and_values[key] = value
 
     return key_and_values
+
+
+def update_render_settings(
+    dictionary: dict,
+    command_line_arguments: dict[str, str],
+    command_line_arguments_default_values: dict[str, str],
+) -> dict[str, str]:
+    """Build the RenderCV settings dictionary by combining the dictionary and the
+        command line arguments.
+
+    Args:
+        dictionary (dict): The dictionary to be combined with the command line
+            arguments.
+        command_line_arguments (dict[str, str]): The command line arguments.
+
+    Returns:
+        dict[str, str]: The combined dictionary.
+    """
+    # if the dictionary is empty, initialize it from the default values:
+    if not dictionary:
+        dictionary = command_line_arguments_default_values
+
+    # Combine the dictionary and the command line arguments if the values are not None:
+    for key, value in command_line_arguments.items():
+        # check if the key is present in the both
+        # command line arguments and the default values:
+        if key in command_line_arguments_default_values:
+            default_value = command_line_arguments_default_values[key]
+            if value != default_value:
+                dictionary = set_or_update_a_value(dictionary, key, str(value))
+        else:
+            # The key is not present in the default values, set the value:
+            # throw an error reporting this
+            raise ValueError(
+                f"The key ({key}) is not present in the default values of the command"
+                " line arguments!"
+            )
+    return dictionary