Remove int_visualization_tool parameter and keep just plot_type. Modify the plot code generation for streamlit and quarto reports accordingly.

Author: sayalaruano

report_metadata_micw2graph.yaml

@@ -11,8 +11,8 @@ report:
     and potential ecological functions.
   graphical_abstract: "example_data/MicW2Graph/Methods_MicW2Graph.png"
   logo: "example_data/mona_logo.png"
-  report_type: "streamlit"
-  report_format: ""
+  report_type: "document"
+  report_format: "docx"
 sections:
   - title: "Exploratory Data Analysis"
     subsections:
@@ -21,15 +21,13 @@ sections:
         components:
           - title: "Top 5 species by biome (plotly)"
             component_type: "plot"
-            plot_type: "interactive"
+            plot_type: "plotly"
             file_path: "example_data/MicW2Graph/top_species_plot_biome.json"
-            int_visualization_tool: "plotly"
             caption: "Optional caption"
           - title: "Multiline plot (altair)"
             component_type: "plot"
-            plot_type: "interactive"
+            plot_type: "altair"
             file_path: "example_data/altair_multilineplot.json"
-            int_visualization_tool: "altair"
           - title: "Abundance data for all studies (csv)"
             component_type: "dataframe"
             file_path: "example_data/MicW2Graph/abundance_data_allbiomes.csv"
@@ -48,9 +46,8 @@ sections:
             file_path: "example_data/MicW2Graph/number_samples_per_study.png"
           - title: "Sampling countries for all studies (plotly)"
             component_type: "plot"
-            plot_type: "interactive"
+            plot_type: "plotly"
             file_path: "example_data/MicW2Graph/pie_plot_countries.json"
-            int_visualization_tool: "plotly"
           - title: "Sample data for all studies (txt)"
             component_type: "dataframe"
             file_path: "example_data/MicW2Graph/sample_info_allbiomes.txt"
@@ -70,15 +67,13 @@ sections:
         components:
           - title: "Network1 (graphml)"
             component_type: "plot"
-            plot_type: "interactive"
-            int_visualization_tool: "pyvis"
+            plot_type: "interactive_network"
             file_path: "example_data/MicW2Graph/man_example.graphml"
       - title: "Network Visualization2"
         components:
           - title: "Network2 (edge list csv)"
             component_type: "plot"
-            plot_type: "interactive"
-            int_visualization_tool: "pyvis"
+            plot_type: "interactive_network"
             csv_network_format: "edgelist"
             file_path: "example_data/MicW2Graph/man_example.csv"
       - title: "Edge list"

vuegen/main.py

@@ -7,7 +7,7 @@
     report_config = load_yaml_config(config_path)
 
     # Define logger suffix based on report engine, type and name
-    report_engine = "streamlit" 
+    report_engine = "quarto" 
     report_type = report_config['report'].get('report_type')
     report_format = report_config['report'].get('report_format')
     report_name = report_config['report'].get('name')

vuegen/metadata_manager.py

@@ -156,8 +156,6 @@ def _create_plot_component(self, component_data: dict) -> r.Plot:
         """
         # Validate enum fields
         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', ''), self.logger) 
                               if component_data.get('csv_network_format') else None)
 
@@ -166,7 +164,6 @@ def _create_plot_component(self, component_data: dict) -> r.Plot:
             logger = self.logger,
             file_path = component_data['file_path'],
             plot_type = plot_type,
-            int_visualization_tool = int_visualization_tool,
             csv_network_format = csv_network_format,
             caption = component_data.get('caption')
         )

vuegen/quarto_reportview.py

@@ -265,54 +265,50 @@ def _generate_plot_content(self, plot, is_report_static, static_dir: str = STATI
         plot_content = []
         # Add title
         plot_content.append(f'### {plot.title}')
+        
+        # Define plot path
+        if is_report_static:
+            static_plot_path  = os.path.join(static_dir, f"{plot.title.replace(' ', '_')}.png")
+        else:
+            html_plot_file  = os.path.join(static_dir, f"{plot.title.replace(' ', '_')}.html")
 
-        if plot.plot_type == r.PlotType.INTERACTIVE:
-            try:
-                # Define plot path
+        # Add content for the different plot types
+        try:
+            if plot.plot_type == r.PlotType.STATIC:
+                plot_content.append(self._generate_image_content(plot.file_path, width=950))
+            elif plot.plot_type == r.PlotType.PLOTLY:
+                plot_content.append(self._generate_plot_code(plot))
                 if is_report_static:
-                    static_plot_path  = os.path.join(static_dir, f"{plot.title.replace(' ', '_')}.png")
+                    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))
                 else:
-                    html_plot_file  = os.path.join(static_dir, f"{plot.title.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))
-                    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))
-                    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))
-                    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))
+                    plot_content.append(f"""fig_plotly.show()\n```\n""")
+            elif plot.plot_type == r.PlotType.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))
                 else:
-                        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.title}: {str(e)}")
-                raise
-        
-        elif plot.plot_type == r.PlotType.STATIC:
-            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.title}: {str(e)}")
-                raise
+                    plot_content.append(f"""fig_altair\n```\n""")
+            elif plot.plot_type == r.PlotType.INTERACTIVE_NETWORK:
+                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))
+                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:
+                    self.report.logger.warning(f"Unsupported plot type: {plot.plot_type}")
+        except Exception as e:
+            self.report.logger.error(f"Error generating content for '{plot.plot_type}' plot '{plot.id}' '{plot.title}': {str(e)}")
+            raise
 
         # Add caption if available
         if plot.caption:
@@ -344,13 +340,13 @@ def _generate_plot_code(self, plot, output_file = "") -> str:
     plot_data = plot_file.read()
     """
         # Add specific code for each visualization tool
-        if plot.int_visualization_tool == r.IntVisualizationTool.PLOTLY:
+        if plot.plot_type == r.PlotType.PLOTLY:
             plot_code += """fig_plotly = pio.from_json(plot_data)
 fig_plotly.update_layout(width=950, height=500)
     """
-        elif plot.int_visualization_tool == r.IntVisualizationTool.ALTAIR:
+        elif plot.plot_type == r.PlotType.ALTAIR:
             plot_code += """fig_altair = alt.Chart.from_json(plot_data).properties(width=900, height=400)"""
-        elif plot.int_visualization_tool == r.IntVisualizationTool.PYVIS:
+        elif plot.plot_type == r.PlotType.INTERACTIVE_NETWORK:
             plot_code = f"""<div style="text-align: center;">
 <iframe src="{os.path.join("..", output_file)}" alt="{plot.title} plot" width="800px" height="630px"></iframe>
 </div>\n"""
@@ -524,8 +520,8 @@ def _generate_component_imports(self, component: r.Component) -> List[str]:
         # Dictionary to hold the imports for each component type
         components_imports = {
             'plot': {
-                r.IntVisualizationTool.ALTAIR: ['import altair as alt'],
-                r.IntVisualizationTool.PLOTLY: ['import plotly.io as pio']
+                r.PlotType.ALTAIR: ['import altair as alt'],
+                r.PlotType.PLOTLY: ['import plotly.io as pio']
             },
             'dataframe': ['import pandas as pd', 'from itables import show', 'import dataframe_image as dfi'],
             'markdown': ['import IPython.display as display']
@@ -537,9 +533,9 @@ def _generate_component_imports(self, component: r.Component) -> List[str]:
 
         # Add relevant imports based on component type and visualization tool
         if component_type == r.ComponentType.PLOT:
-            int_visualization_tool = getattr(component, 'int_visualization_tool', None)
-            if int_visualization_tool in components_imports['plot']:
-                component_imports.extend(components_imports['plot'][int_visualization_tool])
+            plot_type = getattr(component, 'plot_type', None)
+            if plot_type in components_imports['plot']:
+                component_imports.extend(components_imports['plot'][plot_type])
         elif component_type == r.ComponentType.DATAFRAME:
             component_imports.extend(components_imports['dataframe'])
         elif component_type == r.ComponentType.MARKDOWN:

vuegen/report.py

@@ -26,13 +26,10 @@ class ComponentType(StrEnum):
     CHATBOT = auto()
 
 class PlotType(StrEnum):
-    INTERACTIVE = auto()
     STATIC = auto()
-
-class IntVisualizationTool(StrEnum):
     PLOTLY = auto()
     ALTAIR = auto()
-    PYVIS = auto()
+    INTERACTIVE_NETWORK = auto()
 
 class NetworkFormat(StrEnum):
     GML = auto()
@@ -110,8 +107,7 @@ class Plot(Component):
         The format of the CSV file for network plots (EDGELIST or ADJLIST) (default is None).
     """
     def __init__(self, title: str, logger: logging.Logger, plot_type: PlotType, file_path: str=None,
-                caption: str=None, int_visualization_tool: Optional[IntVisualizationTool]=None,
-                csv_network_format: Optional[CSVNetworkFormat]=None):
+                caption: str=None, csv_network_format: Optional[CSVNetworkFormat]=None):
         """
         Initializes a Plot object.
         """
@@ -121,7 +117,6 @@ def __init__(self, title: str, logger: logging.Logger, plot_type: PlotType, file
 
         # Set specific attributes for the Plot class
         self.plot_type = plot_type
-        self.int_visualization_tool = int_visualization_tool
         self.csv_network_format = csv_network_format
 
     def read_network(self) -> nx.Graph:

vuegen/streamlit_reportview.py

@@ -303,39 +303,33 @@ def _generate_plot_content(self, plot, static_dir: str = STATIC_FILES_DIR) -> Li
 
         # Add title
         plot_content.append(self._format_text(text=plot.title, type='header', level=4, color='#2b8cbe'))
-
-        if plot.plot_type == r.PlotType.INTERACTIVE:
-            try:
-                # Handle interactive plot
-                if plot.int_visualization_tool == r.IntVisualizationTool.PLOTLY:
-                    plot_content.append(self._generate_plot_code(plot))
-                elif plot.int_visualization_tool == r.IntVisualizationTool.ALTAIR:
-                    plot_content.append(self._generate_plot_code(plot))
-                elif plot.int_visualization_tool == r.IntVisualizationTool.PYVIS:
-                    # For PyVis, 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)
-                    num_nodes = len(net.nodes)
-                    num_edges = len(net.edges)
-                    plot_content.append(f"""with open('{html_plot_file}', 'r') as f:
+        
+        # Add content for the different plot types
+        try:
+            if plot.plot_type == r.PlotType.STATIC:
+                plot_content.append(f"\nst.image('{plot.file_path}', caption='{plot.caption}', use_column_width=True)\n")  
+            elif plot.plot_type == r.PlotType.PLOTLY:
+                plot_content.append(self._generate_plot_code(plot))
+            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)
+                num_nodes = len(net.nodes)
+                num_edges = len(net.edges)
+                plot_content.append(f"""with open('{html_plot_file}', 'r') as f:
     html_data = f.read()
 st.markdown(f"<p style='text-align: center; color: black;'> <b>Number of nodes:</b> {num_nodes} </p>", unsafe_allow_html=True)
 st.markdown(f"<p style='text-align: center; color: black;'> <b>Number of relationships:</b> {num_edges} </p>", unsafe_allow_html=True)""")
-                    plot_content.append(self._generate_plot_code(plot))
-                else:
-                    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 content for plot '{plot.id}' '{plot.title}': {str(e)}")
-                raise
+                plot_content.append(self._generate_plot_code(plot))
+            else:
+                self.report.logger.warning(f"Unsupported plot type: {plot.plot_type}")
+        except Exception as e:
+            self.report.logger.error(f"Error generating content for '{plot.plot_type}' plot '{plot.id}' '{plot.title}': {str(e)}")
+            raise      
 
-        elif plot.plot_type == r.PlotType.STATIC:
-            try:
-                # Handle static plot
-                plot_content.append(f"\nst.image('{plot.file_path}', caption='{plot.caption}', use_column_width=True)\n")
-            except Exception as e:
-                self.report.logger.error(f"Error generating content for static plot  '{plot.id}' '{plot.title}': {str(e)}")
-                raise        
         # Add caption if available
         if plot.caption:
             plot_content.append(self._format_text(text=plot.caption, type='caption', text_align="left"))
@@ -362,20 +356,19 @@ def _generate_plot_code(self, plot) -> str:
         plot_code = f"""with open('{plot.file_path}', 'r') as plot_file:
     plot_json = json.load(plot_file)\n"""
         # Add specific code for each visualization tool
-        if plot.int_visualization_tool == r.IntVisualizationTool.PLOTLY:
+        if plot.plot_type == r.PlotType.PLOTLY:
             plot_code += "st.plotly_chart(plot_json, use_container_width=True)\n"
 
-        elif plot.int_visualization_tool == r.IntVisualizationTool.ALTAIR:
+        elif plot.plot_type == r.PlotType.ALTAIR:
             plot_code += """altair_plot = alt.Chart.from_dict(plot_json)
 st.vega_lite_chart(json.loads(altair_plot.to_json()), use_container_width=True)\n"""
 
-        elif plot.int_visualization_tool == r.IntVisualizationTool.PYVIS:
+        elif plot.plot_type == r.PlotType.INTERACTIVE_NETWORK:
             plot_code = """# Streamlit checkbox for controlling the layout
 control_layout = st.checkbox('Add panel to control layout', value=True)
 net_html_height = 1200 if control_layout else 630
 # Load HTML into HTML component for display on Streamlit
 st.components.v1.html(html_data, height=net_html_height)\n"""
-
         return plot_code
 
     def _generate_dataframe_content(self, dataframe) -> List[str]:
@@ -537,8 +530,8 @@ def _generate_component_imports(self, component: r.Component) -> List[str]:
         # Dictionary to hold the imports for each component type
         components_imports = {
             'plot': {
-                r.IntVisualizationTool.ALTAIR: ['import json', 'import altair as alt'],
-                r.IntVisualizationTool.PLOTLY: ['import json']
+                r.PlotType.ALTAIR: ['import json', 'import altair as alt'],
+                r.PlotType.PLOTLY: ['import json']
             },
             'dataframe': ['import pandas as pd']
         }
@@ -548,9 +541,9 @@ def _generate_component_imports(self, component: r.Component) -> List[str]:
 
         # Add relevant imports based on component type and visualization tool
         if component_type == r.ComponentType.PLOT:
-            int_visualization_tool = getattr(component, 'int_visualization_tool', None)
-            if int_visualization_tool in components_imports['plot']:
-                component_imports.extend(components_imports['plot'][int_visualization_tool])
+            plot_type = getattr(component, 'plot_type', None)
+            if plot_type in components_imports['plot']:
+                component_imports.extend(components_imports['plot'][plot_type])
         elif component_type == r.ComponentType.DATAFRAME:
             component_imports.extend(components_imports['dataframe'])