Add report_generator module to simplify main. Also, the function to load yaml config file was moved to utils.py to get this info in the main file and create a proper suffix for logging. The main, notebook, and metadata_manager files were updated with these changes. Also, the first version of the logo was included.

Author: sayalaruano

.gitignore

@@ -171,4 +171,5 @@ quarto_report/
 # Extra info
 UML_diagrams/
 Graphical_abstract/
+docs/presentations/
 test.py

docs/images/vuegen_logo.png

@@ -1,29 +1,24 @@
-from streamlit_reportview import StreamlitReportView
-from quarto_reportview import QuartoReportView, ReportFormat
-from metadata_manager import MetadataManager
-from report import ReportType
-from utils import assert_enum_value
+import report_generator
+from utils import get_logger, load_yaml_config
 
 if __name__ == '__main__':
-    # Load report object and  metadata from YAML file
-    yaml_manager = MetadataManager()
-    report, report_metadata = yaml_manager.load_report_metadata('./report_metadata_micw2graph.yaml')
+    # Load the YAML configuration file with the report metadata
+    config_path = "report_metadata_micw2graph.yaml"
+    report_metadata = load_yaml_config(config_path)
 
-    # Create report view
-    doc_report = QuartoReportView(report_metadata['report']['id'], 
-                                                report_metadata['report']['name'], 
-                                                report=report, 
-                                                report_type = assert_enum_value(ReportType, report_metadata['report']['report_type'], report.logger),
-                                                report_format = assert_enum_value(ReportFormat, report_metadata['report']['report_format'], report.logger),
-                                                columns=None)
-    doc_report.generate_report()
-    doc_report.run_report()
+    # Define logger suffix based on report engine, type and name
+    report_engine = "streamlit" 
+    report_type = report_metadata['report'].get('report_type')
+    report_format = report_metadata['report'].get('report_format')
+    report_name = report_metadata['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}"
 
-    # st_report = StreamlitReportView(report_metadata['report']['id'], 
-    #                                              report_metadata['report']['name'], 
-    #                                              report=report, 
-    #                                              report_type = assert_enum_value(ReportType, report_metadata['report']['report_type'], report.logger),
-    #                                              columns=None)
-    # st_report.generate_report()
-    # st_report.run_report()
+    # Initialize logger
+    logger = get_logger(f"{logger_suffix}")
+
+    # Generate the report
+    report_generator.get_report(metadata=report_metadata, report_engine=report_engine, logger=logger)
 

docs/images/vuegen_logo.svg

@@ -1,22 +1,29 @@
-import os
-import yaml
 import report as r
-import logging
 from utils import get_logger, assert_enum_value
 
 class MetadataManager:
     """
     Class for handling metadata of reports from YAML files and creating report objects.
     """
+    def __init__(self, logger=None):
+        """
+        Initializes the MetadataManager with a logger.
 
-    def load_report_metadata(self, file_path: str) -> tuple[r.Report, dict]:
+        Parameters
+        ----------
+        logger : logging.Logger, optional
+            A logger instance for the class. If not provided, a default logger will be created.
         """
-        Loads metadata from a YAML file, parses it, and returns a Report object and the raw metadata.
+        self.logger = logger or get_logger("report")
+
+    def initialize_report(self, metadata: dict) -> tuple[r.Report, dict]:
+        """
+        Extracts report metadata from a YAML file and returns a Report object and the raw metadata.
 
         Parameters
         ----------
-        file_path : str
-            The path to the YAML file containing the report metadata.
+        metadata : dict
+            The report metadata obtained from a YAML file.
 
         Returns
         -------
@@ -30,20 +37,6 @@ def load_report_metadata(self, file_path: str) -> tuple[r.Report, dict]:
         ValueError
             If the YAML file is corrupted or contains missing/invalid values.
         """
-        # Check the existence of the file_path
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"The config file at {file_path} was not found.")
-
-        # Load the YAML configuration file
-        with open(file_path, 'r') as file:
-            try:
-                metadata = yaml.safe_load(file)
-            except yaml.YAMLError as exc:
-                raise ValueError(f"Error parsing YAML file: {exc}")
-        
-        # Define suffix f"or logger object based on report type and report name
-        logger_suffix = f"{metadata['report'].get('report_type')}_report_{metadata['report'].get('name')}"
-
         # Create a Report object from metadata
         report = r.Report(
             id=metadata['report']['id'],
@@ -53,27 +46,25 @@ def load_report_metadata(self, file_path: str) -> tuple[r.Report, dict]:
             description=metadata['report'].get('description'),
             graphical_abstract=metadata['report'].get('graphical_abstract'),
             logo=metadata['report'].get('logo'),
-            logger = get_logger(logger_suffix)
+            logger = self.logger
         )
 
         # Create sections and subsections
         for section_data in metadata.get('sections', []):
-            section = self._create_section(section_data, report.logger)
+            section = self._create_section(section_data)
             report.sections.append(section)
 
-        report.logger.info(f"Report '{report.name}' initialized with {len(report.sections)} sections.")
+        self.logger.info(f"Report '{report.name}' initialized with {len(report.sections)} sections.")
         return report, metadata
 
-    def _create_section(self, section_data: dict, logger: logging.Logger) -> r.Section:
+    def _create_section(self, section_data: dict) -> r.Section:
         """
         Creates a Section object from a dictionary of section data.
 
         Parameters
         ----------
         section_data : dict
             A dictionary containing section metadata.
-        logger : logging.Logger
-            A logger object to track warnings, errors, and info messages.
 
         Returns
         -------
@@ -91,21 +82,19 @@ def _create_section(self, section_data: dict, logger: logging.Logger) -> r.Secti
 
         # Create subsections
         for subsection_data in section_data.get('subsections', []):
-            subsection = self._create_subsection(subsection_data, logger)
+            subsection = self._create_subsection(subsection_data)
             section.subsections.append(subsection)
 
         return section
 
-    def _create_subsection(self, subsection_data: dict, logger: logging.Logger) -> r.Subsection:
+    def _create_subsection(self, subsection_data: dict) -> r.Subsection:
         """
         Creates a Subsection object from a dictionary of subsection data.
 
         Parameters
         ----------
         subsection_data : dict
             A dictionary containing subsection metadata.
-        logger : logging.Logger
-            A logger object to track warnings, errors, and info messages.
 
         Returns
         -------
@@ -123,59 +112,55 @@ def _create_subsection(self, subsection_data: dict, logger: logging.Logger) -> r
 
         # Create components
         for component_data in subsection_data.get('components', []):
-            component = self._create_component(component_data, logger)
+            component = self._create_component(component_data)
             subsection.components.append(component)
 
         return subsection
 
-    def _create_component(self, component_data: dict, logger: logging.Logger) -> r.Component:
+    def _create_component(self, component_data: dict) -> r.Component:
         """
         Creates a Component object from a dictionary of component data.
 
         Parameters
         ----------
         component_data : dict
             A dictionary containing component metadata.
-        logger : logging.Logger
-            A logger object to track warnings, errors, and info messages.
 
         Returns
         -------
         Component
             A Component object (Plot, DataFrame, or Markdown) populated with the provided metadata.
         """
         # Determine the component type
-        component_type = assert_enum_value(r.ComponentType, component_data['component_type'], logger)
+        component_type = assert_enum_value(r.ComponentType, component_data['component_type'], self.logger)
 
         # Dispatch to the corresponding creation method
         if component_type == r.ComponentType.PLOT:
-            return self._create_plot_component(component_data, logger)
+            return self._create_plot_component(component_data)
         elif component_type == r.ComponentType.DATAFRAME:
-            return self._create_dataframe_component(component_data, logger)
+            return self._create_dataframe_component(component_data)
         elif component_type == r.ComponentType.MARKDOWN:
-            return self._create_markdown_component(component_data, logger)
+            return self._create_markdown_component(component_data)
 
-    def _create_plot_component(self, component_data: dict, logger: logging.Logger) -> r.Plot:
+    def _create_plot_component(self, component_data: dict) -> r.Plot:
         """
         Creates a Plot component.
 
         Parameters
         ----------
         component_data : dict
             A dictionary containing plot component metadata.
-        logger : logging.Logger
-            A logger object to track warnings, errors, and info messages.
 
         Returns
         -------
         Plot
             A Plot object populated with the provided metadata.
         """
         # Validate enum fields
-        plot_type = assert_enum_value(r.PlotType, component_data['plot_type'], logger)
-        int_visualization_tool = (assert_enum_value(r.IntVisualizationTool, component_data.get('int_visualization_tool', ''), logger) 
+        plot_type = assert_enum_value(r.PlotType, component_data['plot_type'], self.logger)
+        int_visualization_tool = (assert_enum_value(r.IntVisualizationTool, component_data.get('int_visualization_tool', ''), self.logger) 
                                   if component_data.get('int_visualization_tool') else None)
-        csv_network_format = (assert_enum_value(r.CSVNetworkFormat, component_data.get('csv_network_format', ''), logger) 
+        csv_network_format = (assert_enum_value(r.CSVNetworkFormat, component_data.get('csv_network_format', ''), self.logger) 
                               if component_data.get('csv_network_format') else None)
 
         # Return the constructed Plot object
@@ -188,27 +173,25 @@ def _create_plot_component(self, component_data: dict, logger: logging.Logger) -
             title=component_data.get('title'),
             caption=component_data.get('caption'),
             csv_network_format=csv_network_format,
-            logger = logger
+            logger = self.logger
         )
 
-    def _create_dataframe_component(self, component_data: dict, logger: logging.Logger) -> r.DataFrame:
+    def _create_dataframe_component(self, component_data: dict) -> r.DataFrame:
         """
         Creates a DataFrame component.
 
         Parameters
         ----------
         component_data : dict
             A dictionary containing dataframe component metadata.
-        logger : logging.Logger
-            A logger object to track warnings, errors, and info messages.
 
         Returns
         -------
         DataFrame
             A DataFrame object populated with the provided metadata.
         """        
         # Validate enum field and return dataframe
-        file_format = assert_enum_value(r.DataFrameFormat, component_data['file_format'], logger)
+        file_format = assert_enum_value(r.DataFrameFormat, component_data['file_format'], self.logger)
         return r.DataFrame(
             id=component_data['id'],
             name=component_data['name'],
@@ -217,19 +200,17 @@ def _create_dataframe_component(self, component_data: dict, logger: logging.Logg
             delimiter=component_data.get('delimiter'),
             title=component_data.get('title'),
             caption=component_data.get('caption'),
-            logger = logger
+            logger = self.logger
         )
 
-    def _create_markdown_component(self, component_data: dict, logger: logging.Logger) -> r.Markdown:
+    def _create_markdown_component(self, component_data: dict) -> r.Markdown:
         """
         Creates a Markdown component.
 
         Parameters
         ----------
         component_data : dict
             A dictionary containing markdown component metadata.
-        logger : logging.Logger
-            A logger object to track warnings, errors, and info messages.
 
         Returns
         -------
@@ -242,5 +223,5 @@ def _create_markdown_component(self, component_data: dict, logger: logging.Logge
             file_path=component_data['file_path'],
             title=component_data.get('title'),
             caption=component_data.get('caption'),
-            logger = logger
+            logger = self.logger
         )

docs/vuegen_demo.ipynb

@@ -122,7 +122,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.name}' {self.report_type} report rendered with the {self.report_format} format")
+            self.report.logger.info(f"'{self.name}' '{self.report_type}' report rendered with the '{self.report_format}' format")
         except subprocess.CalledProcessError as e:
             self.report.logger.error(f"Error running '{self.name}' {self.report_type} report: {str(e)}")
             raise

vuegen/main.py

@@ -0,0 +1,69 @@
+# Vuegen imports
+from streamlit_reportview import StreamlitReportView
+from quarto_reportview import QuartoReportView, ReportFormat
+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(metadata: dict, report_engine: str, logger: logging.Logger) -> None:
+    """
+    Generate and run a report based on the specified engine.
+
+    Parameters
+    ----------
+    metadata : dict
+        The report metadata obtained from a YAML 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.
+    logger : logging.Logger
+        A logger object to track warnings, errors, and info messages.
+
+    Raises
+    ------
+    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(metadata)
+
+    # Collect report parameters from YAML file
+    report_id = report_metadata['report']['id']
+    report_name = report_metadata['report']['name']
+    report_type = assert_enum_value(ReportType, report_metadata['report']['report_type'], logger)
+
+    # Create and run ReportView object based on its engine
+    if validated_engine == ReportEngine.STREAMLIT:
+        st_report = StreamlitReportView(
+            report_id,
+            report_name,
+            report=report,
+            report_type=report_type,
+            columns=None
+        )
+        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)
+        doc_report = QuartoReportView(
+            report_id,
+            report_name,
+            report=report,
+            report_type=report_type,
+            report_format=report_format,
+            columns=None
+        )
+        doc_report.generate_report()
+        doc_report.run_report()