Create app.py

app.py

@@ -0,0 +1,549 @@
+import gradio as gr
+import plotly.graph_objects as go
+import networkx as nx
+import pandas as pd
+from collections import defaultdict
+
+# Entity type colors
+ENTITY_COLORS = {
+    'PERSON': '#00B894',      # Green
+    'LOCATION': '#A0E7E5',    # Light Cyan
+    'EVENT': '#4ECDC4',       # Teal
+    'ORGANIZATION': '#55A3FF', # Light Blue
+    'DATE': '#FF6B6B'         # Red
+}
+
+# Relationship types for dropdown
+RELATIONSHIP_TYPES = [
+    'works_with',
+    'located_in',
+    'participated_in',
+    'member_of',
+    'occurred_at',
+    'employed_by',
+    'founded',
+    'attended',
+    'knows',
+    'related_to',
+    'collaborates_with',
+    'other'
+]
+
+class NetworkGraphBuilder:
+    def __init__(self):
+        self.entities = []
+        self.relationships = []
+        
+    def add_entity(self, name, entity_type, record_id):
+        """Add an entity to the collection"""
+        if name.strip():
+            self.entities.append({
+                'name': name.strip(),
+                'type': entity_type,
+                'record_id': record_id
+            })
+    
+    def add_relationship(self, source, target, rel_type):
+        """Add a relationship between entities"""
+        if source and target and source != target:
+            self.relationships.append({
+                'source': source.strip(),
+                'target': target.strip(),
+                'type': rel_type
+            })
+    
+    def build_graph(self):
+        """Build NetworkX graph from entities and relationships"""
+        G = nx.Graph()
+        
+        # Add nodes with attributes
+        for entity in self.entities:
+            G.add_node(
+                entity['name'],
+                entity_type=entity['type'],
+                record_id=entity['record_id']
+            )
+        
+        # Add edges
+        for rel in self.relationships:
+            if rel['source'] in G.nodes and rel['target'] in G.nodes:
+                G.add_edge(
+                    rel['source'],
+                    rel['target'],
+                    relationship=rel['type']
+                )
+        
+        return G
+    
+    def create_plotly_graph(self, G, layout_type='spring'):
+        """Create interactive Plotly visualization"""
+        if len(G.nodes) == 0:
+            return None
+        
+        # Choose layout
+        if layout_type == 'spring':
+            pos = nx.spring_layout(G, k=2, iterations=50)
+        elif layout_type == 'circular':
+            pos = nx.circular_layout(G)
+        elif layout_type == 'kamada_kawai':
+            pos = nx.kamada_kawai_layout(G)
+        else:
+            pos = nx.shell_layout(G)
+        
+        # Create edge traces
+        edge_traces = []
+        edge_labels = []
+        
+        for edge in G.edges(data=True):
+            x0, y0 = pos[edge[0]]
+            x1, y1 = pos[edge[1]]
+            
+            # Edge line
+            edge_trace = go.Scatter(
+                x=[x0, x1, None],
+                y=[y0, y1, None],
+                mode='lines',
+                line=dict(width=2, color='#888'),
+                hoverinfo='none',
+                showlegend=False
+            )
+            edge_traces.append(edge_trace)
+            
+            # Edge label (relationship type)
+            rel_type = edge[2].get('relationship', '')
+            edge_label = go.Scatter(
+                x=[(x0 + x1) / 2],
+                y=[(y0 + y1) / 2],
+                mode='text',
+                text=[rel_type],
+                textfont=dict(size=10, color='#555'),
+                hoverinfo='text',
+                hovertext=f"{edge[0]} → {rel_type} → {edge[1]}",
+                showlegend=False
+            )
+            edge_labels.append(edge_label)
+        
+        # Create node traces (one per entity type for legend)
+        node_traces = {}
+        for node, data in G.nodes(data=True):
+            entity_type = data.get('entity_type', 'UNKNOWN')
+            
+            if entity_type not in node_traces:
+                node_traces[entity_type] = {
+                    'x': [],
+                    'y': [],
+                    'text': [],
+                    'hovertext': [],
+                    'degree': []
+                }
+            
+            x, y = pos[node]
+            node_traces[entity_type]['x'].append(x)
+            node_traces[entity_type]['y'].append(y)
+            node_traces[entity_type]['text'].append(node)
+            
+            # Create hover text with connections
+            connections = list(G.neighbors(node))
+            hover_info = f"<b>{node}</b><br>"
+            hover_info += f"Type: {entity_type}<br>"
+            hover_info += f"Connections: {len(connections)}<br>"
+            if connections:
+                hover_info += f"Connected to: {', '.join(connections[:5])}"
+                if len(connections) > 5:
+                    hover_info += f"... and {len(connections) - 5} more"
+            
+            node_traces[entity_type]['hovertext'].append(hover_info)
+            node_traces[entity_type]['degree'].append(G.degree(node))
+        
+        # Create Plotly traces for each entity type
+        data = edge_traces + edge_labels
+        
+        for entity_type, trace_data in node_traces.items():
+            # Calculate node sizes based on degree
+            max_degree = max(trace_data['degree']) if trace_data['degree'] else 1
+            sizes = [20 + (degree / max_degree) * 30 for degree in trace_data['degree']]
+            
+            node_trace = go.Scatter(
+                x=trace_data['x'],
+                y=trace_data['y'],
+                mode='markers+text',
+                marker=dict(
+                    size=sizes,
+                    color=ENTITY_COLORS.get(entity_type, '#CCCCCC'),
+                    line=dict(width=2, color='white')
+                ),
+                text=trace_data['text'],
+                textposition='top center',
+                textfont=dict(size=10, color='#333'),
+                hovertext=trace_data['hovertext'],
+                hoverinfo='text',
+                name=entity_type,
+                showlegend=True
+            )
+            data.append(node_trace)
+        
+        # Create figure
+        fig = go.Figure(
+            data=data,
+            layout=go.Layout(
+                title=dict(
+                    text='<b>Entity Network Graph</b><br><sub>Node size indicates number of connections</sub>',
+                    x=0.5,
+                    xanchor='center'
+                ),
+                showlegend=True,
+                hovermode='closest',
+                margin=dict(b=20, l=5, r=5, t=80),
+                xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                plot_bgcolor='#fafafa',
+                height=700,
+                legend=dict(
+                    title=dict(text='<b>Entity Types</b>'),
+                    orientation='v',
+                    yanchor='top',
+                    y=1,
+                    xanchor='left',
+                    x=1.02
+                )
+            )
+        )
+        
+        return fig
+
+def collect_entities_from_records(*args):
+    """Collect all entities from the input fields"""
+    builder = NetworkGraphBuilder()
+    
+    # Each record has 5 entity fields (person, location, event, org, date)
+    num_records = 6
+    fields_per_record = 5
+    
+    for i in range(num_records):
+        record_id = i + 1
+        base_idx = i * fields_per_record
+        
+        # Extract entities for this record
+        person = args[base_idx] if base_idx < len(args) else ""
+        location = args[base_idx + 1] if base_idx + 1 < len(args) else ""
+        event = args[base_idx + 2] if base_idx + 2 < len(args) else ""
+        org = args[base_idx + 3] if base_idx + 3 < len(args) else ""
+        date = args[base_idx + 4] if base_idx + 4 < len(args) else ""
+        
+        if person:
+            builder.add_entity(person, 'PERSON', record_id)
+        if location:
+            builder.add_entity(location, 'LOCATION', record_id)
+        if event:
+            builder.add_entity(event, 'EVENT', record_id)
+        if org:
+            builder.add_entity(org, 'ORGANIZATION', record_id)
+        if date:
+            builder.add_entity(date, 'DATE', record_id)
+    
+    # Create list of all entity names for relationship dropdowns
+    entity_names = [e['name'] for e in builder.entities]
+    
+    # Create summary
+    summary = f"""
+    ### 📊 Entities Collected
+    - **Total entities:** {len(builder.entities)}
+    - **People:** {sum(1 for e in builder.entities if e['type'] == 'PERSON')}
+    - **Locations:** {sum(1 for e in builder.entities if e['type'] == 'LOCATION')}
+    - **Events:** {sum(1 for e in builder.entities if e['type'] == 'EVENT')}
+    - **Organizations:** {sum(1 for e in builder.entities if e['type'] == 'ORGANIZATION')}
+    - **Dates:** {sum(1 for e in builder.entities if e['type'] == 'DATE')}
+    
+    Now define relationships between these entities below.
+    """
+    
+    # Return summary and update dropdowns
+    return (
+        summary,
+        gr.update(visible=True),  # Show relationship section
+        gr.update(choices=entity_names, value=None),  # Update all relationship dropdowns
+        gr.update(choices=entity_names, value=None),
+        gr.update(choices=entity_names, value=None),
+        gr.update(choices=entity_names, value=None),
+        gr.update(choices=entity_names, value=None),
+        gr.update(choices=entity_names, value=None),
+        gr.update(choices=entity_names, value=None),
+        gr.update(choices=entity_names, value=None),
+        gr.update(choices=entity_names, value=None),
+        gr.update(choices=entity_names, value=None)
+    )
+
+def generate_network_graph(*args):
+    """Generate the network graph from all inputs"""
+    builder = NetworkGraphBuilder()
+    
+    # Collect entities (first 30 args: 6 records × 5 fields)
+    num_records = 6
+    fields_per_record = 5
+    
+    for i in range(num_records):
+        record_id = i + 1
+        base_idx = i * fields_per_record
+        
+        person = args[base_idx] if base_idx < len(args) else ""
+        location = args[base_idx + 1] if base_idx + 1 < len(args) else ""
+        event = args[base_idx + 2] if base_idx + 2 < len(args) else ""
+        org = args[base_idx + 3] if base_idx + 3 < len(args) else ""
+        date = args[base_idx + 4] if base_idx + 4 < len(args) else ""
+        
+        if person:
+            builder.add_entity(person, 'PERSON', record_id)
+        if location:
+            builder.add_entity(location, 'LOCATION', record_id)
+        if event:
+            builder.add_entity(event, 'EVENT', record_id)
+        if org:
+            builder.add_entity(org, 'ORGANIZATION', record_id)
+        if date:
+            builder.add_entity(date, 'DATE', record_id)
+    
+    # Collect relationships (next args: 5 relationships × 3 fields)
+    relationship_start = 30
+    num_relationships = 5
+    
+    for i in range(num_relationships):
+        base_idx = relationship_start + (i * 3)
+        source = args[base_idx] if base_idx < len(args) else None
+        target = args[base_idx + 1] if base_idx + 1 < len(args) else None
+        rel_type = args[base_idx + 2] if base_idx + 2 < len(args) else None
+        
+        if source and target:
+            builder.add_relationship(source, target, rel_type)
+    
+    # Get layout type (last arg)
+    layout_type = args[-1] if len(args) > relationship_start else 'spring'
+    
+    # Build graph
+    G = builder.build_graph()
+    
+    if len(G.nodes) == 0:
+        return None, "❌ No entities to display. Please add some entities first."
+    
+    if len(G.edges) == 0:
+        return None, "⚠️ No relationships defined. The graph will show isolated nodes."
+    
+    # Create visualization
+    fig = builder.create_plotly_graph(G, layout_type)
+    
+    # Create statistics
+    stats = f"""
+    ### 📈 Network Statistics
+    - **Nodes (Entities):** {G.number_of_nodes()}
+    - **Edges (Relationships):** {G.number_of_edges()}
+    - **Network Density:** {nx.density(G):.3f}
+    - **Average Connections per Node:** {sum(dict(G.degree()).values()) / G.number_of_nodes():.2f}
+    """
+    
+    if G.number_of_edges() > 0:
+        # Find most connected nodes
+        degrees = dict(G.degree())
+        top_nodes = sorted(degrees.items(), key=lambda x: x[1], reverse=True)[:3]
+        stats += "\n**Most Connected Entities:**\n"
+        for node, degree in top_nodes:
+            stats += f"- {node}: {degree} connections\n"
+    
+    return fig, stats
+
+def create_interface():
+    with gr.Blocks(title="Basic Networks Explorer", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # Basic Networks Explorer
+        
+        Build interactive social network graphs by entering entities extracted through Named Entity Recognition (NER).
+        This tool demonstrates how NER can be used to visualize relationships and connections in text data.
+        
+        ### How to use this tool:
+        1. **📝 Enter entities** in the records below (people, locations, events, organizations, dates)
+        2. **🔗 Click "Collect Entities"** to gather all your inputs
+        3. **🤝 Define relationships** between entities in the relationship builder
+        4. **🎨 Choose a layout style** and click "Generate Network Graph"
+        5. **👁️ Explore** the interactive visualization
+        6. **🔄 Refresh the page** to start over with new data
+        """)
+        
+        # Add tip box
+        gr.HTML("""
+        <div style="background-color: #fff3cd; border: 1px solid #ffeaa7; border-radius: 8px; padding: 12px; margin: 15px 0;">
+            <strong style="color: #856404;">💡 Top tip:</strong> This tool works best when you have already identified entities from text using NER. Try the NER Explorer Tool first to extract entities automatically!
+        </div>
+        """)
+        
+        # Entity input section
+        entity_inputs = []
+        
+        with gr.Accordion("📚 Step 1: Enter Entities from Your Records", open=True):
+            for i in range(6):
+                with gr.Group():
+                    gr.Markdown(f"### Record {i+1}")
+                    with gr.Row():
+                        person = gr.Textbox(label="👤 Person", placeholder="e.g., Albert Einstein")
+                        location = gr.Textbox(label="📍 Location", placeholder="e.g., Berlin")
+                        event = gr.Textbox(label="📅 Event", placeholder="e.g., Nobel Prize Ceremony")
+                    with gr.Row():
+                        org = gr.Textbox(label="🏢 Organization", placeholder="e.g., Princeton University")
+                        date = gr.Textbox(label="🗓️ Date", placeholder="e.g., 1921")
+                    
+                    entity_inputs.extend([person, location, event, org, date])
+        
+        collect_btn = gr.Button("🔍 Collect Entities", variant="primary", size="lg")
+        
+        entity_summary = gr.Markdown()
+        
+        # Relationship section (initially hidden)
+        with gr.Column(visible=False) as relationship_section:
+            with gr.Accordion("🤝 Step 2: Define Relationships Between Entities", open=True):
+                gr.Markdown("Select entities and specify how they're connected:")
+            
+                relationship_inputs = []
+                
+                for i in range(5):
+                    with gr.Row():
+                        source = gr.Dropdown(label=f"From Entity {i+1}", choices=[], interactive=True)
+                        rel_type = gr.Dropdown(
+                            label="Relationship Type",
+                            choices=RELATIONSHIP_TYPES,
+                            value="related_to",
+                            interactive=True
+                        )
+                        target = gr.Dropdown(label=f"To Entity {i+1}", choices=[], interactive=True)
+                    
+                    relationship_inputs.extend([source, rel_type, target])
+            
+            with gr.Accordion("🎨 Step 3: Customize and Generate", open=True):
+                layout_type = gr.Dropdown(
+                    label="Graph Layout",
+                    choices=['spring', 'circular', 'kamada_kawai', 'shell'],
+                    value='spring',
+                    info="Choose how nodes are arranged"
+                )
+                
+                generate_btn = gr.Button("🔍 Generate Network Graph", variant="primary", size="lg")
+        
+        # Output section
+        gr.HTML("<hr style='margin: 30px 0;'>")
+        
+        with gr.Row():
+            network_stats = gr.Markdown()
+        
+        with gr.Row():
+            network_plot = gr.Plot(label="Interactive Network Graph")
+        
+        # Examples
+        with gr.Column():
+            gr.Markdown("""
+            ### 💡 No example entities to test? No problem!
+            Simply click on one of the examples provided below, and the fields will be populated for you.
+            """, elem_id="examples-heading")
+        gr.Examples(
+            examples=[
+                [
+                    # Record 1
+                    "Winston Churchill", "London", "Battle of Britain", "Royal Air Force", "1940",
+                    # Record 2
+                    "Franklin D. Roosevelt", "Washington D.C.", "Pearl Harbor Attack", "United States Navy", "December 7, 1941",
+                    # Record 3
+                    "Dwight D. Eisenhower", "Normandy", "D-Day Invasion", "Allied Forces", "June 6, 1944",
+                    # Record 4
+                    "Winston Churchill", "Yalta", "Yalta Conference", "Allied Powers", "February 1945",
+                    # Record 5
+                    "Harry S. Truman", "Potsdam", "Potsdam Conference", "Allied Powers", "July 1945",
+                    # Record 6
+                    "Douglas MacArthur", "Tokyo Bay", "Japanese Surrender", "United States Military", "September 2, 1945"
+                ],
+                [
+                    # Record 1 - Pride and Prejudice
+                    "Elizabeth Bennet", "Longbourn", "First Ball", "", "1811",
+                    # Record 2
+                    "Mr. Darcy", "Pemberley", "First Ball", "", "1811",
+                    # Record 3
+                    "Jane Bennet", "Netherfield", "Dinner Party", "", "1811",
+                    # Record 4
+                    "Mr. Bingley", "Netherfield", "Dinner Party", "", "1811",
+                    # Record 5
+                    "Elizabeth Bennet", "Rosings Park", "Easter Visit", "", "1812",
+                    # Record 6
+                    "Mr. Darcy", "Rosings Park", "Easter Visit", "", "1812"
+                ]
+            ],
+            inputs=entity_inputs,
+            label="Examples"
+        )
+        
+        # Add custom CSS to match NER tool styling
+        gr.HTML("""
+        <style>
+            /* Make the Examples label text black */
+            .gradio-examples-label {
+                color: black !important;
+            }
+            h4.examples-label, .examples-label {
+                color: black !important;
+            }
+            #examples-heading + div label,
+            #examples-heading + div .label-text {
+                color: black !important;
+            }
+        </style>
+        """)
+        
+        # Wire up the interface
+        # Collect entities button
+        collect_btn.click(
+            fn=collect_entities_from_records,
+            inputs=entity_inputs,
+            outputs=[
+                entity_summary,
+                relationship_section
+            ] + relationship_inputs[::3] + relationship_inputs[2::3]  # Update source and target dropdowns
+        )
+        
+        # Generate graph button
+        all_inputs = entity_inputs + relationship_inputs + [layout_type]
+        generate_btn.click(
+            fn=generate_network_graph,
+            inputs=all_inputs,
+            outputs=[network_plot, network_stats]
+        )
+        
+        # Information footer
+        gr.HTML("""
+        <hr style="margin-top: 40px; margin-bottom: 20px;">
+        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 8px; margin-top: 20px;">
+            <h4 style="margin-top: 0;">ℹ️ About This Tool</h4>
+            <p style="font-size: 14px; line-height: 1.8;">
+                This tool demonstrates how <strong>Named Entity Recognition (NER)</strong> can be combined with 
+                <strong>network analysis</strong> to visualize relationships in text data. In real-world applications,
+                entities would be automatically extracted from text using NER models, and relationships could be 
+                identified through co-occurrence analysis, dependency parsing, or machine learning.
+            </p>
+            <p style="font-size: 14px; line-height: 1.8; margin-bottom: 0;">
+                <strong>Built with:</strong> Gradio, NetworkX, and Plotly | 
+                <strong>Graph Layouts:</strong> Spring (force-directed), Circular, Kamada-Kawai, Shell
+            </p>
+        </div>
+        
+        <br> 
+        <hr style="margin-top: 40px; margin-bottom: 20px;">
+        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 8px; margin-top: 20px; text-align: center;">
+            <p style="font-size: 14px; line-height: 1.8; margin: 0;">
+                This <strong>Basic Networks Explorer</strong> was created as part of a Bodleian Libraries Oxford Sassoon Research Fellowship.
+                </a>
+                funded research project:<br>
+                <em>Extracting Keywords from Crowdsourced Collections</em>.
+            </p><br><br> 
+            <p style="font-size: 14px; line-height: 1.8; margin: 0;">
+                The code for this tool was built with the aid of Claude Sonnet 4.5.
+            </p>
+        </div>
+        """)
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()