minor

paper_chat_tab.py

@@ -73,7 +73,6 @@ def fetch_paper_info_neurips(paper_id):
     else:
         abstract = 'Abstract not found'
 
-    # Construct preamble
     link = f"https://openreview.net/forum?id={paper_id}"
     return title, author_list, f"**Abstract:** {abstract}\n\n[View on OpenReview]({link})"
 
@@ -110,12 +109,9 @@ def fetch_paper_content_arxiv(paper_id):
 
 
 def fetch_paper_info_paperpage(paper_id_value):
-    # Extract paper_id from paper_page link or input
     def extract_paper_id(input_string):
-        # Already in correct form?
         if re.fullmatch(r'\d+\.\d+', input_string.strip()):
             return input_string.strip()
-        # If URL
         match = re.search(r'https://huggingface\.co/papers/(\d+\.\d+)', input_string)
         if match:
             return match.group(1)
@@ -141,7 +137,6 @@ def fetch_paper_info_paperpage(paper_id_value):
 
 
 def fetch_paper_content_paperpage(paper_id_value):
-    # Extract paper_id
     def extract_paper_id(input_string):
         if re.fullmatch(r'\d+\.\d+', input_string.strip()):
             return input_string.strip()
@@ -155,7 +150,6 @@ def fetch_paper_content_paperpage(paper_id_value):
     return text
 
 
-# Dictionary for paper sources
 PAPER_SOURCES = {
     "neurips": {
         "fetch_info": fetch_paper_info_neurips,
@@ -170,16 +164,13 @@ PAPER_SOURCES = {
 
 def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_token_input, default_type,
                           provider_max_total_tokens):
-    # Define the function to handle the chat
     def get_fn(message, history, paper_content_value, hf_token_value, provider_name_value, model_name_value,
                max_total_tokens):
         provider_info = PROVIDERS[provider_name_value]
         endpoint = provider_info['endpoint']
         api_key_env_var = provider_info['api_key_env_var']
-        models = provider_info['models']
         max_total_tokens = int(max_total_tokens)
 
-        # Load tokenizer
         tokenizer_key = f"{provider_name_value}_{model_name_value}"
         if tokenizer_key not in tokenizer_cache:
             tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B-Instruct",
@@ -188,44 +179,36 @@ def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_t
         else:
             tokenizer = tokenizer_cache[tokenizer_key]
 
-        # Include the paper content as context
         if paper_content_value:
             context = f"The discussion is about the following paper:\n{paper_content_value}\n\n"
         else:
             context = ""
 
-        # Tokenize the context
         context_tokens = tokenizer.encode(context)
         context_token_length = len(context_tokens)
 
-        # Prepare the messages without context
         messages = []
         message_tokens_list = []
-        total_tokens = context_token_length  # Start with context tokens
+        total_tokens = context_token_length
 
         for user_msg, assistant_msg in history:
-            # Tokenize user message
             user_tokens = tokenizer.encode(user_msg)
             messages.append({"role": "user", "content": user_msg})
             message_tokens_list.append(len(user_tokens))
             total_tokens += len(user_tokens)
 
-            # Tokenize assistant message
             if assistant_msg:
                 assistant_tokens = tokenizer.encode(assistant_msg)
                 messages.append({"role": "assistant", "content": assistant_msg})
                 message_tokens_list.append(len(assistant_tokens))
                 total_tokens += len(assistant_tokens)
 
-        # Tokenize the new user message
         message_tokens = tokenizer.encode(message)
         messages.append({"role": "user", "content": message})
         message_tokens_list.append(len(message_tokens))
         total_tokens += len(message_tokens)
 
-        # Check if total tokens exceed the maximum allowed tokens
         if total_tokens > max_total_tokens:
-            # Attempt to truncate context
             available_tokens = max_total_tokens - (total_tokens - context_token_length)
             if available_tokens > 0:
                 truncated_context_tokens = context_tokens[:available_tokens]
@@ -237,24 +220,20 @@ def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_t
                 total_tokens -= context_token_length
                 context_token_length = 0
 
-        # Truncate message history if needed
         while total_tokens > max_total_tokens and len(messages) > 1:
             removed_message = messages.pop(0)
             removed_tokens = message_tokens_list.pop(0)
             total_tokens -= removed_tokens
 
-        # Rebuild the final messages
         final_messages = []
         if context:
             final_messages.append({"role": "system", "content": f"{context}"})
         final_messages.extend(messages)
 
-        # Use the provider's API key
         api_key = hf_token_value or os.environ.get(api_key_env_var)
         if not api_key:
             raise ValueError("API token is not provided.")
 
-        # Initialize the OpenAI client
         client = OpenAI(
             base_url=endpoint,
             api_key=api_key,
@@ -289,6 +268,7 @@ def create_chat_interface(provider_dropdown, model_dropdown, paper_content, hf_t
 
 
 def paper_chat_tab(paper_id, paper_from, paper_central_df):
+    # First row with two columns
     with gr.Row():
         # Left column: Paper selection and display
         with gr.Column(scale=1):
@@ -316,10 +296,10 @@ def paper_chat_tab(paper_id, paper_from, paper_central_df):
             )
             select_paper_button = gr.Button("Load this paper")
 
-            # Paper info display - styled card
+            # Paper info display
             content = gr.HTML(value="", elem_id="paper_info_card")
 
-        # Right column: Provider and model selection + chat
+        # Right column: Provider and model selection
         with gr.Column(scale=1, visible=False) as provider_section:
             gr.Markdown("### LLM Provider and Model")
             provider_names = list(PROVIDERS.keys())
@@ -354,7 +334,10 @@ def paper_chat_tab(paper_id, paper_from, paper_central_df):
 
             paper_content = gr.State()
 
-            # Create chat interface
+    # Now a new row, full width, for the chat
+    with gr.Row(visible=False) as chat_row:
+        with gr.Column():
+            # Create chat interface below the two columns
             chat_interface, chatbot = create_chat_interface(provider_dropdown, model_dropdown, paper_content,
                                                             hf_token_input, default_type, default_max_total_tokens)
 
@@ -385,7 +368,6 @@ def paper_chat_tab(paper_id, paper_from, paper_central_df):
     )
 
     def update_paper_info(paper_id_value, paper_from_value, selected_model, old_content):
-        # Use PAPER_SOURCES to fetch info
         source_info = PAPER_SOURCES.get(paper_from_value, {})
         fetch_info_fn = source_info.get("fetch_info")
         fetch_pdf_fn = source_info.get("fetch_pdf")
@@ -401,7 +383,6 @@ def paper_chat_tab(paper_id, paper_from, paper_central_df):
         if text is None:
             text = "Paper content could not be retrieved."
 
-        # Create a styled card for the paper info
         card_html = f"""
         <div style="border:1px solid #ccc; border-radius:6px; background:#f9f9f9; padding:15px; margin-bottom:10px;">
             <center><h3 style="margin-top:0; text-decoration:underline;">You are talking with:</h3></center>
@@ -414,7 +395,6 @@ def paper_chat_tab(paper_id, paper_from, paper_central_df):
         return gr.update(value=card_html), text, []
 
     def select_paper(paper_title):
-        # Find the corresponding paper_page from the title
         for t, ppage in paper_choices:
             if t == paper_title:
                 return ppage, "paper_page"
@@ -426,32 +406,34 @@ def paper_chat_tab(paper_id, paper_from, paper_central_df):
         outputs=[paper_id, paper_from]
     )
 
-    # After updating paper_id, we update paper info
     paper_id.change(
         fn=update_paper_info,
         inputs=[paper_id, paper_from, model_dropdown, content],
         outputs=[content, paper_content, chatbot]
     )
 
-    # Function to toggle visibility of the right column based on paper_id
     def toggle_provider_visibility(paper_id_value):
         if paper_id_value and paper_id_value.strip():
             return gr.update(visible=True)
         else:
             return gr.update(visible=False)
 
-    # Chain a then call to toggle visibility of the provider_section after paper info update
+    # Toggle provider section visibility
     paper_id.change(
         fn=toggle_provider_visibility,
         inputs=[paper_id],
         outputs=[provider_section]
     )
 
+    # Toggle chat row visibility
+    paper_id.change(
+        fn=toggle_provider_visibility,
+        inputs=[paper_id],
+        outputs=[chat_row]
+    )
+
 
 def main():
-    """
-    Launches the Gradio app.
-    """
     with gr.Blocks(css_paths="style.css") as demo:
         paper_id = gr.Textbox(label="Paper ID", value="")
         paper_from = gr.Radio(
@@ -460,9 +442,6 @@ def main():
             value="neurips"
         )
 
-        # Build the paper chat tab
-        dummy_calendar = gr.State(datetime.now().strftime("%Y-%m-%d"))
-
         class MockPaperCentral:
             def __init__(self):
                 import pandas as pd