alternate version of the app

alternate.py

@@ -0,0 +1,228 @@
+import os
+import json
+from typing import Optional
+import gradio as gr
+from gradio import Interface, Blocks
+import networkx as nx
+import pandas as pd
+import matplotlib.pyplot as plt
+import community as community_louvain
+import pyvis
+from pyvis.network import Network
+from smolagents import CodeAgent, HfApiModel, tool, GradioUI
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from openinference.instrumentation.smolagents import SmolagentsInstrumentor
+
+# Set up telemetry
+PHOENIX_API_KEY = os.getenv("PHOENIX_API_KEY")
+api_key = f"api_key={PHOENIX_API_KEY}"
+os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = api_key
+os.environ["PHOENIX_CLIENT_HEADERS"] = api_key
+os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "https://app.phoenix.arize.com"
+
+# Updated endpoint from local to cloud
+endpoint = "https://app.phoenix.arize.com/v1/traces"
+trace_provider = TracerProvider()
+trace_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint)))
+SmolagentsInstrumentor().instrument(tracer_provider=trace_provider)
+
+examples = [
+    ["Analyze the degree, betweenness, and closeness centrality metrics for all families in the network, and highlight families with the highest values for each metric."],
+    ["Identify families with significant betweenness centrality and discuss their potential influence in the network."],
+    ["Compare the top three families by degree centrality with their closeness centrality rankings, and explain the differences."],
+    ["Visualize the network structure, emphasizing families with high centrality values using color or size variations."],
+    ["Explore the roles of families with above-average centrality values across all metrics and discuss their positions in the network."]
+]
+
+class GradioUIWithExamples(GradioUI):
+    def __init__(self, agent, examples=None, **kwargs):
+        super().__init__(agent, **kwargs)
+        self.examples = examples
+
+    def build_interface(self):
+        with gr.Blocks() as demo:
+            gr.Markdown("## Florentine Families Network Analysis")
+
+            # Main Input/Output
+            input_box = gr.Textbox(
+                label="Your Question",
+                placeholder="Type your question about the Florentine Families graph...",
+            )
+            output_box = gr.Textbox(
+                label="Agent's Response",
+                placeholder="Response will appear here...",
+                interactive=False,
+            )
+            submit_button = gr.Button("Submit")
+
+            # Link submit button to agent logic
+            submit_button.click(
+                self.agent.run,
+                inputs=input_box,
+                outputs=output_box,
+            )
+
+            # Add Examples
+            if self.examples:
+                gr.Markdown("### Examples")
+                for example in self.examples:
+                    gr.Button(example[0]).click(
+                        lambda x=example[0]: x,  # Populate input box
+                        inputs=[],
+                        outputs=input_box,
+                    )
+        return demo
+
+    def launch(self):
+        # Use the custom-built interface instead of the base class's logic
+        demo = self.build_interface()
+        demo.launch()
+
+# Initialize graph
+graph = nx.florentine_families_graph()
+#graph = nx.les_miserables_graph()
+
+@tool
+def analyze_graph(graph: nx.Graph, metrics: Optional[str] = None, visualize: Optional[bool] = False) -> dict:
+    """
+    Performs an in-depth analysis of the Florentine families graph, a predefined social network representing relationships between Renaissance Florentine families. This graph has already been initialized and should be used for all analyses unless another graph is explicitly provided.
+
+    Args:
+        graph: A networkx graph object to analyze. This is a required argument.
+        metrics: A comma-separated string of centrality metrics to calculate. 
+            Valid options include: 'degree', 'betweenness', 'closeness', 'eigenvector', 
+            'density', 'clustering_coefficient'. If None, all metrics will be calculated.
+        visualize: A boolean indicating whether to generate visualizations for the graph and its metrics.
+
+    Returns:
+        A dictionary containing:
+        - 'metrics': Numerical results for the requested centrality metrics.
+        - 'graph_summary': High-level statistics about the graph (number of nodes, edges, density, etc.).
+        - 'community_info': Detected communities, if applicable.
+        - 'visualizations': Paths to generated visualization files, if visualize is True.
+
+    Note:
+        - This tool defaults to analyzing the Florentine families graph. If a different graph is provided, it will override the default.
+        - Ensure that the 'metrics' argument contains valid options to avoid errors.
+    """
+
+    if metrics:
+        metrics = [metric.strip() for metric in metrics.split(',')]
+    else:
+        metrics = ['degree', 'betweenness', 'closeness', 'eigenvector', 'density', 'clustering_coefficient']
+
+    # Graph summary
+    graph_summary = {
+        "number_of_nodes": graph.number_of_nodes(),
+        "number_of_edges": graph.number_of_edges(),
+        "density": nx.density(graph),
+        "average_clustering": nx.average_clustering(graph),
+        "connected_components": len(list(nx.connected_components(graph))),
+    }
+
+    # Compute requested metrics
+    computed_metrics = {}
+    if 'degree' in metrics:
+        computed_metrics['degree_centrality'] = nx.degree_centrality(graph)
+    if 'betweenness' in metrics:
+        computed_metrics['betweenness_centrality'] = nx.betweenness_centrality(graph)
+    if 'closeness' in metrics:
+        computed_metrics['closeness_centrality'] = nx.closeness_centrality(graph)
+    if 'eigenvector' in metrics:
+        computed_metrics['eigenvector_centrality'] = nx.eigenvector_centrality(graph)
+    if 'density' in metrics:
+        computed_metrics['density'] = nx.density(graph)
+    if 'clustering_coefficient' in metrics:
+        computed_metrics['clustering_coefficient'] = nx.average_clustering(graph)
+
+    # Community detection
+    communities = community_louvain.best_partition(graph)
+
+    # Visualizations
+    visualizations = []
+    if visualize:
+        pos = nx.spring_layout(graph)
+        plt.figure(figsize=(10, 8))
+        nx.draw(
+            graph,
+            pos,
+            with_labels=True,
+            node_size=700,
+            node_color=list(communities.values()),
+            cmap=plt.cm.rainbow,
+        )
+        plt.title("Graph Visualization - Communities")
+        viz_path = "graph_communities.png"
+        plt.savefig(viz_path)
+        visualizations.append(viz_path)
+
+    return {
+        "metrics": computed_metrics,
+        "graph_summary": graph_summary,
+        "community_info": communities,
+        "visualizations": visualizations if visualize else "Visualizations not generated.",
+    }
+
+@tool
+def save_html_to_file(html_content: str, file_path: str) -> str:
+    """
+    Saves the provided HTML content to a file.
+
+    Args:
+        html_content: The HTML content to save.
+        file_path: The path where the HTML file will be saved.
+
+    Returns:
+        A confirmation message upon successful saving.
+    """
+    with open(file_path, 'w', encoding='utf-8') as file:
+        file.write(html_content)
+    return f"HTML content successfully saved to {file_path}"
+
+@tool
+def read_html_from_file(file_path: str) -> str:
+    """
+    Reads HTML content from a file.
+
+    Args:
+        file_path: The path of the HTML file to read.
+
+    Returns:
+        The HTML content as a string.
+    """
+    with open(file_path, 'r', encoding='utf-8') as file:
+        html_content = file.read()
+    return html_content
+
+@tool
+def export_graph_to_json(graph_data: dict) -> str:
+    """
+    Exports a NetworkX graph represented as a dictionary in node-link format to JSON.
+
+    Args:
+        graph_data: The graph data in node-link format.
+
+    Returns:
+        str: The JSON representation of the graph.
+
+    """
+    try:
+        graph = nx.node_link_graph(graph_data, edges="edges")
+        json_output = json.dumps(nx.node_link_data(graph), indent=4)
+        return json_output
+    except Exception as e:
+        return f"Error exporting graph to JSON: {str(e)}"
+
+model = HfApiModel()
+agent = CodeAgent(
+    tools=[analyze_graph, save_html_to_file, read_html_from_file, export_graph_to_json],
+    model=model,
+    additional_authorized_imports=["gradio","networkx","community_louvain","pyvis","matplotlib","json", "pandas"],
+    add_base_tools=True
+)
+
+interface = GradioUIWithExamples(agent, examples=examples)
+interface.launch()