Update app.py

app.py

@@ -1,86 +1,201 @@
 import streamlit as st
 import requests
 import pandas as pd
-
-# --- API Configuration ---
-API_URL = "https://adrienbrdne-fastapi-kig.hf.space/"
-ENDPOINT = f"{API_URL}/generate-key-issues" # API endpoint name remains unchanged
+import google.generativeai as genai
+import os # To potentially use environment variables for API key
+
+# --- Configuration ---
+# API Endpoint for initial key issues
+KEY_ISSUES_API_URL = "https://adrienbrdne-fastapi-kig.hf.space/"
+KEY_ISSUES_ENDPOINT = f"{KEY_ISSUES_API_URL}/generate-key-issues"
+
+# Gemini Model Configuration
+GEMINI_MODEL_NAME = "gemini-2.5-flash-preview-04-17"
+
+# --- Helper Functions ---
+def call_key_issues_api(query):
+    """Calls the first API to get key issues."""
+    data = {"query": query}
+    try:
+        response = requests.post(KEY_ISSUES_ENDPOINT, json=data)
+        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error calling Key Issues API: {e}")
+        return None
+    except Exception as e:
+        st.error(f"An unexpected error occurred during Key Issues API call: {e}")
+        return None
+
+def call_gemini_api(api_key, title, description, technical_topic):
+    """Calls the Gemini API to generate a problematic."""
+    if not api_key:
+        st.error("Gemini API Key is missing. Please enter it above.")
+        return None
+
+    try:
+        # Configure the Gemini client
+        genai.configure(api_key=api_key)
+
+        # Define the prompt using an f-string
+        prompt = f"""I want you to create a technical problematic using a key issue composed of a title and a detailed description.
+Here is the title of the key issue to deal with: <title>{title}</title>
+
+And here is the associated description: <description>{description}</description>
+
+This key issue is part of the following technical topic: <technical_topic>{technical_topic}</technical_topic>
+
+The problematic must be in interrogative form.
+As the output, I only want you to provide the problematic found, nothing else.
+
+Here are examples of problematics that you could create, it shows the level of specificity that you should aim for:
+
+Example 1: 'How can autonomous, policy-driven security decisions be achieved by distributed network elements in a telecommunication network without continuous central authority interaction, whilst ensuring overall network security objectives?'
+Example 2: 'How can secure communication between network elements and the confidentiality of network-related information (network element identities, topology) be guaranteed in 6G networks against unauthorized disclosure?'
+Example 3: 'How can secure access to and communication with network elements be achieved in a 6G network, considering the heterogeneous and dynamic nature of network elements and the evolving landscape of cyber threats?'
+Example 4: 'How can telecommunication systems guarantee long-term security against quantum attacks, considering the complexity and heterogeneity of current and future network architectures and services?'
+
+As far as possible, avoid using acronyms in the problematic.
+Try to be about the same length as the examples if possible."""
+
+        # Create the model instance
+        model = genai.GenerativeModel(GEMINI_MODEL_NAME)
+
+        # Generate content
+        # Note: The config part from the original snippet isn't directly used here,
+        # plain text is the default for generate_content with text prompts.
+        response = model.generate_content(prompt)
+
+        # Check for safety ratings or blocks if necessary (optional)
+        # if response.prompt_feedback.block_reason:
+        #     st.error(f"Content generation blocked: {response.prompt_feedback.block_reason}")
+        #     return None
+
+        return response.text
+
+    except Exception as e:
+        st.error(f"Error calling Gemini API: {e}")
+        return None
 
 # --- Streamlit Interface ---
 st.set_page_config(page_title="Problematic Generator", layout="wide")
 st.title("Generate Problematics from Query")
 
-# Input field for the user query
-user_query = st.text_input(
-    "Enter your query here:",
-    placeholder="Example: deploying edge computing for real-time AI-driven traffic management systems in smart cities"
+# --- Session State Initialization ---
+# Use session state to store data across reruns
+if 'key_issues_df' not in st.session_state:
+    st.session_state.key_issues_df = None
+if 'original_query' not in st.session_state:
+    st.session_state.original_query = ""
+if 'generated_problematic' not in st.session_state:
+    st.session_state.generated_problematic = None
+if 'selected_index' not in st.session_state:
+    st.session_state.selected_index = 0 # Default to first index
+
+# --- API Key Input ---
+st.sidebar.header("API Configuration")
+# Try getting key from environment first, then fallback to input
+default_gemini_key = os.environ.get("GEMINI_API_KEY", "")
+gemini_api_key = st.sidebar.text_input(
+    "Enter your Gemini API Key:",
+    type="password",
+    value=default_gemini_key, # Pre-fill if found in env var
+    help="You can get your API key from Google AI Studio."
 )
 
-# Button to submit the query
-if st.button("Generate Problematics"):
-    if user_query:  # Check if the user entered something
-        st.info(f"Sending query to API: {ENDPOINT}")
-        st.write(f"Query: \"{user_query}\"")
-
-        # Prepare data for the POST request
-        data = {"query": user_query}
-
-        try:
-            # Show a loading spinner during the API call
-            with st.spinner("Calling API to generate problematics..."):
-                response = requests.post(ENDPOINT, json=data) # Added a timeout
-
-            # Check the response status
-            if response.status_code == 200:
-                st.success("Response received successfully!")
-                result = response.json()
-
-                # Check if 'key_issues' key exists and is a list
-                if 'key_issues' in result and isinstance(result['key_issues'], list):
-                    # Convert the 'key_issues' list to a Pandas DataFrame
-                    df = pd.DataFrame(result['key_issues'])
-
-                    # Remove the 'id' column if it exists
-                    if 'id' in df.columns:
-                        df_display = df.drop(columns=['id'])
-                    else:
-                        st.warning("Column 'id' was not found in the received data.")
-                        df_display = df
-
-                    # Display the DataFrame
-                    st.subheader("Generated Problematics (DataFrame):")
-                    st.dataframe(df_display, use_container_width=True) # Display dataframe with full container width
-
-                    # Optional: Display raw JSON response for verification
-                    # st.subheader("Raw JSON Response Received:")
-                    # st.json(result)
+# --- Step 1: Get Key Issues ---
+st.header("Step 1: Generate Key Issues")
+user_query_input = st.text_input(
+    "Enter your technical topic/query:",
+    placeholder="Example: deploying edge computing for real-time AI-driven traffic management systems in smart cities",
+    key="query_input_key" # Unique key for the input widget
+)
 
+if st.button("Generate Key Issues", key="generate_issues_button"):
+    # Clear previous results when generating new issues
+    st.session_state.key_issues_df = None
+    st.session_state.generated_problematic = None
+    st.session_state.original_query = ""
+    st.session_state.selected_index = 0
+
+    if user_query_input:
+        st.session_state.original_query = user_query_input # Store the query
+        st.info(f"Sending query to Key Issues API: {KEY_ISSUES_ENDPOINT}")
+        with st.spinner("Calling API to generate key issues..."):
+            result = call_key_issues_api(user_query_input)
+
+        if result:
+            if 'key_issues' in result and isinstance(result['key_issues'], list) and result['key_issues']:
+                st.success("Key Issues received successfully!")
+                temp_df = pd.DataFrame(result['key_issues'])
+                # Ensure 'title' and 'description' columns exist
+                if 'title' in temp_df.columns and 'description' in temp_df.columns:
+                     # Select and reorder necessary columns, reset index for selection
+                    st.session_state.key_issues_df = temp_df
                 else:
-                    st.error("API response does not contain the expected 'key_issues' key or it is not a list.")
-                    st.json(result) # Display the received response for debugging
-
+                    st.error("API response is missing 'title' or 'description' columns in 'key_issues'.")
+                    st.json(result) # Show response for debugging
+            else:
+                st.error("API response does not contain a valid 'key_issues' list.")
+                st.json(result) # Show response for debugging
+    else:
+        st.warning("Please enter a query before generating key issues.")
+
+# --- Step 2: Display DataFrame and Select Issue ---
+if st.session_state.key_issues_df is not None:
+    st.subheader("Generated Key Issues:")
+    st.dataframe(st.session_state.key_issues_df, use_container_width=True)
+
+    st.header("Step 2: Select a Key Issue and Generate Problematic")
+
+    max_index = len(st.session_state.key_issues_df) - 1
+    if max_index >= 0: # Check if DataFrame is not empty
+        selected_index = st.number_input(
+            f"Select the index of the key issue to use (0 to {max_index}):",
+            min_value=0,
+            max_value=max_index,
+            value=st.session_state.selected_index, # Use session state value
+            step=1,
+            key="index_selector"
+        )
+        st.session_state.selected_index = selected_index # Update session state
+
+        # --- Step 3: Call Gemini API ---
+        if st.button("Generate Problematic for Selected Index", key="generate_problematic_button"):
+            st.session_state.generated_problematic = None # Clear previous problematic
+            if not gemini_api_key:
+                st.error("Please enter your Gemini API Key in the sidebar.")
             else:
-                # Display an error if status is not 200
-                st.error(f"API Call Error: Status {response.status_code}")
                 try:
-                    # Try to display the API error message if it's JSON
-                    error_details = response.json()
-                    st.json(error_details)
-                except requests.exceptions.JSONDecodeError:
-                    # Otherwise, display the raw text response
-                    st.text(response.text)
-
-        except requests.exceptions.RequestException as e:
-            # Handle connection or timeout errors
-            st.error(f"API Connection Error: {e}")
-        except Exception as e:
-            # Handle any other unexpected errors
-            st.error(f"An unexpected error occurred: {e}")
-
+                    # Retrieve selected row data
+                    selected_row = st.session_state.key_issues_df.loc[st.session_state.selected_index]
+                    title = selected_row['title']
+                    description = selected_row['description']
+                    technical_topic = st.session_state.original_query # Use the stored original query
+
+                    st.info(f"Generating problematic for index {st.session_state.selected_index} using Gemini...")
+                    with st.spinner("Calling Gemini API..."):
+                        problematic_text = call_gemini_api(gemini_api_key, title, description, technical_topic)
+
+                    if problematic_text:
+                        st.session_state.generated_problematic = problematic_text
+                    # Error messages are handled within call_gemini_api
+
+                except KeyError:
+                    st.error(f"Could not find data for index {st.session_state.selected_index}. Please check the DataFrame.")
+                except Exception as e:
+                    st.error(f"An unexpected error occurred during problematic generation: {e}")
     else:
-        # Message if the user clicks the button without entering a query
-        st.warning("Please enter a query before generating.")
+        st.warning("The generated key issues list is empty.")
+
+
+# --- Step 4: Display Generated Problematic ---
+if st.session_state.generated_problematic:
+    st.subheader("Generated Problematic:")
+    st.markdown(f"> {st.session_state.generated_problematic}") # Display as a blockquote
+    # Or use st.text_area for easy copying:
+    # st.text_area("Generated Problematic:", st.session_state.generated_problematic, height=150)
 
-# Initial instructions
-else:
-    st.info("Enter a query in the field above and click 'Generate Problematics' to query the API.")
+# --- Initial Instructions ---
+if st.session_state.key_issues_df is None and not user_query_input:
+     st.info("Enter a technical topic/query above and click 'Generate Key Issues' to start.")