Update app.py

app.py

@@ -3,8 +3,9 @@ import io
 import csv
 import time
 import threading
+import requests
 from datetime import datetime, timezone
-from typing import Optional, Tuple
+from typing import Dict, Optional, Tuple
 
 import gradio as gr
 from huggingface_hub import HfApi
@@ -16,7 +17,10 @@ DATASET_REPO_ID = os.environ.get("DATASET_REPO_ID") # Space secret
 HF_TOKEN = os.environ["HF_TOKEN"]          # Space secret
 
 KEYS_PATH = "keys.csv"
-B_KEYS_PATH = "b_keys.csv"
+SENT_PATH = "sent.csv"
+
+# Maximum keys per order = quantity * KEYS_PER_QUANTITY
+KEYS_PER_QUANTITY = 10
 
 
 api = HfApi(token=HF_TOKEN)
@@ -26,7 +30,7 @@ _lock = threading.Lock()
 _cache = {
     "ts": 0.0,
     "keys": None,  # type: ignore
-    "b_keys": None,  # type: ignore
+    "sent": None,  # type: ignore
 }
 CACHE_TTL_SEC = 10.0
 
@@ -68,17 +72,6 @@ def _parse_keys(csv_text: str) -> list:
             })
     return keys
 
-def _parse_b_keys(csv_text: str) -> list:
-    keys = []
-    reader = csv.DictReader(io.StringIO(csv_text))
-    for r in reader:
-        if r["key"].strip():
-            keys.append({
-                "key": r["key"].strip(),
-                "count": int(r.get("count") or "0"),
-            })
-    return keys
-
 def _serialize_keys(keys: list) -> str:
     out = io.StringIO()
     fieldnames = ["key", "sent"]
@@ -91,128 +84,93 @@ def _serialize_keys(keys: list) -> str:
         })
     return out.getvalue()
 
-def _serialize_b_keys(keys: list) -> str:
+def _parse_sent(csv_text: str) -> dict:
+    """Parse sent.csv and return a dict keyed by order_number"""
+    sent = {}
+    reader = csv.DictReader(io.StringIO(csv_text))
+    for r in reader:
+        order_num = r["order_number"].strip()
+        if order_num:
+            keys_sent_str = r.get("keys_sent", "").strip()
+            quantity_keys_sent_str = r.get("quantity_keys_sent", "").strip()
+
+            sent[order_num] = {
+                "order_number": order_num,
+                "quantity": int(r.get("quantity", "0")),
+                "keys_sent": keys_sent_str if keys_sent_str else "",
+                "quantity_keys_sent": int(quantity_keys_sent_str) if quantity_keys_sent_str else 0,
+            }
+    return sent
+
+def _serialize_sent(sent_dict: dict) -> str:
+    """Serialize sent dict back to CSV format"""
     out = io.StringIO()
-    fieldnames = ["key", "count"]
+    fieldnames = ["order_number", "quantity", "keys_sent", "quantity_keys_sent"]
     w = csv.DictWriter(out, fieldnames=fieldnames)
     w.writeheader()
-    for k in keys:
+    for order_num in sorted(sent_dict.keys()):
+        entry = sent_dict[order_num]
         w.writerow({
-            "key": k["key"],
-            "count": k.get("count", 0),
+            "order_number": entry["order_number"],
+            "quantity": entry["quantity"],
+            "keys_sent": entry.get("keys_sent", ""),
+            "quantity_keys_sent": entry.get("quantity_keys_sent", 0),
         })
     return out.getvalue()
 
 def load_state(force: bool = False):
     now = time.time()
     if (not force) and _cache["keys"] is not None and (now - _cache["ts"] < CACHE_TTL_SEC):
-        return _cache["keys"], _cache["b_keys"]
+        return _cache["keys"], _cache["sent"]
 
     keys_csv = _download_csv(DATASET_REPO_ID, KEYS_PATH)
-    b_keys_csv = _download_csv(DATASET_REPO_ID, B_KEYS_PATH)
+    sent_csv = _download_csv(DATASET_REPO_ID, SENT_PATH)
 
     keys = _parse_keys(keys_csv)
-    b_keys = _parse_b_keys(b_keys_csv)
+    sent = _parse_sent(sent_csv)
 
     _cache["ts"] = now
     _cache["keys"] = keys
-    _cache["b_keys"] = b_keys
-    return keys, b_keys
+    _cache["sent"] = sent
+    return keys, sent
 
 # -------------------------
 # Core API
 # -------------------------
-def claim_key(
+def claim_c_key(
+    order_number: str,
     request: Optional[gr.Request] = None,
 ) -> Tuple[str, str]:
     """
-    Returns the next available key.
+    Returns a key for a given order number if the order is valid
+    and hasn't exceeded the allowed key limit (quantity * KEYS_PER_QUANTITY).
     Returns (key, status_message)
     """
     _ = request
 
-    with _lock:
-        keys, _ = load_state(force=True)
-
-        # Find available keys
-        available_keys = [k for k in keys if not k["sent"]]
-
-        if len(available_keys) < 1:
-            return "", "No available keys remaining."
-
-        # Send the next available key
-        key_to_send = available_keys[0]
-
-        # Mark key as sent
-        key_to_send["sent"] = _utc_now_iso()
-
-        # Save changes
-        updated_keys_csv = _serialize_keys(keys)
-
-        _upload_csv(
-            DATASET_REPO_ID,
-            KEYS_PATH,
-            updated_keys_csv,
-            commit_message=f"Key sent at {_utc_now_iso()}",
-        )
-
-        # refresh cache immediately
-        _cache["ts"] = 0.0
-
-        return key_to_send["key"], "Key sent successfully."
+    order_number = order_number.strip()
 
-def claim_b_key(
-    request: Optional[gr.Request] = None,
-) -> Tuple[str, str]:
-    """
-    Returns the  key and increments the usage count.
-    Returns (b_key, status_message)
-    """
-    _ = request
+    if not order_number:
+        return "", "Please provide an order number."
 
     with _lock:
-        keys, b_keys = load_state(force=True)
+        keys, sent = load_state(force=True)
 
-        if not b_keys or len(b_keys) == 0:
-            return "", "No keys available."
+        # Check if order exists in sent.csv
+        if order_number not in sent:
+            return "", f"Order number {order_number} not found."
 
-        # Get the first key (you can add logic to rotate if needed)
-        b_key = b_keys[0]
+        quantity = sent[order_number]["quantity"]
 
-        # Increment the count
-        b_key["count"] += 1
+        # Check how many keys have been sent for this order
+        keys_already_sent = sent[order_number]["quantity_keys_sent"]
 
-        # Save changes
-        updated_b_keys_csv = _serialize_b_keys(b_keys)
+        # Calculate maximum allowed keys
+        max_keys = quantity * KEYS_PER_QUANTITY
 
-        _upload_csv(
-            DATASET_REPO_ID,
-            B_KEYS_PATH,
-            updated_b_keys_csv,
-            commit_message=f"Key requested at {_utc_now_iso()}",
-        )
-
-        # refresh cache immediately
-        _cache["ts"] = 0.0
-
-        return b_key["key"], f"Key provided."
-
-def claim_key_authenticated(
-    profile: Optional[gr.OAuthProfile] = None,
-) -> Tuple[str, str]:
-    """
-    OAuth-protected endpoint that returns the next available key.
-    Requires user to be authenticated via Hugging Face OAuth.
-    Returns (key, status_message)
-    """
-    # Check if user is authenticated
-    if profile is None:
-        return "", "Authentication required. Please sign in with your Hugging Face account."
-
-    username = profile.username
-
-    with _lock:
-        keys, _ = load_state(force=True)
+        # Check if limit has been reached
+        if keys_already_sent >= max_keys:
+            return "", f"Key limit reached for order {order_number} ({keys_already_sent}/{max_keys} keys sent)."
 
         # Find available keys
         available_keys = [k for k in keys if not k["sent"]]
@@ -223,126 +181,86 @@ def claim_key_authenticated(
         # Send the next available key
         key_to_send = available_keys[0]
 
-        # Mark key as sent with user info
-        key_to_send["sent"] = f"{_utc_now_iso()} (user: {username})"
+        # Create ephemeral OpenAI key using the Realtime API (expires in 1 hour)
+        try:
+            response = requests.post(
+                "https://api.openai.com/v1/realtime/client_secrets",
+                headers={
+                    "Authorization": f"Bearer {key_to_send['key']}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "expires_after": {
+                        "anchor": "created_at",
+                        "seconds": 3600  # 1 hour
+                    },
+                    "session": {
+                        "type": "realtime",
+                        "model": "gpt-realtime",
+                        "audio": {
+                            "output": {"voice": "alloy"}
+                        }
+                    }
+                }
+            )
+            response.raise_for_status()
+            ephemeral_data = response.json()
+            ephemeral_key = ephemeral_data["value"]
+        except Exception as e:
+            return "", f"Failed to create ephemeral key: {str(e)}"
 
-        # Save changes
+        # Mark key as sent
+        key_to_send["sent"] = _utc_now_iso()
+
+        # Update sent.csv - store the ephemeral key
+        existing_keys = sent[order_number]["keys_sent"]
+        if existing_keys:
+            sent[order_number]["keys_sent"] = existing_keys + "," + ephemeral_key
+        else:
+            sent[order_number]["keys_sent"] = ephemeral_key
+        sent[order_number]["quantity_keys_sent"] += 1
+
+        # Save changes to both files
         updated_keys_csv = _serialize_keys(keys)
+        updated_sent_csv = _serialize_sent(sent)
 
         _upload_csv(
             DATASET_REPO_ID,
             KEYS_PATH,
             updated_keys_csv,
-            commit_message=f"Key sent to {username} at {_utc_now_iso()}",
+            commit_message=f"Key sent for order {order_number} at {_utc_now_iso()}",
         )
 
-        # refresh cache immediately
-        _cache["ts"] = 0.0
-
-        return key_to_send["key"], f"Key sent successfully to {username}."
-
-def claim_b_key_authenticated(
-    profile: Optional[gr.OAuthProfile] = None,
-) -> Tuple[str, str]:
-    """
-    OAuth-protected endpoint that returns the B key and increments the usage count.
-    Requires user to be authenticated via Hugging Face OAuth.
-    Returns (b_key, status_message)
-    """
-    # Check if user is authenticated
-    if profile is None:
-        return "", "Authentication required. Please sign in with your Hugging Face account."
-
-    username = profile.username
-
-    with _lock:
-        keys, b_keys = load_state(force=True)
-
-        if not b_keys or len(b_keys) == 0:
-            return "", "No keys available."
-
-        # Get the first key
-        b_key = b_keys[0]
-
-        # Increment the count
-        b_key["count"] += 1
-
-        # Save changes
-        updated_b_keys_csv = _serialize_b_keys(b_keys)
-
         _upload_csv(
             DATASET_REPO_ID,
-            B_KEYS_PATH,
-            updated_b_keys_csv,
-            commit_message=f"Key requested by {username} at {_utc_now_iso()}",
+            SENT_PATH,
+            updated_sent_csv,
+            commit_message=f"Updated sent tracking for order {order_number} at {_utc_now_iso()}",
         )
 
         # refresh cache immediately
         _cache["ts"] = 0.0
 
-        return b_key["key"], f"Key provided to {username}."
+        keys_sent_count = sent[order_number]["quantity_keys_sent"]
+        return ephemeral_key, f"Ephemeral key sent successfully. ({keys_sent_count}/{max_keys} keys sent for this order)"
 
 # -------------------------
 # UI
 # -------------------------
 with gr.Blocks(title="API") as demo:
-    gr.Markdown("## API Service")
-
-    with gr.Row():
-        gr.Markdown("*Note: Authenticated endpoints require signing in with your Hugging Face account.*")
-        gr.LoginButton()
-
-    with gr.Tab("Service A"):
-        btn_a = gr.Button("Request", variant="secondary", size="sm")
-        out_a = gr.Textbox(label="Response", interactive=False, show_label=False)
-        status_a = gr.Textbox(label="", interactive=False, show_label=False)
-
-        btn_a.click(
-            fn=claim_key,
-            inputs=[],
-            outputs=[out_a, status_a],
-            api_name="claim_key",
-        )
-
-    with gr.Tab("Service B"):
-        btn_b = gr.Button("Request", variant="secondary", size="sm")
-        out_b = gr.Textbox(label="Response", interactive=False, show_label=False)
-        status_b = gr.Textbox(label="", interactive=False, show_label=False)
-
-        btn_b.click(
-            fn=claim_b_key,
-            inputs=[],
-            outputs=[out_b, status_b],
-            api_name="claim_b_key",
-        )
-
-    with gr.Tab("Service A (Authenticated)"):
-        gr.Markdown("### 🔐 Authentication Required")
-        gr.Markdown("Click the 'Sign in with Hugging Face' button at the top to authenticate.")
-        btn_a_auth = gr.Button("Request Key (OAuth)", variant="primary", size="sm")
-        out_a_auth = gr.Textbox(label="Response", interactive=False, show_label=False)
-        status_a_auth = gr.Textbox(label="", interactive=False, show_label=False)
-
-        btn_a_auth.click(
-            fn=claim_key_authenticated,
-            inputs=[],
-            outputs=[out_a_auth, status_a_auth],
-            api_name="claim_key_authenticated",
-        )
-
-    with gr.Tab("Service B (Authenticated)"):
-        gr.Markdown("### 🔐 Authentication Required")
-        gr.Markdown("Click the 'Sign in with Hugging Face' button at the top to authenticate.")
-        btn_b_auth = gr.Button("Request Key (OAuth)", variant="primary", size="sm")
-        out_b_auth = gr.Textbox(label="Response", interactive=False, show_label=False)
-        status_b_auth = gr.Textbox(label="", interactive=False, show_label=False)
-
-        btn_b_auth.click(
-            fn=claim_b_key_authenticated,
-            inputs=[],
-            outputs=[out_b_auth, status_b_auth],
-            api_name="claim_b_key_authenticated",
-        )
+    gr.Markdown("## Ephemeral Key Service")
+
+    order_input = gr.Textbox(label="Order Number", placeholder="Enter order number (e.g., 2724-1857)")
+    btn_c = gr.Button("Request Key", variant="primary", size="sm")
+    out_c = gr.Textbox(label="Response", interactive=False, show_label=False)
+    status_c = gr.Textbox(label="", interactive=False, show_label=False)
+
+    btn_c.click(
+        fn=claim_c_key,
+        inputs=[order_input],
+        outputs=[out_c, status_c],
+        api_name="claim_c_key",
+    )
 
 demo.queue()
 demo.launch()