Remove the report_format parameter and put their values in the report_type enum. Add code to define congig_path and report_type as commandline args instead of variables in the main file. Modified main, report_generator, and vuegen_demo.ipynb with these changes.

Author: sayalaruano

docs/vuegen_demo.ipynb

@@ -11,8 +11,6 @@ report:
     and potential ecological functions.
   graphical_abstract: "example_data/MicW2Graph/Methods_MicW2Graph.png"
   logo: "example_data/mona_logo.png"
-  report_type: "document"
-  report_format: "docx"
 sections:
   - title: "Exploratory Data Analysis"
     subsections:

report_metadata_micw2graph.yaml renamed to report_config_micw2graph.yaml

@@ -1,24 +1,22 @@
 import report_generator
-from utils import get_logger, load_yaml_config
+from utils import get_logger, load_yaml_config, get_args
 
 if __name__ == '__main__':
+    # Parse command-line arguments
+    args = get_args(prog_name="Vuegen")
+    config_path = args.config
+    report_type = args.report_type
+    
     # Load the YAML configuration file with the report metadata
-    config_path = "report_metadata_micw2graph.yaml"
     report_config = load_yaml_config(config_path)
 
-    # Define logger suffix based on report engine, type and name
-    report_engine = "quarto" 
-    report_type = report_config['report'].get('report_type')
-    report_format = report_config['report'].get('report_format')
+    # Define logger suffix based on report type and name
     report_name = report_config['report'].get('name')
-    if report_engine == "streamlit": 
-        logger_suffix = f"{report_engine}_report_{report_name}"
-    else:
-        logger_suffix = f"{report_type}_{report_format}_report_{report_name}"
+    logger_suffix = f"{report_type}_report_{report_name}"
 
     # Initialize logger
     logger = get_logger(f"{logger_suffix}")
 
     # Generate the report
-    report_generator.get_report(config = report_config, report_engine = report_engine, logger = logger)
+    report_generator.get_report(config = report_config, report_type = report_type, logger = logger)
 

vuegen/main.py

@@ -1,19 +1,9 @@
 import os
 import subprocess
 import report as r
-from enum import StrEnum, auto
 from typing import List
 from utils import create_folder
 
-class ReportFormat(StrEnum):
-    HTML = auto()
-    PDF = auto()
-    DOCX = auto()
-    ODT = auto()
-    REVEALJS = auto()
-    PPTX = auto()
-    JUPYTER = auto()  
-
 class QuartoReportView(r.ReportView):
     """
     A ReportView subclass for generating Quarto reports.
@@ -22,9 +12,8 @@ class QuartoReportView(r.ReportView):
     BASE_DIR = 'quarto_report'
     STATIC_FILES_DIR = os.path.join(BASE_DIR, 'static')
 
-    def __init__(self, report: r.Report, report_type: r.ReportType, report_format: ReportFormat):
-        super().__init__(report=report, report_type = report_type)
-        self.report_format = report_format
+    def __init__(self, report: r.Report, report_type: r.ReportType):
+        super().__init__(report = report, report_type = report_type)
 
     def generate_report(self, output_dir: str = BASE_DIR, static_dir: str = STATIC_FILES_DIR) -> None:
         """
@@ -37,7 +26,7 @@ def generate_report(self, output_dir: str = BASE_DIR, static_dir: str = STATIC_F
         static_dir : str, optional
             The folder where the static files will be saved (default is STATIC_FILES_DIR).
         """
-        self.report.logger.debug(f"Generating '{self.report_type}' report with '{self.report_format}' format in directory: '{output_dir}'")
+        self.report.logger.debug(f"Generating '{self.report_type}' report in directory: '{output_dir}'")
 
         # Create the output folder
         if create_folder(output_dir):
@@ -53,8 +42,8 @@ def generate_report(self, output_dir: str = BASE_DIR, static_dir: str = STATIC_F
 
         try:
             # Create variable to check if the report is static or revealjs
-            is_report_static = self.report_format in {ReportFormat.PDF, ReportFormat.DOCX, ReportFormat.ODT, ReportFormat.PPTX}
-            is_report_revealjs = self.report_format == ReportFormat.REVEALJS
+            is_report_static = self.report_type in {r.ReportType.PDF, r.ReportType.DOCX, r.ReportType.ODT, r.ReportType.PPTX}
+            is_report_revealjs = self.report_type == r.ReportType.REVEALJS
 
             # Define the YAML header for the quarto report
             yaml_header = self._create_yaml_header()
@@ -122,7 +111,7 @@ def run_report(self, output_dir: str = BASE_DIR) -> None:
         """
         try:
             subprocess.run(["quarto", "render", os.path.join(output_dir, f"{self.BASE_DIR}.qmd")], check=True)
-            self.report.logger.info(f"'{self.report.title}' '{self.report_type}' report rendered with the '{self.report_format}' format")
+            self.report.logger.info(f"'{self.report.title}' '{self.report_type}' report rendered")
         except subprocess.CalledProcessError as e:
             self.report.logger.error(f"Error running '{self.report.title}' {self.report_type} report: {str(e)}")
             raise
@@ -147,47 +136,47 @@ def _create_yaml_header(self) -> str:
 
         # Define format-specific YAML configurations
         format_configs = {
-            (r.ReportType.DOCUMENT, ReportFormat.HTML): """
+            r.ReportType.HTML: """
   html:
     toc: true
     toc-location: left
     toc-depth: 3
     page-layout: full
     self-contained: true""",
-            (r.ReportType.DOCUMENT, ReportFormat.PDF): """
+            r.ReportType.PDF: """
   pdf:
     toc: false""",
-            (r.ReportType.DOCUMENT, ReportFormat.DOCX): """
+            r.ReportType.DOCX: """
   docx:
     toc: false""",
-            (r.ReportType.DOCUMENT, ReportFormat.ODT): """
+            r.ReportType.ODT: """
   odt:
     toc: false""",
-            (r.ReportType.PRESENTATION, ReportFormat.REVEALJS): """
+            r.ReportType.REVEALJS: """
   revealjs:
     toc: false
     smaller: true
     controls: true
     navigation-mode: vertical
     controls-layout: bottom-right
     output-file: quarto_report_revealjs.html""",
-            (r.ReportType.PRESENTATION, ReportFormat.PPTX): """
+            r.ReportType.PPTX: """
   pptx:
     toc: false
     output: true""",
-            (r.ReportType.NOTEBOOK, ReportFormat.JUPYTER): """
+r.ReportType.JUPYTER: """
   jupyter:
     kernel: python3"""
         }
 
         # Create a key based on the report type and format
-        key = (self.report_type, self.report_format)
+        key = self.report_type
 
         # Retrieve the configuration if it exists, or raise an error
         if key in format_configs:
             config = format_configs[key]
         else:
-            raise ValueError(f"Unsupported report type or format: {self.report_type}, {self.report_format}")
+            raise ValueError(f"Unsupported report type: {self.report_type}")
 
         # Add the specific configuration to the YAML header
         yaml_header += config

vuegen/quarto_reportview.py

@@ -14,9 +14,13 @@
 
 class ReportType(StrEnum):
     STREAMLIT = auto()
-    DOCUMENT = auto()
-    PRESENTATION = auto()
-    NOTEBOOK = auto()
+    HTML = auto()
+    PDF = auto()
+    DOCX = auto()
+    ODT = auto()
+    REVEALJS = auto()
+    PPTX = auto()
+    JUPYTER = auto()  
 
 class ComponentType(StrEnum):
     PLOT = auto()

vuegen/report.py

@@ -1,26 +1,20 @@
 from streamlit_reportview import StreamlitReportView
-from quarto_reportview import QuartoReportView, ReportFormat
+from quarto_reportview import QuartoReportView
 from metadata_manager import MetadataManager
 from report import ReportType
 from utils import assert_enum_value
-from enum import StrEnum, auto
 import logging
 
-class ReportEngine(StrEnum):
-    STREAMLIT = auto()
-    QUARTO = auto()
-
-def get_report(config: dict, report_engine: str, logger: logging.Logger) -> None:
+def get_report(config: dict, report_type: str, logger: logging.Logger) -> None:
     """
     Generate and run a report based on the specified engine.
 
     Parameters
     ----------
     config : dict
         The report metadata obtained from a YAML config file.
-    report_engine : str
-        The engine to use for generating and displaying the report. 
-        It should be one of the values of the ReportEngine Enum.
+    report_type : str
+        The report type. It should be one of the values of the ReportType Enum.
     logger : logging.Logger
         A logger object to track warnings, errors, and info messages.
 
@@ -29,31 +23,26 @@ def get_report(config: dict, report_engine: str, logger: logging.Logger) -> None
     ValueError
         If an unsupported report engine, report type, or report format are provided.
     """
-    # Validate and convert the report engine to its enum value
-    validated_engine = assert_enum_value(ReportEngine, report_engine, logger)
-
     # Load report object and metadata from the YAML file
     yaml_manager = MetadataManager(logger)
     report, report_metadata = yaml_manager.initialize_report(config)
 
-    # Collect report type from YAML file
-    report_type = assert_enum_value(ReportType, report_metadata['report']['report_type'], logger)
+    # Validate and convert the report type to its enum value
+    report_type = assert_enum_value(ReportType, report_type, logger)
 
-    # Create and run ReportView object based on its engine
-    if validated_engine == ReportEngine.STREAMLIT:
+    # Create and run ReportView object based on its type
+    if report_type == ReportType.STREAMLIT:
         st_report = StreamlitReportView(
             report=report,
             report_type=report_type
         )
         st_report.generate_report()
         st_report.run_report()
 
-    elif validated_engine == ReportEngine.QUARTO:
-        report_format = assert_enum_value(ReportFormat, report_metadata['report']['report_format'], logger)
+    else:
         quarto_report = QuartoReportView(
             report=report,
-            report_type=report_type,
-            report_format=report_format
+            report_type=report_type
         )
         quarto_report.generate_report()
         quarto_report.run_report()

vuegen/report_generator.py

@@ -300,7 +300,6 @@ def _generate_plot_content(self, plot, static_dir: str = STATIC_FILES_DIR) -> Li
             The folder where the static files will be saved (default is STATIC_FILES_DIR).
         """
         plot_content = []
-
         # Add title
         plot_content.append(self._format_text(text=plot.title, type='header', level=4, color='#2b8cbe'))
 
@@ -313,7 +312,6 @@ def _generate_plot_content(self, plot, static_dir: str = STATIC_FILES_DIR) -> Li
             elif plot.plot_type == r.PlotType.ALTAIR:
                 plot_content.append(self._generate_plot_code(plot))
             elif plot.plot_type == r.PlotType.INTERACTIVE_NETWORK:
-                # Handle the network visualization
                 G = plot.read_network()
                 html_plot_file = os.path.join(static_dir, f"{plot.title.replace(' ', '_')}.html")
                 net = plot.create_and_save_pyvis_network(G, html_plot_file)

vuegen/streamlit_reportview.py

@@ -3,6 +3,7 @@
 import yaml
 from datetime import datetime
 import logging
+import argparse
 from enum import StrEnum
 from typing import Type
 
@@ -16,12 +17,12 @@ def check_path(filepath: str) -> bool:
     filepath : str
         The file or folder path to check.
 
-    RETURNS
+    Returns
     -------
     bool
         True if the path exists, False otherwise.
 
-    RAISES
+    Raises
     ------
     AssertionError
         If the filepath is not a valid string.
@@ -100,6 +101,55 @@ def create_folder(directory_path: str, is_nested: bool = False) -> bool:
     except OSError as e:
         raise OSError(f"Error creating directory '{directory_path}': {e}")
 
+def get_args(prog_name: str, others: dict = {}) -> argparse.Namespace:
+    """
+    Initiates argparse.ArgumentParser() and adds common arguments.
+
+    Parameters
+    ----------
+    prog_name : str
+        The name of the program.
+
+    others : dict, optional
+        Additional keyword arguments for ArgumentParser initialization.
+
+    Returns
+    -------
+    argparse.Namespace
+        Parsed command-line arguments.
+
+    Raises
+    ------
+    AssertionError
+        If prog_name is not a string or others is not a dictionary.
+    """
+    # Preconditions
+    assert isinstance(prog_name, str), f"prog_name should be a string: {prog_name}"
+    assert isinstance(others, dict), f"others must be a dict: {others}"
+
+    # Initialize argument parser
+    parser = argparse.ArgumentParser(prog=prog_name, **others)
+
+    # Add arguments
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=str,
+        default="report_config_micw2graph.yaml",
+        help="Path to the YAML configuration file."
+    )
+    parser.add_argument(
+        "-rt",
+        "--report_type",
+        type=str,
+        default=None,
+        help="Type of the report to generate (streamlit, html, pdf, docx, odt, revealjs, pptx, or jupyter)."
+    )
+
+    # Parse arguments
+    return parser.parse_args()
+
+
 ## CONFIG
 def load_yaml_config(file_path: str) -> dict:
     """