🐛 allow to specify output folder - use only relative paths (#136)

* 🐛 allow to specify output folder - use only relative paths

- before other locations were not working, see #135
- everything is relative to  the generated qmd report now
   - quarto without any additional parameters uses path relative to qmd file
   - in qmd report python snippets can use `report_dir` (cwd and quarto report file locaction)

Commit qmd file for html output to get an idea of structure and prepare integration tests

* 🐛 ensure path are absolute and fix dfi export (static_dir exports)

relevant for static quarto based reports

* 🐛 writing is w.r.t to output folder, file path is already specifying static dir.

* 📝 some notes and comments

- also correcting one typo in comment

* 🎨 address copilot comments (typo and unclear comments)

* 🚚 move file to subfolder, specify how reports shoudl be build

* 🎨 move output_dir to init of QuartoReportView

Author: enryH

src/vuegen/quarto_reportview.py

@@ -25,6 +25,7 @@ def __init__(
         report: r.Report,
         report_type: r.ReportType,
         quarto_checks: bool = False,
+        output_dir: Optional[Path] = BASE_DIR,
         static_dir: str = STATIC_FILES_DIR,
     ):
         """_summary_
@@ -44,6 +45,7 @@ def __init__(
         super().__init__(report=report, report_type=report_type)
         self.quarto_checks = quarto_checks
         self.static_dir = static_dir
+        self.output_dir = output_dir.resolve().absolute()
         # self.BUNDLED_EXECUTION = False
         self.quarto_path = "quarto"
         # self.env_vars = os.environ.copy()
@@ -72,25 +74,28 @@ def __init__(
             r.ComponentType.HTML: self._generate_html_content,
         }
 
-    def generate_report(self, output_dir: Path = BASE_DIR) -> None:
+    def generate_report(self, output_dir: Optional[Path] = None) -> None:
         """
         Generates the qmd file of the quarto report. It creates code for rendering each section and its subsections with all components.
 
         Parameters
         ----------
         output_dir : Path, optional
-            The folder where the generated report files will be saved (default is BASE_DIR).
+            The folder where the generated report files will be saved.
+            Will overwrite value set on initialization of QuartoReportView.
         """
+        if output_dir is not None:
+            self.output_dir = Path(output_dir).resolve().absolute()
+
         self.report.logger.debug(
-            f"Generating '{self.report_type}' report in directory: '{output_dir}'"
+            f"Generating '{self.report_type}' report in directory: '{self.output_dir}'"
         )
-
         # Create the output folder
-        if create_folder(output_dir):
-            self.report.logger.debug(f"Created output directory: '{output_dir}'")
+        if create_folder(self.output_dir, is_nested=True):
+            self.report.logger.debug(f"Created output directory: '{self.output_dir}'")
         else:
             self.report.logger.debug(
-                f"Output directory already existed: '{output_dir}'"
+                f"Output directory already existed: '{self.output_dir}'"
             )
 
         # Create the static folder
@@ -207,6 +212,9 @@ def generate_report(self, output_dir: Path = BASE_DIR) -> None:
                     self.report.logger.warning(
                         f"No subsections found in section: '{section.title}'. To show content in the report, add subsections to the section."
                     )
+            # Add globally set output folder
+            report_imports.append("from pathlib import Path")
+            report_imports.append("report_dir = Path().cwd()")
 
             # Remove duplicated imports
             report_unique_imports = set(report_imports)
@@ -224,7 +232,8 @@ def generate_report(self, output_dir: Path = BASE_DIR) -> None:
             report_formatted_imports = "\n".join(report_unique_imports)
 
             # Write the navigation and general content to a Python file
-            with open(Path(output_dir) / f"{self.BASE_DIR}.qmd", "w") as quarto_report:
+            fname_qmd_report = self.output_dir / f"{self.BASE_DIR}.qmd"
+            with open(fname_qmd_report, "w") as quarto_report:
                 quarto_report.write(yaml_header)
                 quarto_report.write(
                     f"""\n```{{python}}
@@ -234,7 +243,7 @@ def generate_report(self, output_dir: Path = BASE_DIR) -> None:
                 )
                 quarto_report.write("\n".join(qmd_content))
                 self.report.logger.info(
-                    f"Created qmd script to render the app: {self.BASE_DIR}.qmd"
+                    f"Created qmd script to render the app: {fname_qmd_report}"
                 )
 
         except Exception as e:
@@ -243,7 +252,7 @@ def generate_report(self, output_dir: Path = BASE_DIR) -> None:
             )
             raise
 
-    def run_report(self, output_dir: str = BASE_DIR) -> None:
+    def run_report(self, output_dir: Optional[Path] = None) -> None:
         """
         Runs the generated quarto report.
 
@@ -253,8 +262,10 @@ def run_report(self, output_dir: str = BASE_DIR) -> None:
             The folder where the report was generated (default is 'sections').
         """
         # from quarto_cli import run_quarto # entrypoint of quarto-cli not in module?
+        if output_dir is not None:
+            self.output_dir = Path(output_dir).resolve().absolute()
 
-        file_path_to_qmd = Path(output_dir) / f"{self.BASE_DIR}.qmd"
+        file_path_to_qmd = Path(self.output_dir) / f"{self.BASE_DIR}.qmd"
         args = [self.quarto_path, "render", str(file_path_to_qmd)]
         self.report.logger.info(
             f"Running '{self.report.title}' '{self.report_type}' report with {args!r}"
@@ -554,13 +565,15 @@ def _generate_plot_content(self, plot) -> List[str]:
 
         # Define plot path
         if self.is_report_static:
+            # ? should that be in the output folder
             static_plot_path = (
                 Path(self.static_dir) / f"{plot.title.replace(' ', '_')}.png"
-            )
+            ).absolute()
+            self.report.logger.debug(f"Static plot path: {static_plot_path}")
         else:
             html_plot_file = (
                 Path(self.static_dir) / f"{plot.title.replace(' ', '_')}.html"
-            )
+            ).absolute()
 
         # Add content for the different plot types
         try:
@@ -572,7 +585,7 @@ def _generate_plot_content(self, plot) -> List[str]:
                 plot_content.append(self._generate_plot_code(plot))
                 if self.is_report_static:
                     plot_content.append(
-                        f"""fig_plotly.write_image("{static_plot_path.relative_to("quarto_report").as_posix()}")\n```\n"""
+                        f"""fig_plotly.write_image("{static_plot_path.relative_to(self.output_dir).as_posix()}")\n```\n"""
                     )
                     plot_content.append(self._generate_image_content(static_plot_path))
                 else:
@@ -581,7 +594,7 @@ def _generate_plot_content(self, plot) -> List[str]:
                 plot_content.append(self._generate_plot_code(plot))
                 if self.is_report_static:
                     plot_content.append(
-                        f"""fig_altair.save("{static_plot_path.relative_to("quarto_report").as_posix()}")\n```\n"""
+                        f"""fig_altair.save("{static_plot_path.as_posix()}")\n```\n"""
                     )
                     plot_content.append(self._generate_image_content(static_plot_path))
                 else:
@@ -597,7 +610,7 @@ def _generate_plot_content(self, plot) -> List[str]:
                         networkx_graph, html_plot_file
                     )
 
-                # Add number of nodes and edges to the plor conetnt
+                # Add number of nodes and edges to the plot content
                 num_nodes = networkx_graph.number_of_nodes()
                 num_edges = networkx_graph.number_of_edges()
                 plot_content.append(f"**Number of nodes:** {num_nodes}\n")
@@ -653,9 +666,11 @@ def _generate_plot_code(self, plot, output_file="") -> str:
 response.raise_for_status()
 plot_json = response.text\n"""
         else:  # If it's a local file
-            plot_rel_path = get_relative_file_path(plot.file_path, base_path="..")
+            plot_rel_path = get_relative_file_path(
+                plot.file_path, relative_to=self.output_dir
+            ).as_posix()
             plot_code += f"""
-with open('{plot_rel_path.as_posix()}', 'r') as plot_file:
+with open(report_dir /'{plot_rel_path}', 'r') as plot_file:
     plot_json = json.load(plot_file)\n"""
         # Add specific code for each visualization tool
         if plot.plot_type == r.PlotType.PLOTLY:
@@ -680,7 +695,9 @@ def _generate_plot_code(self, plot, output_file="") -> str:
             if is_url(plot.file_path) and plot.file_path.endswith(".html"):
                 iframe_src = output_file
             else:
-                iframe_src = Path("..") / output_file
+                iframe_src = get_relative_file_path(
+                    output_file, relative_to=self.output_dir
+                )
 
             # Embed the HTML file in an iframe
             plot_code = f"""
@@ -757,12 +774,12 @@ def _generate_dataframe_content(self, dataframe) -> List[str]:
                 df_file_path = dataframe.file_path
             else:
                 df_file_path = get_relative_file_path(
-                    dataframe.file_path, base_path=".."
-                )
+                    dataframe.file_path, relative_to=self.output_dir
+                ).as_posix()
             # Load the DataFrame using the correct function
             read_function = read_function_mapping[file_extension]
             dataframe_content.append(
-                f"""df = pd.{read_function.__name__}('{df_file_path.as_posix()}')\n"""
+                f"""df = pd.{read_function.__name__}(report_dir / '{df_file_path}')\n"""
             )
             # Display the dataframe
             dataframe_content.extend(self._show_dataframe(dataframe))
@@ -781,7 +798,7 @@ def _generate_dataframe_content(self, dataframe) -> List[str]:
                         )
                     )
                     dataframe_content.append(
-                        f"df = pd.{read_function.__name__}('{df_file_path.as_posix()}', "
+                        f"df = pd.{read_function.__name__}(report_dir / '{df_file_path}', "
                         f"sheet_name='{sheet_name}')\n"
                     )
                     # Display the dataframe
@@ -845,10 +862,12 @@ def _generate_markdown_content(self, markdown) -> List[str]:
                     )
                 )
             else:  # If it's a local file
-                md_rel_path = get_relative_file_path(markdown.file_path, base_path="..")
+                md_rel_path = get_relative_file_path(
+                    markdown.file_path, relative_to=self.output_dir
+                )
                 markdown_content.append(
                     f"""
-with open('{md_rel_path.as_posix()}', 'r') as markdown_file:
+with open(report_dir / '{md_rel_path.as_posix()}', 'r') as markdown_file:
     markdown_content = markdown_file.read()\n"""
                 )
 
@@ -896,9 +915,11 @@ def _show_dataframe(self, dataframe, suffix: Optional[str] = None) -> List[str]:
                     fpath_df_image.stem + f"_{suffix.replace(' ', '_')}"
                 )
             fpath_df_image = fpath_df_image.with_suffix(".png")
-
+            fpath_df_image_rel_static = get_relative_file_path(
+                fpath_df_image, relative_to=self.output_dir
+            )
             dataframe_content.append(
-                f"df.dfi.export('{Path(fpath_df_image).relative_to('quarto_report').as_posix()}',"
+                f"df.dfi.export('{fpath_df_image_rel_static}',"
                 " max_rows=10, max_cols=5, table_conversion='matplotlib')\n```\n"
             )
             # Use helper method to add centered image content
@@ -935,7 +956,9 @@ def _generate_html_content(self, html) -> List[str]:
             if is_url(html.file_path):
                 html_file_path = html.file_path
             else:
-                html_file_path = get_relative_file_path(html.file_path, base_path="..")
+                html_file_path = get_relative_file_path(
+                    html.file_path, relative_to=self.output_dir
+                )
             iframe_code = f"""
 <div style="text-align: center;">
 <iframe src="{html_file_path.as_posix()}" alt="{html.title}" width="950px" height="530px"></iframe>
@@ -978,7 +1001,9 @@ def _generate_image_content(
         if is_url(image_path):
             src = image_path
         else:
-            src = get_relative_file_path(image_path, base_path="..").as_posix()
+            src = get_relative_file_path(
+                image_path, relative_to=self.output_dir
+            ).as_posix()
 
         return f"""![]({src}){{fig-alt={alt_text} width={width}}}\n"""
 

src/vuegen/report_generator.py

@@ -124,9 +124,10 @@ def get_report(
             report=report,
             report_type=report_type,
             quarto_checks=quarto_checks,
+            output_dir=report_dir,
             static_dir=static_files_dir,
         )
-        quarto_report.generate_report(output_dir=report_dir)
-        quarto_report.run_report(output_dir=report_dir)
+        quarto_report.generate_report()
+        quarto_report.run_report()
     # ? Could be also the path to the report file for quarto based reports
     return report_dir, config_path

src/vuegen/utils/__init__.py

@@ -174,7 +174,9 @@ def create_folder(directory_path: str, is_nested: bool = False) -> bool:
         raise OSError(f"Error creating directory '{directory_path}': {e}")
 
 
-def get_relative_file_path(file_path: str, base_path: str = "") -> Path:
+def get_relative_file_path(
+    file_path: str, base_path: str = "", relative_to: str = "."
+) -> Path:
     """
     Returns the relative file path of a given file with respect to
     the current working directory (CWD).
@@ -189,13 +191,23 @@ def get_relative_file_path(file_path: str, base_path: str = "") -> Path:
         The full file path to be converted to a relative path.
     base_path : str, optional
         The base path to be prepended to the relative path, default is an empty string.
+    relativ_to : str, optional
+        The directory to which the file path should be relative,
+        default is the current directory (".").
 
     Returns
     -------
     Path
         The file path relative to the CWD.
     """
-    rel_path = Path(file_path).resolve().relative_to(Path.cwd().resolve())
+    if relative_to == ".":
+        # Use the current working directory as the base
+        relative_to = Path.cwd()
+    elif isinstance(relative_to, str):
+        # ensure path is a Path object
+        relative_to = Path(relative_to)
+    rel_path = os.path.relpath(Path(file_path).resolve(), relative_to)
+    rel_path = Path(rel_path)  # Ensure rel_path is a Path object
 
     if base_path:
         rel_path = Path(base_path) / rel_path