Updated code with cursor

app.py

@@ -1,70 +1,250 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
+import pandas as pd
+import json
+import os
+from datetime import datetime
 
+# Custom system instructions for business category descriptions
+SYSTEM_INSTRUCTIONS = """You are an expert at writing clear and visual descriptions for a business category keyword for a yellow pages or business listing website. Given a category keyword, generate a single, detailed description that defines its key visual elements, location, and context. Do not add artistic or stylistic flair. Ensure that the description is CLIP model ready and not too verbose.
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+Here are some examples of the correct format:
 
-    messages = [{"role": "system", "content": system_message}]
+Category: "Car Rental For Self Driven"
 
-    messages.extend(history)
+Description: "a car available for self-drive rental, parked at a pickup spot without a chauffeur; looks travel-ready, clean, well-maintained, keys handed over to customer"
 
-    messages.append({"role": "user", "content": message})
+Category: "Mehandi"
 
-    response = ""
+Description: "Temporary henna artwork applied on hands and feet using cones; fine brown or maroon floral and paisley patterns, mandalas, and lace-like detailing, commonly seen at weddings and festivals."
+
+Category: "Photographer"
+
+Description: "a person actively shooting photos or posing with a camera; holding a camera to eye, adjusting lens, or directing a subject during a shoot"
+
+Category: "Equipment"
+
+Description: "lighting stands, softboxes, strobes, tripods, reflectors, gimbals, battery packs, memory cards arranged as gear kits"
+
+---
+
+Now, I will provide a new category. Output the category name and Description in json format."""
 
+
+def process_single_category(category, client, max_tokens, temperature, top_p):
+    """Process a single category keyword and return the description."""
+    messages = [
+        {"role": "system", "content": SYSTEM_INSTRUCTIONS},
+        {"role": "user", "content": f"Category: {category}"}
+    ]
+    
+    response = ""
     for message in client.chat_completion(
         messages,
         max_tokens=max_tokens,
-        stream=True,
+        stream=False,
         temperature=temperature,
         top_p=top_p,
     ):
         choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
+        if len(choices) and choices[0].message.content:
+            response = choices[0].message.content
+            break
+    
+    return response
+
+
+def process_csv_files(
+    files,
+    category_column,
+    max_tokens,
+    temperature,
+    top_p,
+    hf_token: gr.OAuthToken,
+    progress=gr.Progress()
+):
+    """
+    Process multiple CSV files and generate descriptions for category keywords.
+    """
+    if not files or len(files) == 0:
+        return "Please upload at least one CSV file.", None
+    
+    if not hf_token or not hf_token.token:
+        return "Please login with your Hugging Face account.", None
+    
+    client = InferenceClient(token=hf_token.token, model="meta-llama/Llama-3.3-70B-Instruct")
+    
+    output_files = []
+    status_messages = []
+    
+    for file_idx, file in enumerate(files):
+        try:
+            # Read CSV file
+            df = pd.read_csv(file.name)
+            status_messages.append(f"📄 Processing file {file_idx + 1}/{len(files)}: {os.path.basename(file.name)}")
+            
+            # Check if category column exists
+            if category_column not in df.columns:
+                status_messages.append(f"⚠️ Warning: Column '{category_column}' not found in {os.path.basename(file.name)}. Available columns: {', '.join(df.columns)}")
+                continue
+            
+            # Process each category
+            descriptions = []
+            raw_responses = []
+            
+            categories = df[category_column].dropna().unique()
+            total_categories = len(categories)
+            
+            for idx, category in enumerate(categories):
+                progress((file_idx * total_categories + idx) / (len(files) * total_categories), 
+                        desc=f"Processing category {idx + 1}/{total_categories} in file {file_idx + 1}")
+                
+                try:
+                    response = process_single_category(
+                        category, client, max_tokens, temperature, top_p
+                    )
+                    raw_responses.append(response)
+                    
+                    # Try to parse JSON response
+                    try:
+                        # Extract JSON from response if wrapped in markdown code blocks
+                        if "```json" in response:
+                            json_str = response.split("```json")[1].split("```")[0].strip()
+                        elif "```" in response:
+                            json_str = response.split("```")[1].split("```")[0].strip()
+                        else:
+                            json_str = response.strip()
+                        
+                        parsed = json.loads(json_str)
+                        description = parsed.get("Description", parsed.get("description", ""))
+                    except:
+                        # If JSON parsing fails, use the raw response
+                        description = response
+                    
+                    descriptions.append({
+                        "Category": category,
+                        "Description": description,
+                        "Raw_Response": response
+                    })
+                    
+                except Exception as e:
+                    status_messages.append(f"⚠️ Error processing category '{category}': {str(e)}")
+                    descriptions.append({
+                        "Category": category,
+                        "Description": f"Error: {str(e)}",
+                        "Raw_Response": ""
+                    })
+            
+            # Create output dataframe
+            output_df = pd.DataFrame(descriptions)
+            
+            # Save to file
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            base_name = os.path.splitext(os.path.basename(file.name))[0]
+            output_filename = f"output_{base_name}_{timestamp}.csv"
+            output_df.to_csv(output_filename, index=False)
+            output_files.append(output_filename)
+            
+            status_messages.append(f"✅ Completed: {len(descriptions)} categories processed from {os.path.basename(file.name)}")
+            
+        except Exception as e:
+            status_messages.append(f"❌ Error processing {os.path.basename(file.name)}: {str(e)}")
+    
+    status_text = "\n".join(status_messages)
+    
+    if output_files:
+        return status_text, output_files
+    else:
+        return status_text + "\n\n❌ No output files generated.", None
+
+
+# Create Gradio interface
+with gr.Blocks(title="Business Category Description Generator") as demo:
+    gr.Markdown("""
+    # 🏢 Business Category Description Generator
+    
+    Upload CSV files containing business category keywords, and this app will generate 
+    CLIP-ready visual descriptions for each category using AI.
+    
+    **Instructions:**
+    1. Login with your Hugging Face account (required)
+    2. Upload one or more CSV files
+    3. Specify the column name that contains the category keywords
+    4. Click "Process Files" to generate descriptions
+    5. Download the output CSV files
+    """)
+    
     with gr.Sidebar():
         gr.LoginButton()
-    chatbot.render()
-
+        gr.Markdown("### Model Settings")
+        max_tokens = gr.Slider(
+            minimum=64, 
+            maximum=512, 
+            value=256, 
+            step=16, 
+            label="Max Tokens"
+        )
+        temperature = gr.Slider(
+            minimum=0.1, 
+            maximum=1.0, 
+            value=0.7, 
+            step=0.1, 
+            label="Temperature"
+        )
+        top_p = gr.Slider(
+            minimum=0.1, 
+            maximum=1.0, 
+            value=0.9, 
+            step=0.05, 
+            label="Top-p"
+        )
+    
+    with gr.Row():
+        with gr.Column():
+            files_input = gr.File(
+                label="Upload CSV Files",
+                file_count="multiple",
+                file_types=[".csv"]
+            )
+            category_column = gr.Textbox(
+                label="Category Column Name",
+                value="category",
+                placeholder="Enter the name of the column containing categories"
+            )
+            process_btn = gr.Button("🚀 Process Files", variant="primary", size="lg")
+        
+        with gr.Column():
+            status_output = gr.Textbox(
+                label="Status",
+                lines=10,
+                interactive=False
+            )
+            files_output = gr.File(
+                label="Download Output Files",
+                file_count="multiple"
+            )
+    
+    process_btn.click(
+        fn=process_csv_files,
+        inputs=[
+            files_input,
+            category_column,
+            max_tokens,
+            temperature,
+            top_p,
+            gr.OAuthToken()
+        ],
+        outputs=[status_output, files_output]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 📝 Output Format
+    Each output CSV file will contain:
+    - **Category**: The original category keyword
+    - **Description**: The generated visual description
+    - **Raw_Response**: The complete model response (including JSON)
+    """)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()