Update app.py

app.py

@@ -5,6 +5,10 @@ from io import StringIO
 import folium
 from streamlit_folium import st_folium
 import unicodedata
+import networkx as nx
+import plotly.express as px
+import plotly.graph_objects as go
+
 
 # -------------------------------
 # Authority Lists as XML Strings
@@ -201,6 +205,8 @@ def parse_inscriptions(xml_content):
         origin = places_dict.get(origin_id, {}).get('Name', origin_id)
         origin_geonames_link = places_dict.get(origin_id, {}).get('GeoNames Link', "#")
         origin_pleiades_link = places_dict.get(origin_id, {}).get('Pleiades Link', "#")
+        latitude = places_dict.get(origin_id, {}).get('Latitude', None)
+        longitude = places_dict.get(origin_id, {}).get('Longitude', None)
         
         # Handle Material with or without 'ref' attribute
         material_elem = inscription.find('Material')
@@ -225,7 +231,25 @@ def parse_inscriptions(xml_content):
         
         language = inscription.find('Language').text if inscription.find('Language') is not None else "N/A"
         
-        text = "".join(inscription.find('Text').itertext()).strip() if inscription.find('Text') is not None else "N/A"
+        # Extract Titles from the Text element
+        text_elem = inscription.find('Text')
+        titles_used = []
+        titles_descriptions = []
+        if text_elem is not None:
+            for title in text_elem.findall('.//title'):
+                title_ref = title.get('ref')
+                if title_ref and title_ref in titles_dict:
+                    title_info = titles_dict[title_ref]
+                    title_name = title_info['Name']
+                    title_description = title_info['Description']
+                    titles_used.append(title_name)
+                    titles_descriptions.append(title_description)
+                elif title.text:
+                    title_text = title.text.strip()
+                    titles_used.append(title_text)
+                    titles_descriptions.append("No description available.")
+        
+        text = "".join(text_elem.itertext()).strip() if text_elem is not None else "N/A"
         
         dating = inscription.find('Dating').text if inscription.find('Dating') is not None else "N/A"
         images = inscription.find('Images').text if inscription.find('Images') is not None else "N/A"
@@ -240,9 +264,13 @@ def parse_inscriptions(xml_content):
             'Origin': origin,
             'GeoNames Link': origin_geonames_link,
             'Pleiades Link': origin_pleiades_link,
+            'Latitude': latitude,
+            'Longitude': longitude,
             'Material_ID': material_id,
             'Material': material,
             'Language': language,
+            'Titles': ", ".join(titles_used) if titles_used else "N/A",
+            'Title_Descriptions': "; ".join(titles_descriptions) if titles_descriptions else "N/A",
             'Text': text,
             'Dating': dating,
             'Images': images,
@@ -709,11 +737,14 @@ with tabs[4]:
             place_desc = places_dict.get(row['Origin_ID'], {}).get('Description', "No description available.")
             st.markdown(f"**Place Description**: {place_desc}")
 
+# -------------------------------
+# Authority Connections Tab
+# -------------------------------
 with tabs[5]:
     st.subheader("Authority Connections")
     
     # Define Authority Types
-    authority_types = ["Material", "Place"]  # Extend this list if you include Titles in the future
+    authority_types = ["Material", "Place", "Title"]  # Added "Title"
     
     # Select Authority Type
     selected_authority_type = st.selectbox("Select Authority Type", authority_types)
@@ -742,10 +773,9 @@ with tabs[5]:
                 # Display inscriptions in a table
                 st.dataframe(connected_inscriptions[['Number', 'Publisher', 'Origin', 'Language', 'Dating', 'Encoder']])
                 
-                # Optional: Visualization - Number of Inscriptions per Year (Dating)
+                # **Plotly Visualization: Inscriptions Over Time**
                 st.markdown("#### Inscriptions Over Time")
-                # Assuming 'Dating' is in a format that can be processed (e.g., single year or range)
-                # For simplicity, we'll extract the starting year
+                # Assuming 'Dating' is in a format that can be processed (e.g., "155 to 155")
                 def extract_start_year(dating):
                     if isinstance(dating, str):
                         parts = dating.split('to')
@@ -757,38 +787,87 @@ with tabs[5]:
                 
                 connected_inscriptions['Start_Year'] = connected_inscriptions['Dating'].apply(extract_start_year)
                 year_counts = connected_inscriptions['Start_Year'].dropna().astype(int).value_counts().sort_index()
+                year_counts = year_counts.reset_index()
+                year_counts.columns = ['Year', 'Count']
                 
-                fig, ax = plt.subplots()
-                ax.bar(year_counts.index, year_counts.values, color='skyblue')
-                ax.set_xlabel('Year')
-                ax.set_ylabel('Number of Inscriptions')
-                ax.set_title(f'Number of Inscriptions Using {selected_material} Over Time')
-                st.pyplot(fig)
+                fig_bar = px.bar(
+                    year_counts,
+                    x='Year',
+                    y='Count',
+                    labels={'Count': 'Number of Inscriptions'},
+                    title=f'Number of Inscriptions Using {selected_material} Over Time',
+                    template='plotly_white'
+                )
+                st.plotly_chart(fig_bar, use_container_width=True)
                 
-                # Optional: Network Graph
+                # **Plotly Visualization: Network Graph of Inscriptions and Materials**
                 st.markdown("#### Network Graph of Inscriptions and Materials")
+                
+                # Create a network graph using Plotly
                 G = nx.Graph()
-
+                
                 # Add nodes
                 G.add_node(selected_material, type='Material')
                 for _, row in connected_inscriptions.iterrows():
                     inscription_node = f"Inscription {row['Number']}"
                     G.add_node(inscription_node, type='Inscription')
                     G.add_edge(selected_material, inscription_node)
-
-                # Define node colors based on type
-                color_map = []
-                for node in G:
-                    if G.nodes[node]['type'] == 'Material':
-                        color_map.append('lightblue')
-                    else:
-                        color_map.append('lightgreen')
-
-                # Draw the graph
-                plt.figure(figsize=(8, 6))
-                nx.draw(G, with_labels=True, node_color=color_map, node_size=1500, font_size=10, font_weight='bold')
-                st.pyplot(plt)
-                plt.close()
+                
+                # Generate positions for the nodes
+                pos = nx.spring_layout(G, k=0.5, iterations=50)
+                
+                edge_x = []
+                edge_y = []
+                for edge in G.edges():
+                    x0, y0 = pos[edge[0]]
+                    x1, y1 = pos[edge[1]]
+                    edge_x.extend([x0, x1, None])
+                    edge_y.extend([y0, y1, None])
+                
+                edge_trace = go.Scatter(
+                    x=edge_x, y=edge_y,
+                    line=dict(width=1, color='#888'),
+                    hoverinfo='none',
+                    mode='lines'
+                )
+                
+                node_x = []
+                node_y = []
+                for node in G.nodes():
+                    x, y = pos[node]
+                    node_x.append(x)
+                    node_y.append(y)
+                
+                node_trace = go.Scatter(
+                    x=node_x, y=node_y,
+                    mode='markers+text',
+                    text=[node for node in G.nodes()],
+                    textposition="bottom center",
+                    hoverinfo='text',
+                    marker=dict(
+                        showscale=False,
+                        color=['lightblue' if G.nodes[node]['type'] == 'Material' else 'lightgreen' for node in G.nodes()],
+                        size=20,
+                        line_width=2
+                    )
+                )
+                
+                fig_network = go.Figure(data=[edge_trace, node_trace],
+                                         layout=go.Layout(
+                                             title=f"Network Graph: {selected_material} and Connected Inscriptions",
+                                             titlefont_size=16,
+                                             showlegend=False,
+                                             hovermode='closest',
+                                             margin=dict(b=20,l=5,r=5,t=40),
+                                             annotations=[ dict(
+                                                 text="",
+                                                 showarrow=False,
+                                                 xref="paper", yref="paper") ],
+                                             xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                                             yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))
+                                         )
+                
+                st.plotly_chart(fig_network, use_container_width=True)
                 
             else:
                 st.info("No inscriptions found for the selected material.")
@@ -816,53 +895,224 @@ with tabs[5]:
                 # Display inscriptions in a table
                 st.dataframe(connected_inscriptions[['Number', 'Publisher', 'Material', 'Language', 'Dating', 'Encoder']])
                 
-                # Optional: Visualization - Inscriptions Geographical Distribution
+                # **Plotly Visualization: Geographical Distribution of Inscriptions**
                 st.markdown("#### Geographical Distribution of Inscriptions")
                 map_df = connected_inscriptions[['Latitude', 'Longitude', 'Number']]
                 map_df = map_df.dropna(subset=['Latitude', 'Longitude'])
                 
                 if not map_df.empty:
-                    # Create a Folium map centered on the selected place
-                    selected_place_coords = [places_dict[place_id]['Latitude'], places_dict[place_id]['Longitude']]
-                    folium_map = folium.Map(location=selected_place_coords, zoom_start=8)
-                    
-                    for _, row in map_df.iterrows():
-                        folium.Marker(
-                            location=[row['Latitude'], row['Longitude']],
-                            popup=f"Inscription {row['Number']}"
-                        ).add_to(folium_map)
-                    
-                    st_folium(folium_map, width=700, height=500)
+                    fig_map = px.scatter_geo(
+                        map_df,
+                        lat='Latitude',
+                        lon='Longitude',
+                        hover_name='Number',
+                        title=f'Geographical Distribution of Inscriptions from {selected_place}',
+                        template='plotly_white'
+                    )
+                    fig_map.update_layout(
+                        geo=dict(
+                            scope='world',
+                            projection_type='natural earth',
+                            showland=True,
+                            landcolor='lightgray',
+                            showcountries=True,
+                        )
+                    )
+                    st.plotly_chart(fig_map, use_container_width=True)
                 else:
                     st.info("No geographical data available for these inscriptions.")
                 
-                # Optional: Network Graph
+                # **Plotly Visualization: Network Graph of Inscriptions and Places**
                 st.markdown("#### Network Graph of Inscriptions and Places")
                 G = nx.Graph()
-
+                
                 # Add nodes
                 G.add_node(selected_place, type='Place')
                 for _, row in connected_inscriptions.iterrows():
                     inscription_node = f"Inscription {row['Number']}"
                     G.add_node(inscription_node, type='Inscription')
                     G.add_edge(selected_place, inscription_node)
-
-                # Define node colors based on type
-                color_map = []
-                for node in G:
-                    if G.nodes[node]['type'] == 'Place':
-                        color_map.append('salmon')
-                    else:
-                        color_map.append('lightgreen')
-
-                # Draw the graph
-                plt.figure(figsize=(8, 6))
-                nx.draw(G, with_labels=True, node_color=color_map, node_size=1500, font_size=10, font_weight='bold')
-                st.pyplot(plt)
-                plt.close()
+                
+                # Generate positions for the nodes
+                pos = nx.spring_layout(G, k=0.5, iterations=50)
+                
+                edge_x = []
+                edge_y = []
+                for edge in G.edges():
+                    x0, y0 = pos[edge[0]]
+                    x1, y1 = pos[edge[1]]
+                    edge_x.extend([x0, x1, None])
+                    edge_y.extend([y0, y1, None])
+                
+                edge_trace = go.Scatter(
+                    x=edge_x, y=edge_y,
+                    line=dict(width=1, color='#888'),
+                    hoverinfo='none',
+                    mode='lines'
+                )
+                
+                node_x = []
+                node_y = []
+                for node in G.nodes():
+                    x, y = pos[node]
+                    node_x.append(x)
+                    node_y.append(y)
+                
+                node_trace = go.Scatter(
+                    x=node_x, y=node_y,
+                    mode='markers+text',
+                    text=[node for node in G.nodes()],
+                    textposition="bottom center",
+                    hoverinfo='text',
+                    marker=dict(
+                        showscale=False,
+                        color=['salmon' if G.nodes[node]['type'] == 'Place' else 'lightgreen' for node in G.nodes()],
+                        size=20,
+                        line_width=2
+                    )
+                )
+                
+                fig_network = go.Figure(data=[edge_trace, node_trace],
+                                         layout=go.Layout(
+                                             title=f"Network Graph: {selected_place} and Connected Inscriptions",
+                                             titlefont_size=16,
+                                             showlegend=False,
+                                             hovermode='closest',
+                                             margin=dict(b=20,l=5,r=5,t=40),
+                                             annotations=[ dict(
+                                                 text="",
+                                                 showarrow=False,
+                                                 xref="paper", yref="paper") ],
+                                             xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                                             yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))
+                                         )
+                
+                st.plotly_chart(fig_network, use_container_width=True)
                 
             else:
                 st.info("No inscriptions found for the selected place.")
+    
+    elif selected_authority_type == "Title":
+        # List all titles from titles_dict
+        title_names = [title['Name'] for title in titles_dict.values()]
+        selected_title = st.selectbox("Select Title", sorted(title_names))
+        
+        # Find the title ID based on the selected name
+        title_id = None
+        for id_, title in titles_dict.items():
+            if title['Name'] == selected_title:
+                title_id = id_
+                break
+        
+        if title_id:
+            # Filter inscriptions that reference this title
+            # Assuming 'Titles' column contains comma-separated titles
+            connected_inscriptions = df[df['Titles'].str.contains(selected_title, case=False, na=False)]
+            
+            st.markdown(f"### Inscriptions referencing **{selected_title}**")
+            st.write(f"**Total Inscriptions:** {len(connected_inscriptions)}")
+            
+            if not connected_inscriptions.empty:
+                # Display inscriptions in a table
+                st.dataframe(connected_inscriptions[['Number', 'Publisher', 'Origin', 'Material', 'Language', 'Dating', 'Encoder']])
+                
+                # **Plotly Visualization: Inscriptions Referencing the Title Over Time**
+                st.markdown("#### Inscriptions Referencing the Title Over Time")
+                def extract_start_year(dating):
+                    if isinstance(dating, str):
+                        parts = dating.split('to')
+                        try:
+                            return int(parts[0].strip())
+                        except:
+                            return None
+                    return None
+                
+                connected_inscriptions['Start_Year'] = connected_inscriptions['Dating'].apply(extract_start_year)
+                year_counts = connected_inscriptions['Start_Year'].dropna().astype(int).value_counts().sort_index()
+                year_counts = year_counts.reset_index()
+                year_counts.columns = ['Year', 'Count']
+                
+                fig_bar = px.bar(
+                    year_counts,
+                    x='Year',
+                    y='Count',
+                    labels={'Count': 'Number of Inscriptions'},
+                    title=f'Number of Inscriptions Referencing "{selected_title}" Over Time',
+                    template='plotly_white'
+                )
+                st.plotly_chart(fig_bar, use_container_width=True)
+                
+                # **Plotly Visualization: Network Graph of Inscriptions and Titles**
+                st.markdown("#### Network Graph of Inscriptions and Titles")
+                
+                # Create a network graph using Plotly
+                G = nx.Graph()
+                
+                # Add nodes
+                G.add_node(selected_title, type='Title')
+                for _, row in connected_inscriptions.iterrows():
+                    inscription_node = f"Inscription {row['Number']}"
+                    G.add_node(inscription_node, type='Inscription')
+                    G.add_edge(selected_title, inscription_node)
+                
+                # Generate positions for the nodes
+                pos = nx.spring_layout(G, k=0.5, iterations=50)
+                
+                edge_x = []
+                edge_y = []
+                for edge in G.edges():
+                    x0, y0 = pos[edge[0]]
+                    x1, y1 = pos[edge[1]]
+                    edge_x.extend([x0, x1, None])
+                    edge_y.extend([y0, y1, None])
+                
+                edge_trace = go.Scatter(
+                    x=edge_x, y=edge_y,
+                    line=dict(width=1, color='#888'),
+                    hoverinfo='none',
+                    mode='lines'
+                )
+                
+                node_x = []
+                node_y = []
+                for node in G.nodes():
+                    x, y = pos[node]
+                    node_x.append(x)
+                    node_y.append(y)
+                
+                node_trace = go.Scatter(
+                    x=node_x, y=node_y,
+                    mode='markers+text',
+                    text=[node for node in G.nodes()],
+                    textposition="bottom center",
+                    hoverinfo='text',
+                    marker=dict(
+                        showscale=False,
+                        color=['orange' if G.nodes[node]['type'] == 'Title' else 'lightgreen' for node in G.nodes()],
+                        size=20,
+                        line_width=2
+                    )
+                )
+                
+                fig_network = go.Figure(data=[edge_trace, node_trace],
+                                         layout=go.Layout(
+                                             title=f"Network Graph: {selected_title} and Connected Inscriptions",
+                                             titlefont_size=16,
+                                             showlegend=False,
+                                             hovermode='closest',
+                                             margin=dict(b=20,l=5,r=5,t=40),
+                                             annotations=[ dict(
+                                                 text="",
+                                                 showarrow=False,
+                                                 xref="paper", yref="paper") ],
+                                             xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                                             yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))
+                                         )
+                
+                st.plotly_chart(fig_network, use_container_width=True)
+                
+            else:
+                st.info("No inscriptions found referencing the selected title.")
 
 
 # -------------------------------