With logging

app.py

@@ -1,5 +1,6 @@
 import os
 import json
+import uuid
 from datetime import datetime
 import gradio as gr
 import openai
@@ -9,30 +10,35 @@ from pathlib import Path
 log_dir = Path("usage_logs")
 log_dir.mkdir(exist_ok=True)
 
-def log_interaction(interaction_type, data):
-    """Log each interaction with timestamp"""
+OPENAI_TOKEN = os.getenv("openAI_TOKEN")
+
+def generate_session_id():
+    """Generate a unique session ID"""
+    return str(uuid.uuid4())[:8]
+
+def log_interaction(session_id, interaction_type, data):
+    """Log each interaction with timestamp and session ID"""
     timestamp = datetime.now().isoformat()
     log_entry = {
         "timestamp": timestamp,
+        "session_id": session_id,
         "interaction_type": interaction_type,
         "data": data
     }
     
-    # Use date as filename for easier analysis
     date_str = datetime.now().strftime("%Y-%m-%d")
     log_file = log_dir / f"usage_log_{date_str}.jsonl"
     
-    # Append to log file
     with open(log_file, "a") as f:
         json.dump(log_entry, f)
         f.write("\n")
 
-def generate_with_temperature(input_text, temperature):
+def generate_with_temperature(input_text, temperature, session_id):
     try:
-        # Log the attempt
-        log_interaction("temperature_generation", {
+        log_interaction(session_id, "temperature_generation", {
             "input_text": input_text,
-            "temperature": temperature
+            "temperature": temperature,
+            "type": "low" if temperature <= 0.4 else "high"
         })
         
         openai_client = openai.OpenAI(api_key=OPENAI_TOKEN)
@@ -54,8 +60,7 @@ def generate_with_temperature(input_text, temperature):
         return response.choices[0].message.content
     except Exception as e:
         error_msg = str(e)
-        # Log the error
-        log_interaction("error", {
+        log_interaction(session_id, "error", {
             "function": "generate_with_temperature",
             "error": error_msg,
             "input_text": input_text,
@@ -63,12 +68,12 @@ def generate_with_temperature(input_text, temperature):
         })
         return f"Error: {error_msg}"
 
-def generate_with_system_prompt(input_text, system_prompt):
+def generate_with_system_prompt(input_text, system_prompt, session_id):
     try:
-        # Log the attempt
-        log_interaction("system_prompt_generation", {
+        log_interaction(session_id, "system_prompt_generation", {
             "input_text": input_text,
-            "system_prompt": system_prompt
+            "system_prompt": system_prompt,
+            "timestamp_start": datetime.now().isoformat()
         })
         
         openai_client = openai.OpenAI(api_key=OPENAI_TOKEN)
@@ -81,10 +86,18 @@ def generate_with_system_prompt(input_text, system_prompt):
             temperature=0.7,
             max_tokens=300
         )
+        
+        # Log completion
+        log_interaction(session_id, "system_prompt_completion", {
+            "input_text": input_text,
+            "system_prompt": system_prompt,
+            "success": True
+        })
+        
         return response.choices[0].message.content
     except Exception as e:
         error_msg = str(e)
-        log_interaction("error", {
+        log_interaction(session_id, "error", {
             "function": "generate_with_system_prompt",
             "error": error_msg,
             "input_text": input_text,
@@ -92,12 +105,12 @@ def generate_with_system_prompt(input_text, system_prompt):
         })
         return f"Error: {error_msg}"
 
-def generate_with_examples(input_text, approach_type):
+def generate_with_examples(input_text, approach_type, session_id):
     try:
-        # Log the attempt
-        log_interaction("reasoning_approach_generation", {
+        log_interaction(session_id, "reasoning_approach_generation", {
             "input_text": input_text,
-            "approach_type": approach_type
+            "approach_type": approach_type,
+            "timestamp_start": datetime.now().isoformat()
         })
         
         openai_client = openai.OpenAI(api_key=OPENAI_TOKEN)
@@ -120,10 +133,18 @@ def generate_with_examples(input_text, approach_type):
             temperature=0.7,
             max_tokens=300
         )
+        
+        # Log completion
+        log_interaction(session_id, "reasoning_approach_completion", {
+            "input_text": input_text,
+            "approach_type": approach_type,
+            "success": True
+        })
+        
         return response.choices[0].message.content
     except Exception as e:
         error_msg = str(e)
-        log_interaction("error", {
+        log_interaction(session_id, "error", {
             "function": "generate_with_examples",
             "error": error_msg,
             "input_text": input_text,
@@ -131,15 +152,13 @@ def generate_with_examples(input_text, approach_type):
         })
         return f"Error: {error_msg}"
 
-# Tab selection tracking
-def on_tab_select(tab_name):
-    log_interaction("tab_selection", {"tab": tab_name})
-
 with gr.Blocks() as demo:
+    session_id = gr.State(lambda: generate_session_id())
+    
     gr.Markdown("# Language Models & Methods Lab Interface")
     
     with gr.Tabs() as tabs:
-        with gr.Tab("Temperature Effects", id="temperature_tab"):
+        with gr.Tab("Temperature Effects"):
             with gr.Row():
                 temp_input = gr.Textbox(
                     label="Enter your prompt",
@@ -158,7 +177,7 @@ with gr.Blocks() as demo:
                 focused_output = gr.Textbox(label="Focused Output (Low Temperature)", lines=5)
                 creative_output = gr.Textbox(label="Creative Output (High Temperature)", lines=5)
 
-        with gr.Tab("System Prompts", id="system_tab"):
+        with gr.Tab("System Prompts"):
             with gr.Row():
                 system_input = gr.Textbox(
                     label="Enter your prompt",
@@ -183,7 +202,7 @@ with gr.Blocks() as demo:
             with gr.Row():
                 system_output = gr.Textbox(label="Output", lines=5)
 
-        with gr.Tab("Reasoning Approaches", id="reasoning_tab"):
+        with gr.Tab("Reasoning Approaches"):
             with gr.Row():
                 shot_input = gr.Textbox(
                     label="Enter your task/question",
@@ -203,26 +222,34 @@ with gr.Blocks() as demo:
             with gr.Row():
                 shot_output = gr.Textbox(label="Output", lines=8)
 
-    # Event handlers with logging
+    # Event handlers with session logging
+    def handle_temperature_generation(input_text, temp1, temp2, session_id):
+        output1 = generate_with_temperature(input_text, temp1, session_id)
+        output2 = generate_with_temperature(input_text, temp2, session_id)
+        return [output1, output2]
+
     generate_temp.click(
-        lambda x, t1, t2: [generate_with_temperature(x, t1), generate_with_temperature(x, t2)],
-        inputs=[temp_input, temp_slider1, temp_slider2],
+        handle_temperature_generation,
+        inputs=[temp_input, temp_slider1, temp_slider2, session_id],
         outputs=[focused_output, creative_output]
     )
 
     generate_system.click(
         generate_with_system_prompt,
-        inputs=[system_input, system_prompt],
+        inputs=[system_input, system_prompt, session_id],
         outputs=system_output
     )
 
     generate_shot.click(
         generate_with_examples,
-        inputs=[shot_input, approach_type],
+        inputs=[shot_input, approach_type, session_id],
         outputs=shot_output
     )
 
     # Tab selection logging
-    tabs.select(lambda evt: on_tab_select(evt), None, None)
+    def on_tab_select(tab_name, session_id):
+        log_interaction(session_id, "tab_selection", {"tab": tab_name})
+
+    tabs.select(lambda evt, sid: on_tab_select(evt, sid), [None, session_id], None)
 
 demo.launch()