ONS4

app.py

@@ -25,82 +25,59 @@ def load_model(hf_token):
     """Load the model with the provided token"""
     global global_model, global_tokenizer, model_loaded, loaded_model_name
 
-    # Initially assume tabs should be hidden until successful load
-    initial_tabs_update = gr.Tabs.update(visible=False)
+    # --- FIX: Use gr.update() for visibility ---
+    initial_tabs_update = gr.update(visible=False) # Generic update targeted by outputs list
 
     if not hf_token:
         model_loaded = False
         loaded_model_name = "None"
-        return "⚠️ Please enter your Hugging Face token to use the model.", initial_tabs_update
+        return "⚠️ Please enter your Hugging Face token.", initial_tabs_update
 
     try:
-        # Try different model versions from smallest to largest
         model_options = [
-            "google/gemma-2b-it",
-            "google/gemma-7b-it",
-            "google/gemma-2b",
-            "google/gemma-7b",
-            "TinyLlama/TinyLlama-1.1B-Chat-v1.0" # Fallback
+            "google/gemma-2b-it", "google/gemma-7b-it",
+            "google/gemma-2b", "google/gemma-7b",
+            "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
         ]
-
-        print(f"Attempting to load models with token starting with: {hf_token[:5]}...")
+        print(f"Attempting loading with token: {hf_token[:5]}...")
         loaded_successfully = False
         for model_name in model_options:
             try:
-                print(f"\n--- Attempting to load model: {model_name} ---")
+                print(f"\n--- Attempting: {model_name} ---")
                 is_gemma = "gemma" in model_name.lower()
                 current_token = hf_token if is_gemma else None
-
                 print("Loading tokenizer...")
-                global_tokenizer = AutoTokenizer.from_pretrained(
-                    model_name,
-                    token=current_token
-                )
-                print("Tokenizer loaded successfully.")
-
-                print(f"Loading model {model_name}...")
+                global_tokenizer = AutoTokenizer.from_pretrained(model_name, token=current_token)
+                print("Loading model...")
                 global_model = AutoModelForCausalLM.from_pretrained(
-                    model_name,
-                    torch_dtype=torch.float16, # Using float16 for broader compatibility
-                    device_map="auto",
-                    token=current_token
+                    model_name, torch_dtype=torch.float16,
+                    device_map="auto", token=current_token
                 )
-                print(f"Model {model_name} loaded successfully!")
-
+                print(f"Success: {model_name}")
                 model_loaded = True
                 loaded_model_name = model_name
                 loaded_successfully = True
-                tabs_update = gr.Tabs.update(visible=True)
-                status_msg = f"✅ Model '{model_name}' loaded successfully!"
+                # --- FIX: Use gr.update() for visibility ---
+                tabs_update = gr.update(visible=True) # Generic update targeted by outputs list
+                status_msg = f"✅ Model '{model_name}' loaded!"
                 if "tinyllama" in model_name.lower():
-                    status_msg = f"✅ Fallback model '{model_name}' loaded successfully! Limited capabilities compared to Gemma."
+                    status_msg = f"✅ Fallback '{model_name}' loaded!"
                 return status_msg, tabs_update
-
-            except ImportError as import_err:
-                 print(f"Import Error loading {model_name}: {import_err}. Check dependencies (e.g., bitsandbytes, accelerate).")
+            except ImportError as ie:
+                 print(f"Import Error ({model_name}): {ie}. Check dependencies.")
                  continue
-            except Exception as specific_e:
-                print(f"Failed to load {model_name}: {specific_e}")
-                if "401 Client Error" in str(specific_e) or "requires you to be logged in" in str(specific_e) and is_gemma:
-                    print("Authentication error likely. Check token and license agreement.")
+            except Exception as e:
+                print(f"Failed ({model_name}): {e}")
+                if "401" in str(e) or "logged in" in str(e) and is_gemma: print("Auth error likely.")
                 continue
-
         if not loaded_successfully:
-            model_loaded = False
-            loaded_model_name = "None"
-            print("Could not load any model version.")
-            return "❌ Could not load any model. Please check your token, license acceptance, dependencies, and network connection.", initial_tabs_update
-
+            model_loaded = False; loaded_model_name = "None"
+            return "❌ Failed to load any model. Check token/license/deps/network.", initial_tabs_update
     except Exception as e:
-        model_loaded = False
-        loaded_model_name = "None"
-        error_msg = str(e)
-        print(f"Error in load_model: {error_msg}")
-        traceback.print_exc()
-        if "401 Client Error" in error_msg or "requires you to be logged in" in error_msg :
-            return "❌ Authentication failed. Check token/license.", initial_tabs_update
-        else:
-            return f"❌ Unexpected error during model loading: {error_msg}", initial_tabs_update
+        model_loaded = False; loaded_model_name = "None"
+        print(f"Outer load error: {e}"); traceback.print_exc()
+        if "401" in str(e) or "logged in" in str(e): return "❌ Auth failed.", initial_tabs_update
+        else: return f"❌ Unexpected load error: {e}", initial_tabs_update
 
 
 def generate_prompt(task_type, **kwargs):
@@ -141,6 +118,7 @@ def generate_text(prompt, max_new_tokens=1024, temperature=0.7, top_p=0.9):
     global global_model, global_tokenizer, model_loaded, loaded_model_name
 
     print(f"\n--- Generating Text ---")
+    # ... (rest of the function remains the same as the previous valid version) ...
     print(f"Model: {loaded_model_name}")
     print(f"Params: max_new_tokens={max_new_tokens}, temp={temperature}, top_p={top_p}")
     print(f"Prompt (start): {prompt[:150]}...")
@@ -154,11 +132,9 @@ def generate_text(prompt, max_new_tokens=1024, temperature=0.7, top_p=0.9):
         chat_prompt = prompt # Default to raw prompt
         if loaded_model_name and ("it" in loaded_model_name.lower() or "instruct" in loaded_model_name.lower() or "chat" in loaded_model_name.lower()):
              if "gemma" in loaded_model_name.lower():
-                 # Use Gemma's specific format
                  chat_prompt = f"<start_of_turn>user\n{prompt}<end_of_turn>\n<start_of_turn>model\n"
              elif "tinyllama" in loaded_model_name.lower():
-                 # Use TinyLlama's chat format
-                 chat_prompt = f"<|system|>\nYou are a friendly chatbot.</s>\n<|user|>\n{prompt}</s>\n<|assistant|>\n"
+                 chat_prompt = f"<|system|>\nYou are a helpful assistant.</s>\n<|user|>\n{prompt}</s>\n<|assistant|>\n"
              else: # Generic instruction format
                  chat_prompt = f"User: {prompt}\nAssistant:"
 
@@ -168,11 +144,10 @@ def generate_text(prompt, max_new_tokens=1024, temperature=0.7, top_p=0.9):
 
         effective_max_new_tokens = min(int(max_new_tokens), 2048)
 
-        # Handle potential None for eos_token_id
         eos_token_id = global_tokenizer.eos_token_id
         if eos_token_id is None:
             print("Warning: eos_token_id is None, using default 50256.")
-            eos_token_id = 50256 # A common default EOS token ID
+            eos_token_id = 50256
 
         generation_args = {
             "input_ids": inputs.input_ids,
@@ -181,9 +156,8 @@ def generate_text(prompt, max_new_tokens=1024, temperature=0.7, top_p=0.9):
             "do_sample": True,
             "temperature": float(temperature),
             "top_p": float(top_p),
-            "pad_token_id": eos_token_id # Use determined EOS or default
+            "pad_token_id": eos_token_id
         }
-
         print(f"Generation args: {generation_args}")
 
         with torch.no_grad():
@@ -201,15 +175,17 @@ def generate_text(prompt, max_new_tokens=1024, temperature=0.7, top_p=0.9):
         print(f"Generation error: {error_msg}")
         traceback.print_exc()
         if "CUDA out of memory" in error_msg:
-             return f"❌ Error: CUDA out of memory. Try reducing 'Max New Tokens' or using a smaller model."
+             return f"❌ Error: CUDA out of memory. Try reducing 'Max New Tokens' or use a smaller model."
         elif "probability tensor contains nan" in error_msg or "invalid value encountered" in error_msg:
-             return f"❌ Error: Generation failed (invalid probability). Try adjusting Temperature/Top-P or modifying the prompt."
+             return f"❌ Error: Generation failed (invalid probability). Adjust Temp/Top-P or prompt."
         else:
              return f"❌ Error during text generation: {error_msg}"
 
+
 # --- UI Components & Layout ---
 
 def create_parameter_ui():
+    # ... (function remains the same) ...
     with gr.Accordion("✨ Generation Parameters", open=False):
         with gr.Row():
             max_new_tokens = gr.Slider(minimum=64, maximum=2048, value=512, step=64, label="Max New Tokens", info="Max tokens to generate.")
@@ -224,6 +200,7 @@ lang_map = {"Python": "python", "JavaScript": "javascript", "Java": "java", "C++
 with gr.Blocks(theme=gr.themes.Soft(), fill_height=True, title="Gemma Capabilities Demo") as demo:
 
     # Header
+    # ... (remains the same) ...
     gr.Markdown(
         """
         <div style="text-align: center; margin-bottom: 20px;"><h1><span style="font-size: 1.5em;">🤖</span> Gemma Capabilities Demo</h1>
@@ -231,8 +208,10 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True, title="Gemma Capabiliti
         <p style="font-size: 0.9em;"><a href="https://huggingface.co/google/gemma-7b-it" target="_blank">[Accept Gemma License Here]</a></p></div>"""
     )
 
+
     # --- Authentication ---
-    with gr.Group(): # Removed variant="panel"
+    # ... (remains the same) ...
+    with gr.Group():
         gr.Markdown("### 🔑 Authentication")
         with gr.Row():
             with gr.Column(scale=4):
@@ -242,12 +221,13 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True, title="Gemma Capabiliti
         auth_status = gr.Markdown("ℹ️ Enter token & click 'Load Model'. May take time.")
         gr.Markdown(
              "**Token Info:** Get from [HF Settings](https://huggingface.co/settings/tokens) (read access). Ensure Gemma license is accepted.",
-             elem_id="token-info" # Optional ID for styling if needed later
+             elem_id="token-info"
          )
 
     # --- Main Content Tabs ---
+    # Define tabs instance first
     with gr.Tabs(elem_id="main_tabs", visible=False) as tabs:
-
+        # ... (All TabItem definitions remain the same as the previous working version) ...
         # --- Text Generation Tab ---
         with gr.TabItem("📝 Creative & Informational"):
             with gr.Row():
@@ -263,26 +243,20 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True, title="Gemma Capabiliti
                     with gr.Group(visible=False) as custom_prompt_group:
                         custom_prompt = gr.Textbox(label="Custom Prompt", placeholder="Enter full prompt...", lines=5)
                     text_gen_params = create_parameter_ui()
-                    # Removed gr.Spacer
                     generate_text_btn = gr.Button("Generate Text", variant="primary")
                 with gr.Column(scale=1):
                     gr.Markdown("#### Generated Output")
                     text_output = gr.Textbox(label="Result", lines=25, interactive=False, show_copy_button=True)
 
-            # Visibility logic
             def update_text_gen_visibility(choice):
                 return { creative_options: gr.update(visible=choice == "Creative Writing"),
                          info_options: gr.update(visible=choice == "Informational Writing"),
                          custom_prompt_group: gr.update(visible=choice == "Custom Prompt") }
             text_gen_type.change(update_text_gen_visibility, text_gen_type, [creative_options, info_options, custom_prompt_group], queue=False)
 
-            # Click handler
             def text_gen_click(gen_type, style, c_topic, fmt_type, i_topic, custom_pr, *params):
-                task_map = {"Creative Writing": ("creative", {"style": style, "topic": c_topic}),
-                            "Informational Writing": ("informational", {"format_type": fmt_type, "topic": i_topic}),
-                            "Custom Prompt": ("custom", {"prompt": custom_pr})}
-                task_type, kwargs = task_map.get(gen_type, ("custom", {"prompt": custom_pr}))
-                # Apply safe_value inside handler where needed
+                task_map = {"Creative Writing": ("creative", {}), "Informational Writing": ("informational", {}), "Custom Prompt": ("custom", {})}
+                task_type, kwargs = task_map.get(gen_type, ("custom", {}))
                 if task_type == "creative": kwargs = {"style": safe_value(style, "story"), "topic": safe_value(c_topic, "[topic]")}
                 elif task_type == "informational": kwargs = {"format_type": safe_value(fmt_type, "article"), "topic": safe_value(i_topic, "[topic]")}
                 else: kwargs = {"prompt": safe_value(custom_pr, "Write something.")}
@@ -290,14 +264,12 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True, title="Gemma Capabiliti
                 return generate_text(final_prompt, *params)
             generate_text_btn.click(text_gen_click, [text_gen_type, style, creative_topic, format_type, info_topic, custom_prompt, *text_gen_params], text_output)
 
-            # Examples
             gr.Examples( examples=[ ["Creative Writing", "poem", "sound of rain", "", "", "", 512, 0.7, 0.9],
                                      ["Informational Writing", "", "", "explanation", "photosynthesis", "", 768, 0.6, 0.9],
                                      ["Custom Prompt", "", "", "", "", "Dialogue: cat and dog discuss humans.", 512, 0.8, 0.95] ],
-                         inputs=[text_gen_type, style, creative_topic, format_type, info_topic, custom_prompt, *text_gen_params[:3]], # Pass UI elements
+                         inputs=[text_gen_type, style, creative_topic, format_type, info_topic, custom_prompt, *text_gen_params[:3]],
                          outputs=text_output, label="Try examples...")
 
-
         # --- Brainstorming Tab ---
         with gr.TabItem("🧠 Brainstorming"):
              with gr.Row():
@@ -306,12 +278,10 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True, title="Gemma Capabiliti
                      brainstorm_category = gr.Dropdown(["project", "business", "creative", "solution", "content", "feature", "product name"], label="Category", value="project")
                      brainstorm_topic = gr.Textbox(label="Topic/Problem", placeholder="e.g., reducing plastic waste", value="unique mobile app ideas", lines=3)
                      brainstorm_params = create_parameter_ui()
-                     # Removed gr.Spacer
                      brainstorm_btn = gr.Button("Generate Ideas", variant="primary")
                  with gr.Column(scale=1):
                      gr.Markdown("#### Generated Ideas")
                      brainstorm_output = gr.Textbox(label="Result", lines=25, interactive=False, show_copy_button=True)
-
              def brainstorm_click(category, topic, *params):
                  prompt = generate_prompt("brainstorm", category=safe_value(category, "project"), topic=safe_value(topic, "ideas"))
                  return generate_text(prompt, *params)
@@ -321,7 +291,6 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True, title="Gemma Capabiliti
                            ["creative", "fantasy novel themes", 512, 0.85, 0.95] ],
                           inputs=[brainstorm_category, brainstorm_topic, *brainstorm_params[:3]], outputs=brainstorm_output, label="Try examples...")
 
-
         # --- Code Tab ---
         with gr.TabItem("💻 Code"):
             with gr.Tabs():
@@ -332,249 +301,136 @@ with gr.Blocks(theme=gr.themes.Soft(), fill_height=True, title="Gemma Capabiliti
                             code_lang_gen = gr.Dropdown(list(lang_map.keys())[:-1], label="Language", value="Python")
                             code_task = gr.Textbox(label="Task", placeholder="e.g., function for factorial", value="Python class for calculator", lines=4)
                             code_gen_params = create_parameter_ui()
-                            # Removed gr.Spacer
                             code_gen_btn = gr.Button("Generate Code", variant="primary")
                         with gr.Column(scale=1):
                             gr.Markdown("#### Generated Code")
                             code_output = gr.Code(label="Result", language="python", lines=25, interactive=False)
-
                      def gen_code_click(lang, task, *params):
                          prompt = generate_prompt("code_generate", language=safe_value(lang, "Python"), task=safe_value(task, "hello world"))
-                         result = generate_text(prompt, *params)
-                         # Basic code block extraction
-                         if "```" in result:
-                             parts = result.split("```")
-                             if len(parts) >= 2:
-                                 block = parts[1]
-                                 if '\n' in block: first_line, rest = block.split('\n', 1); return rest.strip() if first_line.strip().lower() == lang.lower() else block.strip()
-                                 else: return block.strip()
+                         result = generate_text(prompt, *params); # Basic extraction...
+                         if "```" in result: parts = result.split("```"); block = parts[1] if len(parts)>1 else ''; return block.split('\n',1)[1].strip() if '\n' in block and block.split('\n',1)[0].strip().lower() == lang.lower() else block.strip()
                          return result.strip()
                      def update_gen_lang_display(lang): return gr.Code.update(language=lang_map.get(lang, "plaintext"))
                      code_lang_gen.change(update_gen_lang_display, code_lang_gen, code_output, queue=False)
                      code_gen_btn.click(gen_code_click, [code_lang_gen, code_task, *code_gen_params], code_output)
-                     gr.Examples([ ["JavaScript", "email validation regex function", 768, 0.6, 0.9],
-                                   ["SQL", "select users > 30 yrs old", 512, 0.5, 0.8],
-                                   ["HTML", "basic portfolio structure", 1024, 0.7, 0.9] ],
-                                 inputs=[code_lang_gen, code_task, *code_gen_params[:3]], outputs=code_output, label="Try examples...")
+                     gr.Examples([["JS", "email validation", 768, 0.6, 0.9], ["SQL", "users > 30", 512, 0.5, 0.8], ["HTML", "portfolio", 1024, 0.7, 0.9]], [code_lang_gen, code_task, *code_gen_params[:3]], code_output, label="Try...") # Abbreviated examples
 
                 with gr.TabItem("Explain"):
                      with gr.Row():
-                         with gr.Column(scale=1):
-                            gr.Markdown("#### Setup")
-                            code_lang_explain = gr.Dropdown(list(lang_map.keys()), label="Language", value="Python")
-                            code_to_explain = gr.Code(label="Code to Explain", language="python", lines=15)
-                            explain_code_params = create_parameter_ui()
-                            # Removed gr.Spacer
-                            explain_code_btn = gr.Button("Explain Code", variant="primary")
-                         with gr.Column(scale=1):
-                            gr.Markdown("#### Explanation")
-                            code_explanation = gr.Textbox(label="Result", lines=25, interactive=False, show_copy_button=True)
-
-                     def explain_code_click(lang, code, *params):
-                         code_content = safe_value(code['code'] if isinstance(code, dict) else code, "# Empty code")
-                         prompt = generate_prompt("code_explain", language=safe_value(lang, "code"), code=code_content)
-                         return generate_text(prompt, *params)
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); code_lang_explain = gr.Dropdown(list(lang_map.keys()), label="Language", value="Python"); code_to_explain = gr.Code(label="Code to Explain", language="python", lines=15); explain_code_params = create_parameter_ui(); explain_code_btn = gr.Button("Explain Code", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Explanation"); code_explanation = gr.Textbox(label="Result", lines=25, interactive=False, show_copy_button=True)
+                     def explain_code_click(lang, code, *params): code_content = safe_value(code['code'] if isinstance(code, dict) else code, "#"); prompt = generate_prompt("code_explain", language=safe_value(lang, "code"), code=code_content); return generate_text(prompt, *params)
                      def update_explain_lang_display(lang): return gr.Code.update(language=lang_map.get(lang, "plaintext"))
                      code_lang_explain.change(update_explain_lang_display, code_lang_explain, code_to_explain, queue=False)
                      explain_code_btn.click(explain_code_click, [code_lang_explain, code_to_explain, *explain_code_params], code_explanation)
 
-
                 with gr.TabItem("Debug"):
                      with gr.Row():
-                         with gr.Column(scale=1):
-                            gr.Markdown("#### Setup")
-                            code_lang_debug = gr.Dropdown(list(lang_map.keys()), label="Language", value="Python")
-                            code_to_debug = gr.Code(label="Buggy Code", language="python", lines=15, value="def avg(nums):\n  # Potential div by zero\n  return sum(nums)/len(nums)")
-                            debug_code_params = create_parameter_ui()
-                            # Removed gr.Spacer
-                            debug_code_btn = gr.Button("Debug Code", variant="primary")
-                         with gr.Column(scale=1):
-                            gr.Markdown("#### Debugging Analysis")
-                            debug_result = gr.Textbox(label="Result", lines=25, interactive=False, show_copy_button=True)
-
-                     def debug_code_click(lang, code, *params):
-                         code_content = safe_value(code['code'] if isinstance(code, dict) else code, "# Empty code")
-                         prompt = generate_prompt("code_debug", language=safe_value(lang, "code"), code=code_content)
-                         return generate_text(prompt, *params)
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); code_lang_debug = gr.Dropdown(list(lang_map.keys()), label="Language", value="Python"); code_to_debug = gr.Code(label="Buggy Code", language="python", lines=15, value="def avg(nums):\n  # Potential div by zero\n  return sum(nums)/len(nums)"); debug_code_params = create_parameter_ui(); debug_code_btn = gr.Button("Debug Code", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Debugging Analysis"); debug_result = gr.Textbox(label="Result", lines=25, interactive=False, show_copy_button=True)
+                     def debug_code_click(lang, code, *params): code_content = safe_value(code['code'] if isinstance(code, dict) else code, "#"); prompt = generate_prompt("code_debug", language=safe_value(lang, "code"), code=code_content); return generate_text(prompt, *params)
                      def update_debug_lang_display(lang): return gr.Code.update(language=lang_map.get(lang, "plaintext"))
                      code_lang_debug.change(update_debug_lang_display, code_lang_debug, code_to_debug, queue=False)
                      debug_code_btn.click(debug_code_click, [code_lang_debug, code_to_debug, *debug_code_params], debug_result)
 
-
         # --- Comprehension Tab ---
         with gr.TabItem("📚 Comprehension"):
             with gr.Tabs():
                 with gr.TabItem("Summarize"):
                     with gr.Row():
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Setup")
-                            summarize_text = gr.Textbox(label="Text to Summarize", lines=15, placeholder="Paste long text...")
-                            summarize_params = create_parameter_ui()
-                            # Removed gr.Spacer
-                            summarize_btn = gr.Button("Summarize Text", variant="primary")
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Summary")
-                            summary_output = gr.Textbox(label="Result", lines=15, interactive=False, show_copy_button=True)
-                    def summarize_click(text, *params):
-                        prompt = generate_prompt("summarize", text=safe_value(text, "[empty text]"))
-                        # Adjust max tokens for summary specifically if needed
-                        p_list = list(params); p_list[0] = min(max(int(p_list[0]), 64), 512)
-                        return generate_text(prompt, *p_list)
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); summarize_text = gr.Textbox(label="Text", lines=15, placeholder="Paste..."); summarize_params = create_parameter_ui(); summarize_btn = gr.Button("Summarize", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Summary"); summary_output = gr.Textbox(label="Result", lines=15, interactive=False, show_copy_button=True)
+                    def summarize_click(text, *params): prompt = generate_prompt("summarize", text=safe_value(text,"[text]")); p = list(params); p[0]=min(max(int(p[0]),64),512); return generate_text(prompt, *p)
                     summarize_btn.click(summarize_click, [summarize_text, *summarize_params], summary_output)
-
-
                 with gr.TabItem("Q & A"):
                     with gr.Row():
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Setup")
-                            qa_text = gr.Textbox(label="Context Text", lines=10, placeholder="Paste text containing answer...")
-                            qa_question = gr.Textbox(label="Question", placeholder="Ask question about text...")
-                            qa_params = create_parameter_ui()
-                            # Removed gr.Spacer
-                            qa_btn = gr.Button("Get Answer", variant="primary")
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Answer")
-                            qa_output = gr.Textbox(label="Result", lines=10, interactive=False, show_copy_button=True)
-                    def qa_click(text, question, *params):
-                        prompt = generate_prompt("qa", text=safe_value(text, "[context]"), question=safe_value(question,"[question]"))
-                        p_list = list(params); p_list[0] = min(max(int(p_list[0]), 32), 256)
-                        return generate_text(prompt, *p_list)
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); qa_text = gr.Textbox(label="Context", lines=10, placeholder="Paste context..."); qa_question = gr.Textbox(label="Question", placeholder="Ask..."); qa_params = create_parameter_ui(); qa_btn = gr.Button("Answer", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Answer"); qa_output = gr.Textbox(label="Result", lines=10, interactive=False, show_copy_button=True)
+                    def qa_click(text, q, *params): prompt = generate_prompt("qa", text=safe_value(text,"[ctx]"), question=safe_value(q,"[q]")); p = list(params); p[0]=min(max(int(p[0]),32),256); return generate_text(prompt, *p)
                     qa_btn.click(qa_click, [qa_text, qa_question, *qa_params], qa_output)
-
-
                 with gr.TabItem("Translate"):
                      with gr.Row():
-                         with gr.Column(scale=1):
-                             gr.Markdown("#### Setup")
-                             translate_text = gr.Textbox(label="Text to Translate", lines=8, placeholder="Enter text...")
-                             target_lang = gr.Dropdown(["French", "Spanish", "German", "Japanese", "Chinese", "Russian", "Arabic", "Hindi", "Portuguese", "Italian"], label="Translate To", value="French")
-                             translate_params = create_parameter_ui()
-                             # Removed gr.Spacer
-                             translate_btn = gr.Button("Translate Text", variant="primary")
-                         with gr.Column(scale=1):
-                             gr.Markdown("#### Translation")
-                             translation_output = gr.Textbox(label="Result", lines=8, interactive=False, show_copy_button=True)
-                     def translate_click(text, lang, *params):
-                         prompt = generate_prompt("translate", text=safe_value(text,"[text]"), target_lang=safe_value(lang,"French"))
-                         p_list = list(params); p_list[0] = max(int(p_list[0]), 64)
-                         return generate_text(prompt, *p_list)
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); translate_text = gr.Textbox(label="Text", lines=8, placeholder="Enter text..."); target_lang = gr.Dropdown(["French", "Spanish", "German", "Japanese", "Chinese", "Russian", "Arabic", "Hindi", "Portuguese", "Italian"], label="To", value="French"); translate_params = create_parameter_ui(); translate_btn = gr.Button("Translate", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Translation"); translation_output = gr.Textbox(label="Result", lines=8, interactive=False, show_copy_button=True)
+                     def translate_click(text, lang, *params): prompt = generate_prompt("translate", text=safe_value(text,"[text]"), target_lang=safe_value(lang,"French")); p = list(params); p[0]=max(int(p[0]),64); return generate_text(prompt, *p)
                      translate_btn.click(translate_click, [translate_text, target_lang, *translate_params], translation_output)
 
-
         # --- More Tasks Tab ---
         with gr.TabItem("🛠️ More Tasks"):
              with gr.Tabs():
-                 with gr.TabItem("Content Creation"):
+                 with gr.TabItem("Content"): # Abbreviated names for brevity
                      with gr.Row():
-                         with gr.Column(scale=1):
-                             gr.Markdown("#### Setup")
-                             content_type = gr.Dropdown(["blog post outline", "social media post (Twitter)", "social media post (LinkedIn)", "marketing email subject line", "product description", "press release intro"], label="Content Type", value="blog post outline")
-                             content_topic = gr.Textbox(label="Topic", value="sustainable travel tips", lines=2)
-                             content_audience = gr.Textbox(label="Audience", value="eco-conscious millennials")
-                             content_params = create_parameter_ui()
-                             # Removed gr.Spacer
-                             content_btn = gr.Button("Generate Content", variant="primary")
-                         with gr.Column(scale=1):
-                             gr.Markdown("#### Generated Content")
-                             content_output = gr.Textbox(label="Result", lines=20, interactive=False, show_copy_button=True)
-                     def content_click(c_type, topic, audience, *params):
-                         prompt = generate_prompt("content_creation", content_type=safe_value(c_type,"text"), topic=safe_value(topic,"[topic]"), audience=safe_value(audience,"[audience]"))
-                         return generate_text(prompt, *params)
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); content_type = gr.Dropdown(["blog outline", "tweet", "linkedin post", "email subject", "product desc", "press release intro"], label="Type", value="blog outline"); content_topic = gr.Textbox(label="Topic", value="sustainable travel", lines=2); content_audience = gr.Textbox(label="Audience", value="millennials"); content_params = create_parameter_ui(); content_btn = gr.Button("Generate", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Result"); content_output = gr.Textbox(lines=20, interactive=False, show_copy_button=True)
+                     def content_click(t, top, aud, *p): prompt = generate_prompt("content_creation", content_type=safe_value(t,"text"), topic=safe_value(top,"[topic]"), audience=safe_value(aud,"[audience]")); return generate_text(prompt, *p)
                      content_btn.click(content_click, [content_type, content_topic, content_audience, *content_params], content_output)
-
-                 with gr.TabItem("Email Drafting"):
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Setup")
-                            email_type = gr.Dropdown(["job inquiry", "meeting request", "follow-up", "thank you", "support response", "sales outreach"], label="Email Type", value="meeting request")
-                            email_context = gr.Textbox(label="Context/Points", lines=5, value="Request meeting next week re: project X. Suggest Tue/Wed afternoon.")
-                            email_params = create_parameter_ui()
-                            # Removed gr.Spacer
-                            email_btn = gr.Button("Generate Draft", variant="primary")
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Generated Draft")
-                            email_output = gr.Textbox(label="Result", lines=20, interactive=False, show_copy_button=True)
-                    def email_click(e_type, context, *params):
-                        prompt = generate_prompt("email_draft", email_type=safe_value(e_type,"email"), context=safe_value(context,"[context]"))
-                        return generate_text(prompt, *params)
-                    email_btn.click(email_click, [email_type, email_context, *email_params], email_output)
-
-                 with gr.TabItem("Doc Editing"):
+                 with gr.TabItem("Email"):
+                     with gr.Row():
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); email_type = gr.Dropdown(["job inquiry", "meeting request", "follow-up", "thank you", "support reply", "sales outreach"], label="Type", value="meeting request"); email_context = gr.Textbox(label="Context", lines=5, value="Meet next week re: project X. Tue/Wed PM?"); email_params = create_parameter_ui(); email_btn = gr.Button("Generate", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Draft"); email_output = gr.Textbox(lines=20, interactive=False, show_copy_button=True)
+                     def email_click(t, ctx, *p): prompt = generate_prompt("email_draft", email_type=safe_value(t,"email"), context=safe_value(ctx,"[context]")); return generate_text(prompt, *p)
+                     email_btn.click(email_click, [email_type, email_context, *email_params], email_output)
+                 with gr.TabItem("Edit"):
                      with gr.Row():
-                         with gr.Column(scale=1):
-                             gr.Markdown("#### Setup")
-                             edit_text = gr.Textbox(label="Text to Edit", lines=10, placeholder="Paste text...")
-                             edit_type = gr.Dropdown(["improve clarity", "fix grammar/spelling", "make concise", "make formal", "make casual", "simplify"], label="Improve For", value="improve clarity")
-                             edit_params = create_parameter_ui()
-                             # Removed gr.Spacer
-                             edit_btn = gr.Button("Edit Text", variant="primary")
-                         with gr.Column(scale=1):
-                             gr.Markdown("#### Edited Text")
-                             edit_output = gr.Textbox(label="Result", lines=10, interactive=False, show_copy_button=True)
-                     def edit_click(text, e_type, *params):
-                         prompt = generate_prompt("document_edit", text=safe_value(text,"[text]"), edit_type=safe_value(e_type,"clarity"))
-                         p_list = list(params); input_tokens = len(safe_value(text,"").split()); p_list[0] = max(int(p_list[0]), input_tokens + 64)
-                         return generate_text(prompt, *p_list)
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); edit_text = gr.Textbox(label="Text", lines=10, placeholder="Paste..."); edit_type = gr.Dropdown(["clarity", "grammar/spelling", "concise", "formal", "casual", "simplify"], label="Improve For", value="clarity"); edit_params = create_parameter_ui(); edit_btn = gr.Button("Edit", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Edited"); edit_output = gr.Textbox(lines=10, interactive=False, show_copy_button=True)
+                     def edit_click(txt, et, *p): prompt = generate_prompt("document_edit", text=safe_value(txt,"[text]"), edit_type=safe_value(et,"clarity")); p_list = list(p); p_list[0] = max(int(p_list[0]), len(safe_value(txt,"").split()) + 64); return generate_text(prompt, *p_list)
                      edit_btn.click(edit_click, [edit_text, edit_type, *edit_params], edit_output)
-
-                 with gr.TabItem("Classification"):
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Setup")
-                            classify_text = gr.Textbox(label="Text to Classify", lines=8, value="Sci-fi movie explores AI consciousness.")
-                            classify_categories = gr.Textbox(label="Categories (comma-sep)", value="Tech, Entertainment, Science, Politics")
-                            classify_params = create_parameter_ui()
-                            # Removed gr.Spacer
-                            classify_btn = gr.Button("Classify Text", variant="primary")
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Classification")
-                            classify_output = gr.Textbox(label="Predicted Category", lines=2, interactive=False, show_copy_button=True)
-                    def classify_click(text, cats, *params):
-                        prompt = generate_prompt("classify", text=safe_value(text,"[text]"), categories=safe_value(cats,"cat1, cat2"))
-                        p_list = list(params); p_list[0] = min(max(int(p_list[0]), 16), 128)
-                        raw = generate_text(prompt, *p_list)
-                        # Basic post-processing attempt
-                        lines = raw.split('\n'); last = lines[-1].strip(); possible = [c.strip().lower() for c in cats.split(',')]; return last if last.lower() in possible else raw
-                    classify_btn.click(classify_click, [classify_text, classify_categories, *classify_params], classify_output)
-
-                 with gr.TabItem("Data Extraction"):
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Setup")
-                            extract_text = gr.Textbox(label="Source Text", lines=10, value="Order #123 by Jane ([email protected]). Total: $99. Shipped: 123 Main St.")
-                            extract_data_points = gr.Textbox(label="Data Points (comma-sep)", value="order num, name, email, total, address")
-                            extract_params = create_parameter_ui()
-                            # Removed gr.Spacer
-                            extract_btn = gr.Button("Extract Data", variant="primary")
-                        with gr.Column(scale=1):
-                            gr.Markdown("#### Extracted Data")
-                            extract_output = gr.Textbox(label="Result (JSON or Key-Value)", lines=10, interactive=False, show_copy_button=True)
-                    def extract_click(text, points, *params):
-                        prompt = generate_prompt("data_extract", text=safe_value(text,"[text]"), data_points=safe_value(points,"info"))
-                        return generate_text(prompt, *params)
-                    extract_btn.click(extract_click, [extract_text, extract_data_points, *extract_params], extract_output)
+                 with gr.TabItem("Classify"):
+                     with gr.Row():
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); classify_text = gr.Textbox(label="Text", lines=8, value="Sci-fi movie explores AI."); classify_categories = gr.Textbox(label="Categories", value="Tech, Entertainment, Science"); classify_params = create_parameter_ui(); classify_btn = gr.Button("Classify", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Category"); classify_output = gr.Textbox(lines=2, interactive=False, show_copy_button=True)
+                     def classify_click(txt, cats, *p): prompt = generate_prompt("classify", text=safe_value(txt,"[text]"), categories=safe_value(cats,"c1,c2")); p_list = list(p); p_list[0] = min(max(int(p_list[0]),16),128); raw=generate_text(prompt,*p_list); lines=raw.split('\n');last=lines[-1].strip();poss=[c.strip().lower() for c in cats.split(',')]; return last if last.lower() in poss else raw
+                     classify_btn.click(classify_click, [classify_text, classify_categories, *classify_params], classify_output)
+                 with gr.TabItem("Extract"):
+                     with gr.Row():
+                         with gr.Column(scale=1): gr.Markdown("#### Setup"); extract_text = gr.Textbox(label="Source", lines=10, value="Order #123 by Jane ([email protected]). Total: $99."); extract_data_points = gr.Textbox(label="Extract", value="order num, name, email, total"); extract_params = create_parameter_ui(); extract_btn = gr.Button("Extract", variant="primary")
+                         with gr.Column(scale=1): gr.Markdown("#### Data"); extract_output = gr.Textbox(lines=10, interactive=False, show_copy_button=True)
+                     def extract_click(txt, pts, *p): prompt = generate_prompt("data_extract", text=safe_value(txt,"[text]"), data_points=safe_value(pts,"info")); return generate_text(prompt, *p)
+                     extract_btn.click(extract_click, [extract_text, extract_data_points, *extract_params], extract_output)
 
 
     # --- Authentication Handler & Footer ---
-    footer_status = gr.Markdown(f"...", elem_id="footer-status-md") # Placeholder
+    footer_status = gr.Markdown("...", elem_id="footer-status-md") # Placeholder for footer
 
+    # Define authentication handler AFTER tabs is defined
     def handle_auth(token):
-        yield "⏳ Authenticating & loading model...", gr.Tabs.update(visible=False)
-        status_message, tabs_update = load_model(token)
-        yield status_message, tabs_update
+        # --- FIX: Use gr.update() for visibility ---
+        yield "⏳ Authenticating & loading model...", gr.update(visible=False)
+        # Call the actual model loading function
+        status_message, tabs_update_obj = load_model(token) # Get the update object
+        yield status_message, tabs_update_obj # Yield the object
 
+    # Define footer update handler
     def update_footer_status(status_text): # Updates footer based on global state
-        return gr.Markdown.update(value=f"""
+        # --- FIX: Use gr.update() for Markdown ---
+        return gr.update(value=f"""
            <hr><div style="text-align: center; font-size: 0.9em; color: #777;">
            <p>Powered by Hugging Face 🤗 Transformers & Gradio. Model: <strong>{loaded_model_name if model_loaded else 'None'}</strong>.</p>
            <p>Review outputs carefully. Models may generate inaccurate information.</p></div>""")
 
-    auth_button.click(handle_auth, hf_token, [auth_status, tabs], queue=True)
+    # Link button click to the handler
+    auth_button.click(
+        fn=handle_auth,
+        inputs=hf_token,
+        outputs=[auth_status, tabs], # Target auth_status and the tabs instance
+        queue=True
+    )
     # Update footer whenever auth status text changes
-    auth_status.change(update_footer_status, auth_status, footer_status, queue=False)
+    auth_status.change(
+        fn=update_footer_status,
+        inputs=auth_status, # Trigger based on auth_status text
+        outputs=footer_status, # Update the footer_status Markdown
+        queue=False
+    )
     # Initial footer update on load
-    demo.load(update_footer_status, auth_status, footer_status, queue=False)
+    demo.load(
+        fn=update_footer_status,
+        inputs=auth_status, # Use initial auth_status text
+        outputs=footer_status,
+        queue=False
+    )
 
 
 # --- Launch App ---
-demo.launch(share=False)
+demo.queue().launch(share=False)

testing_grok.py

@@ -0,0 +1,205 @@
+import gradio as gr
+import torch
+import os
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from gradio.themes.utils import colors, sizes
+from gradio.themes import Soft
+
+# Define custom themes
+class GemmaLightTheme(Soft):
+    def __init__(self):
+        super().__init__(
+            primary_hue=colors.blue,
+            secondary_hue=colors.indigo,
+            neutral_hue=colors.gray,
+            spacing_size=sizes.spacing_md,
+            radius_size=sizes.radius_md,
+            text_size=sizes.text_md,
+        )
+
+class GemmaDarkTheme(Soft):
+    def __init__(self):
+        super().__init__(
+            primary_hue=colors.blue,
+            secondary_hue=colors.indigo,
+            neutral_hue=colors.gray,
+            spacing_size=sizes.spacing_md,
+            radius_size=sizes.radius_md,
+            text_size=sizes.text_md,
+        )
+        self.name = "gemma_dark"
+        self.background_fill_primary = "#1F1F2E"
+        self.background_fill_secondary = "#2A2A3C"
+        self.border_color_primary = "#3A3A4C"
+        self.border_color_secondary = "#4A4A5C"
+        self.color_accent_soft = "#3B5FA3"
+        self.color_accent = "#4B82C4"
+        self.text_color = "#FFFFFF"
+        self.text_color_subdued = "#CCCCCC"
+        self.shadow_spread = "8px"
+        self.shadow_inset = "0px 1px 2px 0px rgba(0, 0, 0, 0.1) inset"
+
+# [Previous code for helper functions, model loading, etc., remains unchanged]
+
+# Create Gradio interface
+with gr.Blocks(theme=GemmaLightTheme()) as demo:
+    # Header with theme toggle
+    with gr.Row(equal_height=True):
+        with gr.Column(scale=6):
+            gr.Markdown(
+                """
+                # 🤖 Gemma Capabilities Demo
+                
+                This interactive demo showcases Google's Gemma model capabilities across different tasks.
+                """
+            )
+        with gr.Column(scale=1, min_width=150):
+            theme_toggle = gr.Radio(
+                ["Light", "Dark"],
+                value="Light",
+                label="Theme",
+                info="Switch between light and dark mode",
+                elem_id="theme_toggle"
+            )
+
+    # Add CSS and JavaScript for themes
+    gr.HTML("""
+    <style>
+    /* Base styles for better UI */
+    .gr-group {
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+        border-radius: 10px;
+        padding: 20px;
+        background-color: var(--block-background-fill);
+    }
+    .gr-tabs {
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+        border-radius: 10px;
+        overflow: hidden;
+    }
+    button.primary {
+        transition: transform 0.2s, box-shadow 0.2s;
+    }
+    button.primary:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.2);
+    }
+    textarea, .input-box {
+        font-size: 16px !important;
+    }
+    
+    /* Dark theme overrides using Gradio variables */
+    .dark-theme {
+        --body-background-fill: #1F1F2E !important;
+        --block-background-fill: #2A2A3C !important;
+        --input-background-fill: #3A3A4C !important;
+        --button-primary-background-fill: #4B82C4 !important;
+        --button-secondary-background-fill: #3A3A4C !important;
+        --border-color-primary: #4A4A5C !important;
+        --body-text-color: #FFFFFF !important;
+        --block-label-text-color: #CCCCCC !important;
+        --input-text-color: #FFFFFF !important;
+        --button-primary-text-color: #FFFFFF !important;
+        --button-secondary-text-color: #FFFFFF !important;
+        --shadow: 0 1px 2px rgba(0,0,0,0.5) !important;
+    }
+    .dark-theme .code {
+        background-color: #2A2A3C !important;
+        color: #FFFFFF !important;
+    }
+    </style>
+    
+    <script>
+    (function() {
+        function applyTheme() {
+            const themeToggle = document.getElementById('theme_toggle');
+            if (!themeToggle) return;
+            const inputs = themeToggle.querySelectorAll('input');
+            for (let input of inputs) {
+                if (input.checked && input.value === 'Dark') {
+                    document.body.classList.add('dark-theme');
+                    return;
+                }
+            }
+            document.body.classList.remove('dark-theme');
+        }
+        
+        function setupObserver() {
+            const themeToggle = document.getElementById('theme_toggle');
+            if (!themeToggle) {
+                setTimeout(setupObserver, 100);
+                return;
+            }
+            applyTheme();
+            const observer = new MutationObserver((mutations) => {
+                mutations.forEach((mutation) => {
+                    if (mutation.type === 'attributes' || mutation.type === 'childList') {
+                        applyTheme();
+                    }
+                });
+            });
+            observer.observe(themeToggle, { attributes: true, childList: true, subtree: true });
+            const inputs = themeToggle.querySelectorAll('input');
+            inputs.forEach(input => input.addEventListener('change', applyTheme));
+        }
+        
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', setupObserver);
+        } else {
+            setupObserver();
+        }
+    })();
+    </script>
+    """)
+
+    # Authentication Section
+    with gr.Group(elem_id="auth_box"):
+        gr.Markdown("## 🔑 Authentication")
+        with gr.Row(equal_height=True):
+            with gr.Column(scale=3):
+                hf_token = gr.Textbox(
+                    label="Hugging Face Token",
+                    placeholder="Enter your token here...",
+                    type="password",
+                    value=DEFAULT_HF_TOKEN,
+                    info="Get your token from https://huggingface.co/settings/tokens"
+                )
+            with gr.Column(scale=1):
+                auth_button = gr.Button("Authenticate", variant="primary")
+        auth_status = gr.Markdown("Please authenticate to use the model.")
+        
+        def authenticate(token):
+            return "⏳ Loading model... Please wait, this may take a minute."
+        
+        def auth_complete(token):
+            return load_model(token)
+        
+        auth_button.click(fn=authenticate, inputs=[hf_token], outputs=[auth_status], queue=False).then(
+            fn=auth_complete, inputs=[hf_token], outputs=[auth_status]
+        )
+        gr.Markdown(
+            """
+            ### How to get a token:
+            1. Go to [Hugging Face Token Settings](https://huggingface.co/settings/tokens)
+            2. Create a new token with read access
+            3. Accept the [Gemma model license](https://huggingface.co/google/gemma-3-4b-pt)
+            """
+        )
+
+    # [Remaining tabs and components remain unchanged for brevity]
+
+    # Footer
+    with gr.Group(elem_id="footer"):
+        gr.Markdown(
+            """
+            ## About Gemma
+            Gemma is a family of lightweight, state-of-the-art open models from Google...
+            [Learn more about Gemma](https://huggingface.co/google/gemma-3-4b-pt)
+            <div style="text-align: center; margin-top: 20px; padding: 10px;">
+                <p>© 2023 Gemma Capabilities Demo | Made with ❤️ using Gradio</p>
+            </div>
+            """
+        )
+
+# Launch the app
+demo.launch(share=False)