Add error handling code and logging into the StreamlitReportView class

Author: sayalaruano

report/quarto_reportview.py

@@ -35,59 +35,69 @@ def generate_report(self, output_dir: str = BASE_DIR) -> None:
         output_dir : str, optional
             The folder where the generated report files will be saved (default is BASE_DIR).
         """
+        self.report.logger.debug(f"Generating '{self.report_type}' report with '{self.report_format}' format in directory: '{output_dir}'")
+
         # Create the output folder if it does not exist
         if not os.path.exists(output_dir):
             os.mkdir(output_dir)
-
-        # 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
-        
-        # Define the YAML header for the quarto report
-        yaml_header = self._create_yaml_header()
-        
-        # Create qmd content and imports for the report 
-        qmd_content = []
-        report_imports = []
-
-        # Add the title and description of the report
-        qmd_content.append(f'''{self.report.description}\n''')
-
-        # If available add the graphical abstract
-        if self.report.graphical_abstract:
-            qmd_content.append(self._generate_image_content(self.report.graphical_abstract, f"Graphical abstract for the {self.report.title} report"))
-        # Add the sections and subsections to the report
-        for section in self.report.sections:
-            # Add section header and description
-            qmd_content.append(f'# {section.title}')
-            qmd_content.append(f'''{section.description}''')
+            self.report.logger.debug(f"Created output directory: {output_dir}")
+        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
 
-            if section.subsections:
-                # Iterate through subsections and integrate them into the section file
-                for subsection in section.subsections:                    
-                    # Generate content for the subsection
-                    subsection_content, subsection_imports = self._generate_subsection(subsection, is_report_static, is_report_revealjs)
-                    qmd_content.extend(subsection_content)
-                    report_imports.extend(subsection_imports) 
-        
-        # Flatten the subsection_imports into a single list
-        flattened_report_imports = [imp for sublist in report_imports for imp in sublist]
-        
-        # Remove duplicated imports
-        report_unique_imports = list(set(flattened_report_imports))
+            # Define the YAML header for the quarto report
+            yaml_header = self._create_yaml_header()
+            
+            # Create qmd content and imports for the report 
+            qmd_content = []
+            report_imports = []
+
+            # Add the title and description of the report
+            qmd_content.append(f'''{self.report.description}\n''')
+
+            # If available add the graphical abstract
+            if self.report.graphical_abstract:
+                qmd_content.append(self._generate_image_content(self.report.graphical_abstract, f"Graphical abstract for the {self.report.title} report"))
+            # Add the sections and subsections to the report
+            self.report.logger.info("Starting to generate sections for the report.")
+            for section in self.report.sections:
+                self.report.logger.debug(f"Processing section: '{section.name}' - {len(section.subsections)} subsection(s)")
+                # Add section header and description
+                qmd_content.append(f'# {section.title}')
+                qmd_content.append(f'''{section.description}''')
+                
+                if section.subsections:
+                    # Iterate through subsections and integrate them into the section file
+                    for subsection in section.subsections:
+                        self.report.logger.debug(f"Processing subsection: '{subsection.name}' - {len(subsection.components)} component(s)")                    
+                        # Generate content for the subsection
+                        subsection_content, subsection_imports = self._generate_subsection(subsection, is_report_static, is_report_revealjs)
+                        qmd_content.extend(subsection_content)
+                        report_imports.extend(subsection_imports) 
+            
+            # Flatten the subsection_imports into a single list
+            flattened_report_imports = [imp for sublist in report_imports for imp in sublist]
+            
+            # Remove duplicated imports
+            report_unique_imports = list(set(flattened_report_imports))
 
-        # Format imports
-        report_formatted_imports = "\n".join(report_unique_imports)
-        
-        # Write the navigation and general content to a Python file
-        with open(os.path.join(output_dir, "quarto_report.qmd"), 'w') as quarto_report:
-            quarto_report.write(yaml_header)
-            quarto_report.write(f"""\n```{{python}}
+            # Format imports
+            report_formatted_imports = "\n".join(report_unique_imports)
+            
+            # Write the navigation and general content to a Python file
+            with open(os.path.join(output_dir, f"{self.BASE_DIR}.qmd"), 'w') as quarto_report:
+                quarto_report.write(yaml_header)
+                quarto_report.write(f"""\n```{{python}}
 #| label: 'Imports'
 #| echo: false
 {report_formatted_imports}
 ```\n\n""")
-            quarto_report.write("\n".join(qmd_content))
+                quarto_report.write("\n".join(qmd_content))
+                self.report.logger.info(f"Created qmd script to render the app: {self.BASE_DIR}.qmd")
+        except Exception as e:
+            self.report.logger.error(f"An error occurred while generating the report: {str(e)}")
+            raise
 
     def run_report(self, output_dir: str = BASE_DIR) -> None:
         """
@@ -98,7 +108,12 @@ def run_report(self, output_dir: str = BASE_DIR) -> None:
         output_dir : str, optional
             The folder where the report was generated (default is 'sections').
         """
-        subprocess.run(["quarto", "render", os.path.join(output_dir, "quarto_report.qmd")], check=True)
+        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")
+        except subprocess.CalledProcessError as e:
+            self.report.logger.error(f"Error running '{self.name}' {self.report_type} report: {str(e)}")
+            raise
 
     def _create_yaml_header(self) -> str:
         """
@@ -206,10 +221,13 @@ def _generate_subsection(self, subsection, is_report_static, is_report_revealjs)
 
             elif component.component_type == r.ComponentType.MARKDOWN:
                 subsection_content.extend(self._generate_markdown_content(component))
+            else:
+                self.report.logger.warning(f"Unsupported component type '{component.component_type}' in subsection: {subsection.name}")
 
         if is_report_revealjs:
             subsection_content.append(':::\n')
-        
+
+        self.report.logger.info(f"Generated content and imports for subsection: '{subsection.name}'")
         return subsection_content, subsection_imports
 
     def _generate_plot_content(self, plot, is_report_static, output_dir: str = STATIC_FILES_DIR) -> List[str]:
@@ -237,42 +255,54 @@ def _generate_plot_content(self, plot, is_report_static, output_dir: str = STATI
         plot_content = []
         plot_content.append(f'### {plot.title}')
         if plot.plot_type == r.PlotType.INTERACTIVE:
-            # Define plot path
-            if is_report_static:
-                static_plot_path  = os.path.join(output_dir, f"{plot.name.replace(' ', '_')}.png")
-            else:
-                html_plot_file  = os.path.join(output_dir, f"{plot.name.replace(' ', '_')}.html")
-
-            if plot.int_visualization_tool == r.IntVisualizationTool.PLOTLY:
-                plot_content.append(self._generate_plot_code(plot))
-                if is_report_static:
-                    plot_content.append(f"""fig_plotly.write_image("{os.path.join("..", static_plot_path)}")\n```\n""")
-                    plot_content.append(self._generate_image_content(static_plot_path, plot.name))
-                else:
-                    plot_content.append(f"""fig_plotly.show()\n```\n""")
-            elif plot.int_visualization_tool == r.IntVisualizationTool.ALTAIR:
-                plot_content.append(self._generate_plot_code(plot))
+            try:
+                # Define plot path
                 if is_report_static:
-                    plot_content.append(f"""fig_altair.save("{os.path.join("..", static_plot_path)}")\n```\n""")
-                    plot_content.append(self._generate_image_content(static_plot_path, plot.name))
+                    static_plot_path  = os.path.join(output_dir, f"{plot.name.replace(' ', '_')}.png")
                 else:
-                    plot_content.append(f"""fig_altair\n```\n""")
-            elif plot.int_visualization_tool == r.IntVisualizationTool.PYVIS:
-                G = plot.read_network()
-                num_nodes = G.number_of_nodes()
-                num_edges = G.number_of_edges()
-                plot_content.append(f'**Number of nodes:** {num_nodes}\n')
-                plot_content.append(f'**Number of edges:** {num_edges}\n')
-                if is_report_static:
-                    plot.save_netwrok_image(G, static_plot_path, "png")
-                    plot_content.append(self._generate_image_content(static_plot_path, plot.name))
+                    html_plot_file  = os.path.join(output_dir, f"{plot.name.replace(' ', '_')}.html")
+
+                if plot.int_visualization_tool == r.IntVisualizationTool.PLOTLY:
+                    plot_content.append(self._generate_plot_code(plot))
+                    if is_report_static:
+                        plot_content.append(f"""fig_plotly.write_image("{os.path.join("..", static_plot_path)}")\n```\n""")
+                        plot_content.append(self._generate_image_content(static_plot_path, plot.name))
+                    else:
+                        plot_content.append(f"""fig_plotly.show()\n```\n""")
+                elif plot.int_visualization_tool == r.IntVisualizationTool.ALTAIR:
+                    plot_content.append(self._generate_plot_code(plot))
+                    if is_report_static:
+                        plot_content.append(f"""fig_altair.save("{os.path.join("..", static_plot_path)}")\n```\n""")
+                        plot_content.append(self._generate_image_content(static_plot_path, plot.name))
+                    else:
+                        plot_content.append(f"""fig_altair\n```\n""")
+                elif plot.int_visualization_tool == r.IntVisualizationTool.PYVIS:
+                    G = plot.read_network()
+                    num_nodes = G.number_of_nodes()
+                    num_edges = G.number_of_edges()
+                    plot_content.append(f'**Number of nodes:** {num_nodes}\n')
+                    plot_content.append(f'**Number of edges:** {num_edges}\n')
+                    if is_report_static:
+                        plot.save_netwrok_image(G, static_plot_path, "png")
+                        plot_content.append(self._generate_image_content(static_plot_path, plot.name))
+                    else:
+                        # Get the Network object
+                        net = plot.create_and_save_pyvis_network(G, html_plot_file)
+                        plot_content.append(self._generate_plot_code(plot, html_plot_file))
                 else:
-                    # Get the Network object
-                    net = plot.create_and_save_pyvis_network(G, html_plot_file)
-                    plot_content.append(self._generate_plot_code(plot, html_plot_file))
+                        self.report.logger.warning(f"Unsupported interactive plot tool: {plot.int_visualization_tool}")
+            except Exception as e:
+                self.report.logger.error(f"Error generating interactive plot content for {plot.name}: {str(e)}")
+                raise
+        
         elif plot.plot_type == r.PlotType.STATIC:
-            plot_content.append(self._generate_image_content(plot.file_path, width=950))
+            try:
+                plot_content.append(self._generate_image_content(plot.file_path, width=950))
+            except Exception as e:
+                self.report.logger.error(f"Error generating static plot content for {plot.name}: {str(e)}")
+                raise
 
+        self.report.logger.info(f"Successfully generated content for plot: '{plot.name}'")
         return plot_content
 
     def _generate_plot_code(self, plot, output_file = "") -> str:
@@ -333,25 +363,32 @@ def _generate_dataframe_content(self, dataframe, is_report_static) -> List[str]:
 #| label: {dataframe.name}
 #| echo: false
 """)
-        if dataframe.file_format == r.DataFrameFormat.CSV:
-            if dataframe.delimiter:
-                datframe_content.append(f"""df = pd.read_csv('{os.path.join("..", dataframe.file_path)}', delimiter='{dataframe.delimiter}')""")
+        try:
+            if dataframe.file_format == r.DataFrameFormat.CSV:
+                if dataframe.delimiter:
+                    datframe_content.append(f"""df = pd.read_csv('{os.path.join("..", dataframe.file_path)}', delimiter='{dataframe.delimiter}')""")
+                    datframe_content.extend(self._show_dataframe(dataframe, is_report_static))
+                else:
+                    datframe_content.append(f"""df = pd.read_csv('{os.path.join("..", dataframe.file_path)}')""")
+                    datframe_content.extend(self._show_dataframe(dataframe, is_report_static))
+            elif dataframe.file_format == r.DataFrameFormat.PARQUET:
+                datframe_content.append(f"""df = pd.read_parquet('{os.path.join("..", dataframe.file_path)}')""")
                 datframe_content.extend(self._show_dataframe(dataframe, is_report_static))
-            else:
-                datframe_content.append(f"""df = pd.read_csv('{os.path.join("..", dataframe.file_path)}')""")
+            elif dataframe.file_format == r.DataFrameFormat.TXT:
+                datframe_content.append(f"""df = pd.read_csv('{os.path.join("..", dataframe.file_path)}', sep='\\t')""")
                 datframe_content.extend(self._show_dataframe(dataframe, is_report_static))
-        elif dataframe.file_format == r.DataFrameFormat.PARQUET:
-            datframe_content.append(f"""df = pd.read_parquet('{os.path.join("..", dataframe.file_path)}')""")
-            datframe_content.extend(self._show_dataframe(dataframe, is_report_static))
-        elif dataframe.file_format == r.DataFrameFormat.TXT:
-            datframe_content.append(f"""df = pd.read_csv('{os.path.join("..", dataframe.file_path)}', sep='\\t')""")
-            datframe_content.extend(self._show_dataframe(dataframe, is_report_static))
-        elif dataframe.file_format == r.DataFrameFormat.EXCEL:
-            datframe_content.append(f"""df = pd.read_excel('{os.path.join("..", dataframe.file_path)}')""")
-            datframe_content.extend(self._show_dataframe(dataframe, is_report_static))
-        else:
-            raise ValueError(f"Unsupported DataFrame file format: {dataframe.file_format}")
-
+            elif dataframe.file_format == r.DataFrameFormat.EXCEL:
+                datframe_content.append(f"""df = pd.read_excel('{os.path.join("..", dataframe.file_path)}')""")
+                datframe_content.extend(self._show_dataframe(dataframe, is_report_static))
+            else:
+                self.report.logger.error(f"Unsupported DataFrame file format: {dataframe.file_format}")
+                raise ValueError(f"Unsupported DataFrame file format: {dataframe.file_format}")
+        
+        except Exception as e:
+            self.report.logger.error(f"Error generating content for DataFrame: {dataframe.title}. Error: {str(e)}")
+            raise
+        
+        self.report.logger.info(f"Successfully generated content for DataFrame: '{dataframe.title}'")
         return datframe_content
 
     def _generate_markdown_content(self, markdown) -> List[str]:
@@ -368,9 +405,10 @@ def _generate_markdown_content(self, markdown) -> List[str]:
         list : List[str]
             The list of content lines for the markdown.
         """
-        markdown_content = []
-        markdown_content.append(f'### {markdown.title}')
-        markdown_content.append(f"""```{{python}}
+        try:
+            markdown_content = []
+            markdown_content.append(f'### {markdown.title}')
+            markdown_content.append(f"""```{{python}}
 #| label: {markdown.name}
 #| table-cap: "MD file"
 #| table-type: "md"
@@ -379,6 +417,11 @@ def _generate_markdown_content(self, markdown) -> List[str]:
     markdown_content = markdown_file.read()
 display.Markdown(markdown_content)
 ```\n""")
+        except Exception as e:
+            self.report.logger.error(f"Error generating content for Markdown: {markdown.title}. Error: {str(e)}")
+            raise
+        
+        self.report.logger.info(f"Successfully generated content for Markdown: '{markdown.title}'")
         return markdown_content
 
     def _generate_image_content(self, image_path: str, alt_text: str = "", width: int = 650, height: int = 400) -> str: