Update app.py

app.py

@@ -2,132 +2,105 @@ import gradio as gr
 import pandas as pd
 import tempfile
 import os
-from io import BytesIO
-import re
-import openai
-import hashlib
 import json
+import hashlib
 import asyncio
-import aiohttp
+from io import BytesIO
 from pathlib import Path
-from concurrent.futures import ThreadPoolExecutor
-from functools import lru_cache
-
+import openai
 import gradio_client.utils
 
-_original_json_schema_to_python_type = gradio_client.utils._json_schema_to_python_type
+"""NetCom → WooCommerce transformer (Try 1 schema)
+=================================================
+Drop a *Reseller Schedule* CSV and get back a WooCommerce‑ready CSV that matches
+`Try 1 - WooCommerce_Mapped_Data__Fixed_Attributes_and_Agenda_.csv` exactly –
+including `Stock` and `Sold individually?` columns that NetCom doesn’t supply.
+
+Highlights
+----------
+* Empty cells are skipped – no wasted GPT calls.
+* GPT‑4o mini used with a tiny disk cache (`ai_response_cache/`).
+* Brand → logo URLs hard‑coded below (update when media library changes).
+"""
+
+# ---------------------------------------------------------------------------
+# Gradio JSON‑schema helper hot‑patch (bool schema bug)
+# ---------------------------------------------------------------------------
+_original = gradio_client.utils._json_schema_to_python_type
 
 def _fixed_json_schema_to_python_type(schema, defs=None):
-    # If the schema is a bool, return a fallback type (e.g. "any")
-    if isinstance(schema, bool):
+    if isinstance(schema, bool):  # gradio 4.29 bug
         return "any"
-    return _original_json_schema_to_python_type(schema, defs)
+    return _original(schema, defs)
 
-gradio_client.utils._json_schema_to_python_type = _fixed_json_schema_to_python_type
+gradio_client.utils._json_schema_to_python_type = _fixed_json_schema_to_python_type  # type: ignore
 
+# ---------------------------------------------------------------------------
+# Tiny disk cache for OpenAI responses
+# ---------------------------------------------------------------------------
+CACHE_DIR = Path("ai_response_cache"); CACHE_DIR.mkdir(exist_ok=True)
 
-# Create cache directory if it doesn't exist
-CACHE_DIR = Path("ai_response_cache")
-CACHE_DIR.mkdir(exist_ok=True)
 
-def get_cache_path(prompt):
-    """Generate a unique cache file path based on the prompt content"""
-    prompt_hash = hashlib.md5(prompt.encode('utf-8')).hexdigest()
-    return CACHE_DIR / f"{prompt_hash}.json"
+def _cache_path(prompt: str) -> Path:
+    return CACHE_DIR / f"{hashlib.md5(prompt.encode()).hexdigest()}.json"
 
-def get_cached_response(prompt):
-    """Try to get a cached response for the given prompt"""
-    cache_path = get_cache_path(prompt)
-    if cache_path.exists():
-        try:
-            with open(cache_path, 'r', encoding='utf-8') as f:
-                return json.load(f)['response']
-        except Exception as e:
-            print(f"Error reading cache: {e}")
-    return None
 
-def cache_response(prompt, response):
-    """Cache the response for a given prompt"""
-    cache_path = get_cache_path(prompt)
+def _get_cached(prompt: str):
     try:
-        with open(cache_path, 'w', encoding='utf-8') as f:
-            json.dump({'prompt': prompt, 'response': response}, f)
-    except Exception as e:
-        print(f"Error writing to cache: {e}")
-
-
-async def process_text_batch_async(client, batch_prompts):
-    """Process a batch of prompts asynchronously"""
-    results = []
-    
-    # First check cache for each prompt
-    for prompt in batch_prompts:
-        cached = get_cached_response(prompt)
-        if cached:
-            results.append((prompt, cached))
-    
-    # Filter out prompts that were found in cache
-    uncached_prompts = [p for p in batch_prompts if not any(p == cached_prompt for cached_prompt, _ in results)]
-    
-    if uncached_prompts:
-        # Process uncached prompts in parallel
-        async def process_single_prompt(prompt):
-            try:
-                response = await client.chat.completions.create(
-                    model="gpt-4o-mini",
-                    messages=[{"role": "user", "content": prompt}],
-                    temperature=0
-                )
-                result = response.choices[0].message.content
-                # Cache the result
-                cache_response(prompt, result)
-                return prompt, result
-            except Exception as e:
-                print(f"Error processing prompt: {e}")
-                return prompt, f"Error: {str(e)}"
-        
-        # Create tasks for all uncached prompts
-        tasks = [process_single_prompt(prompt) for prompt in uncached_prompts]
-        
-        # Run all tasks concurrently and wait for them to complete
-        uncached_results = await asyncio.gather(*tasks)
-        
-        # Combine cached and newly processed results
-        results.extend(uncached_results)
-    
-    # Sort results to match original order of batch_prompts
-    prompt_to_result = {prompt: result for prompt, result in results}
-    return [prompt_to_result[prompt] for prompt in batch_prompts]
+        return json.loads(_cache_path(prompt).read_text("utf-8"))["response"]
+    except Exception:
+        return None
 
 
-async def process_text_with_ai_async(texts, instruction):
-    """Process text with GPT-4o-mini asynchronously in batches"""
-    if not texts:
-        return []
-        
-    results = []
-    batch_size = 500
-    
-    # Create OpenAI async client
+def _set_cache(prompt: str, rsp: str):
+    try:
+        _cache_path(prompt).write_text(json.dumps({"prompt": prompt, "response": rsp}), "utf-8")
+    except Exception:
+        pass
+
+# ---------------------------------------------------------------------------
+# Async GPT helpers
+# ---------------------------------------------------------------------------
+async def _gpt(client: openai.AsyncOpenAI, prompt: str) -> str:
+    cached = _get_cached(prompt)
+    if cached is not None:
+        return cached
+    try:
+        cmp = await client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0,
+        )
+        txt = cmp.choices[0].message.content
+    except Exception as e:
+        txt = f"Error: {e}"
+    _set_cache(prompt, txt)
+    return txt
+
+
+async def _batch(texts: list[str], instruction: str) -> list[str]:
+    """Return len(texts) list. Blank inputs remain blank."""
+    res = ["" for _ in texts]
+    idx, prompts = [], []
+    for i, t in enumerate(texts):
+        if isinstance(t, str) and t.strip():
+            idx.append(i); prompts.append(f"{instruction}\n\nText: {t}")
+    if not prompts:
+        return res
     client = openai.AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-    
-    # Process in batches
-    for i in range(0, len(texts), batch_size):
-        batch = texts[i:i+batch_size]
-        batch_prompts = [f"{instruction}\n\nText: {text}" for text in batch]
-        
-        batch_results = await process_text_batch_async(client, batch_prompts)
-        results.extend(batch_results)
-    
-    return results
+    tasks = [_gpt(client, p) for p in prompts]
+    outs = await asyncio.gather(*tasks)
+    for k, v in enumerate(outs):
+        res[idx[k]] = v
+    return res
 
+# ---------------------------------------------------------------------------
+# Main converter
+# ---------------------------------------------------------------------------
 
 def process_woocommerce_data_in_memory(netcom_file):
-    """
-    Reads the uploaded NetCom CSV file in-memory, processes it to the WooCommerce format,
-    and returns the resulting CSV as bytes, suitable for download.
-    """
-    # Define the brand-to-logo mapping with updated URLs
+    """Return BytesIO of Woo CSV."""
+    # Brand logos
     brand_logo_map = {
         "Amazon Web Services": "/wp-content/uploads/2025/04/aws.png",
         "Cisco": "/wp-content/uploads/2025/04/cisco-e1738593292198-1.webp",
@@ -139,225 +112,123 @@ def process_woocommerce_data_in_memory(netcom_file):
         "Comptia": "/wp-content/uploads/2025/04/Comptia.png",
         "Autodesk": "/wp-content/uploads/2025/04/autodesk.png",
         "ISC2": "/wp-content/uploads/2025/04/ISC2.png",
-        "AICerts": "/wp-content/uploads/2025/04/aicerts-logo-1.png"
+        "AICerts": "/wp-content/uploads/2025/04/aicerts-logo-1.png",
     }
-
-    # Default prerequisite text for courses without prerequisites
-    default_prerequisite = "No specific prerequisites are required for this course. Basic computer literacy and familiarity with fundamental concepts in the subject area are recommended for the best learning experience."
-
-    # 1. Read the uploaded CSV into a DataFrame
-    netcom_df = pd.read_csv(netcom_file.name, encoding='latin1')
-    netcom_df.columns = netcom_df.columns.str.strip()  # standardize column names
-    
-    # Prepare descriptions for AI processing
-    descriptions = netcom_df['Decription'].fillna("").tolist()
-    objectives = netcom_df['Objectives'].fillna("").tolist()
-    prerequisites = netcom_df['RequiredPrerequisite'].fillna("").tolist()
-    agendas = netcom_df['Outline'].fillna("").tolist()
-    
-    # Process with AI asynchronously
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    
-    # Run all processing tasks concurrently
-    tasks = [
-        process_text_with_ai_async(
-            descriptions, 
-            "Create a concise 250-character summary of this course description:"
-        ),
-        process_text_with_ai_async(
-            descriptions, 
-            "Condense this description to maximum 750 characters in paragraph format, with clean formatting:"
-        ),
-        process_text_with_ai_async(
-            objectives, 
-            "Format these objectives into a bullet list format with clean formatting. Start each bullet with '• ':"
-        ),
-        process_text_with_ai_async(
-            agendas, 
-            "Format this agenda into a bullet list format with clean formatting. Start each bullet with '• ':"
-        )
-    ]
-    
-    # Process prerequisites separately to handle default case
-    formatted_prerequisites_task = []
-    for prereq in prerequisites:
-        if not prereq or pd.isna(prereq) or prereq.strip() == "":
-            formatted_prerequisites_task.append(default_prerequisite)
-        else:
-            # For non-empty prerequisites, we'll process them with AI
-            prereq_result = loop.run_until_complete(process_text_with_ai_async(
-                [prereq], 
-                "Format these prerequisites into a bullet list format with clean formatting. Start each bullet with '• ':"
-            ))
-            formatted_prerequisites_task.append(prereq_result[0])
-    
-    # Run all tasks and get results
-    results = loop.run_until_complete(asyncio.gather(*tasks))
-    loop.close()
-    
-    short_descriptions, condensed_descriptions, formatted_objectives, formatted_agendas = results
-    
-    # Add processed text to dataframe
-    netcom_df['Short_Description'] = short_descriptions
-    netcom_df['Condensed_Description'] = condensed_descriptions
-    netcom_df['Formatted_Objectives'] = formatted_objectives
-    netcom_df['Formatted_Prerequisites'] = formatted_prerequisites_task
-    netcom_df['Formatted_Agenda'] = formatted_agendas
-
-    # 2. Create aggregated dates and times for each Course ID
-    # Sort by Course ID and date first
-    netcom_df = netcom_df.sort_values(['Course ID', 'Course Start Date'])
-    
-    date_agg = (
-        netcom_df.groupby('Course ID')['Course Start Date']
-        .apply(lambda x: ','.join(x.astype(str).unique()))
-        .reset_index(name='Aggregated_Dates')
-    )
-
-    time_agg = (
-        netcom_df.groupby('Course ID')
-        .apply(
-            lambda df: ','.join(
-                f"{st}-{et} {tz}"
-                for st, et, tz in zip(df['Course Start Time'], 
-                                      df['Course End Time'], 
-                                      df['Time Zone'])
-            )
-        )
-        .reset_index(name='Aggregated_Times')
+    default_prereq = (
+        "No specific prerequisites are required for this course. "
+        "Basic computer literacy and familiarity with fundamental concepts in the subject area are recommended for the best learning experience."
     )
-
-    # 3. Extract unique parent products
-    parent_products = netcom_df.drop_duplicates(subset=['Course ID'])
-
-    # 4. Merge aggregated dates and times
-    parent_products = parent_products.merge(date_agg, on='Course ID', how='left')
-    parent_products = parent_products.merge(time_agg, on='Course ID', how='left')
-
-    # 5. Create parent (variable) products
-    woo_parent_df = pd.DataFrame({
-        'Type': 'variable',
-        'SKU': parent_products['Course ID'],
-        'Name': parent_products['Course Name'],
-        'Published': 1,
-        'Visibility in catalog': 'visible',
-        'Short description': parent_products['Short_Description'],
-        'Description': parent_products['Condensed_Description'],
-        'Tax status': 'taxable',
-        'In stock?': 1,
-        'Regular price': parent_products['SRP Pricing'].replace('[\$,]', '', regex=True),
-        'Categories': 'courses',
-        'Images': parent_products['Vendor'].map(brand_logo_map).fillna(''),
-        'Parent': '',
-        'Brands': parent_products['Vendor'],
-        'Attribute 1 name': 'Date',
-        'Attribute 1 value(s)': parent_products['Aggregated_Dates'],
-        'Attribute 1 visible': 'visible',
-        'Attribute 1 global': 1,
-        'Attribute 2 name': 'Location',
-        'Attribute 2 value(s)': 'Virtual',
-        'Attribute 2 visible': 'visible',
-        'Attribute 2 global': 1,
-        'Attribute 3 name': 'Time',
-        'Attribute 3 value(s)': parent_products['Aggregated_Times'],
-        'Attribute 3 visible': 'visible',
-        'Attribute 3 global': 1,
-        'Meta: outline': parent_products['Formatted_Agenda'],
-        'Meta: days': parent_products['Duration'],
-        'Meta: location': 'Virtual',
-        'Meta: overview': parent_products['Target Audience'],
-        'Meta: objectives': parent_products['Formatted_Objectives'],
-        'Meta: prerequisites': parent_products['Formatted_Prerequisites'],
-        'Meta: agenda': parent_products['Formatted_Agenda']
+    # Load NetCom CSV
+    df = pd.read_csv(netcom_file.name, encoding="latin1"); df.columns = df.columns.str.strip()
+    def _col(opts):
+        return next((c for c in opts if c in df.columns), None)
+    # Column aliases
+    col_desc = _col(["Description", "Decription"])
+    col_obj  = _col(["Objectives", "objectives"])
+    col_pre  = _col(["RequiredPrerequisite", "Required Pre-requisite"])
+    col_out  = _col(["Outline"])
+    col_dur  = _col(["Duration"])
+    col_sid  = _col(["Course SID", "Course SID"])
+    if col_dur is None:
+        df["Duration"] = ""; col_dur = "Duration"
+    # AI prep lists
+    descs, objs, pres, outs = (df.get(c, pd.Series([""]*len(df))).fillna("").tolist() for c in (col_desc, col_obj, col_pre, col_out))
+    loop = asyncio.new_event_loop(); asyncio.set_event_loop(loop)
+    short_d, long_d, fmt_obj, fmt_out = loop.run_until_complete(asyncio.gather(
+        _batch(descs, "Create a concise 250-character summary of this course description:"),
+        _batch(descs, "Condense this description to a maximum of 750 characters in paragraph format, with clean formatting:"),
+        _batch(objs,  "Format these objectives into a bullet list with clean formatting. Start each bullet with '• ':"),
+        _batch(outs,  "Format this agenda into a bullet list with clean formatting. Start each bullet with '• ':"),
+    )); loop.close()
+    fmt_pre = [default_prereq if not str(p).strip() else asyncio.run(_batch([p], "Format these prerequisites into a bullet list with clean formatting. Start each bullet with '• ':"))[0] for p in pres]
+    # Attach processed cols
+    df["Short_Description"] = short_d; df["Condensed_Description"] = long_d
+    df["Formatted_Objectives"] = fmt_obj; df["Formatted_Agenda"] = fmt_out; df["Formatted_Prerequisites"] = fmt_pre
+    # Dates
+    df["Course Start Date"] = pd.to_datetime(df["Course Start Date"], errors="coerce")
+    df["Date_fmt"] = df["Course Start Date"].dt.strftime("%-m/%-d/%Y")
+    df_sorted = df.sort_values(["Course ID", "Course Start Date"])
+    date_agg = df_sorted.groupby("Course ID")["Date_fmt"].apply(lambda s: ",".join(s.dropna().unique())).reset_index(name="Aggregated_Dates")
+    time_agg = df_sorted.groupby("Course ID").apply(lambda g: ",".join(f"{st}-{et} {tz}" for st, et, tz in zip(g["Course Start Time"], g["Course End Time"], g["Time Zone"]))).reset_index(name="Aggregated_Times")
+    parents = df_sorted.drop_duplicates("Course ID").merge(date_agg).merge(time_agg)
+    # Parent rows
+    woo_parent = pd.DataFrame({
+        "Type": "variable",
+        "SKU": parents["Course ID"],
+        "Name": parents["Course Name"],
+        "Published": 1,
+        "Visibility in catalog": "visible",
+        "Short description": parents["Short_Description"],
+        "Description": parents["Condensed_Description"],
+        "Tax status": "taxable",
+        "In stock?": 1,
+        "Stock": 1,
+        "Sold individually?": 1,
+        "Regular price": parents["SRP Pricing"].replace("[\\$,]", "", regex=True),
+        "Categories": "courses",
+        "Images": parents["Vendor"].map(brand_logo_map).fillna(""),
+        "Parent": "",
+        "Brands": parents["Vendor"],
+        # Attributes
+        "Attribute 1 name": "Date", "Attribute 1 value(s)": parents["Aggregated_Dates"], "Attribute 1 visible": "visible", "Attribute 1 global": 1,
+        "Attribute 2 name": "Location", "Attribute 2 value(s)": "Virtual", "Attribute 2 visible": "visible", "Attribute 2 global": 1,
+        "Attribute 3 name": "Time", "Attribute 3 value(s)": parents["Aggregated_Times"], "Attribute 3 visible": "visible", "Attribute 3 global": 1,
+        # Meta
+        "Meta: outline": parents["Formatted_Agenda"], "Meta: days": parents[col_dur], "Meta: location": "Virtual",
+        "Meta: overview": parents["Target Audience"], "Meta: objectives": parents["Formatted_Objectives"],
+        "Meta: prerequisites": parents["Formatted_Prerequisites"], "Meta: agenda": parents["Formatted_Agenda"],
     })
-
-    # 6. Create child (variation) products
-    woo_child_df = pd.DataFrame({
-        'Type': 'variation, virtual',
-        'SKU': netcom_df['Course SID'],
-        'Name': netcom_df['Course Name'],
-        'Published': 1,
-        'Visibility in catalog': 'visible',
-        'Short description': netcom_df['Short_Description'],
-        'Description': netcom_df['Condensed_Description'],
-        'Tax status': 'taxable',
-        'In stock?': 1,
-        'Regular price': netcom_df['SRP Pricing'].replace('[\$,]', '', regex=True),
-        'Categories': 'courses',
-        'Images': netcom_df['Vendor'].map(brand_logo_map).fillna(''),
-        'Parent': netcom_df['Course ID'],
-        'Brands': netcom_df['Vendor'],
-        'Attribute 1 name': 'Date',
-        'Attribute 1 value(s)': netcom_df['Course Start Date'],
-        'Attribute 1 visible': 'visible',
-        'Attribute 1 global': 1,
-        'Attribute 2 name': 'Location',
-        'Attribute 2 value(s)': 'Virtual',
-        'Attribute 2 visible': 'visible',
-        'Attribute 2 global': 1,
-        'Attribute 3 name': 'Time',
-        'Attribute 3 value(s)': netcom_df.apply(
-            lambda row: f"{row['Course Start Time']}-{row['Course End Time']} {row['Time Zone']}", axis=1
-        ),
-        'Attribute 3 visible': 'visible',
-        'Attribute 3 global': 1,
-        'Meta: outline': netcom_df['Formatted_Agenda'],
-        'Meta: days': netcom_df['Duration'],
-        'Meta: location': 'Virtual',
-        'Meta: overview': netcom_df['Target Audience'],
-        'Meta: objectives': netcom_df['Formatted_Objectives'],
-        'Meta: prerequisites': netcom_df['Formatted_Prerequisites'],
-        'Meta: agenda': netcom_df['Formatted_Agenda']
+    # Child rows
+    woo_child = pd.DataFrame({
+        "Type": "variation, virtual",
+        "SKU": df_sorted[col_sid].astype(str).str.strip(),
+        "Name": df_sorted["Course Name"],
+        "Published": 1,
+        "Visibility in catalog": "visible",
+        "Short description": df_sorted["Short_Description"],
+        "Description": df_sorted["Condensed_Description"],
+        "Tax status": "taxable",
+        "In stock?": 1,
+        "Stock": 1,
+        "Sold individually?": 1,
+        "Regular price": df_sorted["SRP Pricing"].replace("[\\$,]", "", regex=True),
+        "Categories": "courses",
+        "Images": df_sorted["Vendor"].map(brand_logo_map).fillna(""),
+        "Parent": df_sorted["Course ID"],
+        "Brands": df_sorted["Vendor"],
+        "Attribute 1 name": "Date", "Attribute 1 value(s)": df_sorted["Date_fmt"], "Attribute 1 visible": "visible", "Attribute 1 global": 1,
+        "Attribute 2 name": "Location", "Attribute 2 value(s)": "Virtual", "Attribute 2 visible": "visible", "Attribute 2 global": 1,
+        "Attribute 3 name": "Time", "Attribute 3 value(s)": df_sorted.apply(lambda r: f"{r['Course Start Time']}-{r['Course End Time']} {r['Time Zone']}", axis=1), "Attribute 3 visible": "visible", "Attribute 3 global": 1,
+        "Meta: outline": df_sorted["Formatted_Agenda"], "Meta: days": df_sorted[col_dur], "Meta: location": "Virtual",
+        "Meta: overview": df_sorted["Target Audience"], "Meta: objectives": df_sorted["Formatted_Objectives"],
+        "Meta: prerequisites": df_sorted["Formatted_Prerequisites"], "Meta: agenda": df_sorted["Formatted_Agenda"],
     })
-
-    # 7. Combine parent + child
-    woo_final_df = pd.concat([woo_parent_df, woo_child_df], ignore_index=True)
-
-    # 8. Desired column order (removed Stock and Sold individually?)
+    # Combine & order
+    combined = pd.concat([woo_parent, woo_child], ignore_index=True)
     column_order = [
-        'Type', 'SKU', 'Name', 'Published', 'Visibility in catalog',
-        'Short description', 'Description', 'Tax status', 'In stock?',
-        'Regular price', 'Categories', 'Images',
-        'Parent', 'Brands', 'Attribute 1 name', 'Attribute 1 value(s)', 'Attribute 1 visible',
-        'Attribute 1 global', 'Attribute 2 name', 'Attribute 2 value(s)', 'Attribute 2 visible',
-        'Attribute 2 global', 'Attribute 3 name', 'Attribute 3 value(s)', 'Attribute 3 visible',
-        'Attribute 3 global', 'Meta: outline', 'Meta: days', 'Meta: location', 'Meta: overview',
-        'Meta: objectives', 'Meta: prerequisites', 'Meta: agenda'
+        "Type","SKU","Name","Published","Visibility in catalog","Short description","Description","Tax status","In stock?","Stock","Sold individually?","Regular price","Categories","Images","Parent","Brands", "Attribute 1 name","Attribute 1 value(s)","Attribute 1 visible","Attribute 1 global","Attribute 2 name","Attribute 2 value(s)","Attribute 2 visible","Attribute 2 global","Attribute 3 name","Attribute 3 value(s)","Attribute 3 visible","Attribute 3 global","Meta: outline","Meta: days","Meta: location","Meta: overview","Meta: objectives","Meta: prerequisites","Meta: agenda"
     ]
-    woo_final_df = woo_final_df[column_order]
+    combined = combined[column_order]
+    buf = BytesIO(); combined.to_csv(buf, index=False, encoding="utf-8-sig"); buf.seek(0); return buf
+
+# ---------------------------------------------------------------------------
+# Gradio wrapper
+# ---------------------------------------------------------------------------
 
-    # 9. Convert to CSV (in memory)
-    output_buffer = BytesIO()
-    woo_final_df.to_csv(output_buffer, index=False, encoding='utf-8-sig')
-    output_buffer.seek(0)
-    
-    return output_buffer
+def process_file(upload):
+    return process_woocommerce_data_in_memory(upload)
 
-def process_file(uploaded_file):
-    """
-    Takes the uploaded file, processes it, and returns the CSV as a file-like object
-    """
-    processed_csv_io = process_woocommerce_data_in_memory(uploaded_file)
-    
-    # Create a temporary file to save the CSV data
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as temp_file:
-        temp_file.write(processed_csv_io.getvalue())
-        temp_path = temp_file.name
-    
-    return temp_path
 
 interface = gr.Interface(
     fn=process_file,
     inputs=gr.File(label="Upload NetCom CSV", file_types=[".csv"]),
     outputs=gr.File(label="Download WooCommerce CSV"),
-    title="NetCom to WooCommerce CSV Processor",
-    description="Upload your NetCom Reseller Schedule CSV to generate the WooCommerce import-ready CSV.",
+    title="NetCom → WooCommerce CSV Processor",
+    description="Upload a NetCom Reseller Schedule CSV to generate a WooCommerce‑import CSV (Try 1 schema).",
     analytics_enabled=False,
 )
 
 if __name__ == "__main__":
-    openai_api_key = os.getenv("OPENAI_API_KEY")
-    if not openai_api_key:
-        print("Warning: OPENAI_API_KEY environment variable not set")
-    interface.launch()
+    if not os.getenv("OPENAI_API_KEY"):
+        print("⚠️  OPENAI_API_KEY not set – AI paraphrasing will error out")
+    interface.launch()