Update app.py

app.py

@@ -1,7 +1,6 @@
 import gradio as gr
 import requests
 import base64
-import json
 from PIL import Image
 import io
 import logging
@@ -11,63 +10,53 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(level
 logger = logging.getLogger(__name__)
 
 # ==============================================================================
-#  API CALL LOGIC
+#  CLIENT-SIDE API CALL LOGIC
 # ==============================================================================
 
-def call_decoder_api(server_base_url: str, image: Image.Image) -> dict:
+def call_api(server_endpoint_url: str, image: Image.Image) -> dict:
     """
     Takes a PIL image, converts it to base64, sends it to the specified server API,
     and returns the decrypted JSON data.
     """
     # --- Input Validation ---
-    if not server_base_url or "hf.space" not in server_base_url:
-        raise gr.Error("Please provide a valid Hugging Face Space URL for the server API.")
+    if not server_endpoint_url or "/run/mcp_decode" not in server_endpoint_url:
+        raise gr.Error("Please provide the FULL API endpoint URL, including the /run/mcp_decode path.")
     if image is None:
         raise gr.Error("Please upload an encrypted image.")
 
-    # The specific endpoint for our Gradio API
-    api_endpoint = f"{server_base_url.strip('/')}/run/mcp_decode"
-    logger.info(f"Attempting to call API at: {api_endpoint}")
+    api_endpoint = server_endpoint_url.strip()
+    logger.info(f"Client attempting to call API at: {api_endpoint}")
 
     try:
         # 1. Convert the PIL Image to a base64 string
-        buffer = io.BytesIO()
-        image.save(buffer, format="PNG")
-        image_bytes = buffer.getvalue()
-        image_base64 = base64.b64encode(image_bytes).decode('utf-8')
+        with io.BytesIO() as buffer:
+            image.save(buffer, format="PNG")
+            image_base64 = base64.b64encode(buffer.getvalue()).decode('utf-8')
 
         # 2. Prepare the JSON payload for the Gradio API
-        # Gradio's /run/predict endpoint expects this specific structure: {"data": [input1, input2, ...]}
-        payload = {
-            "data": [
-                image_base64
-            ]
-        }
+        payload = {"data": [image_base64]}
 
         # 3. Make the POST request to the server API
         headers = {"Content-Type": "application/json"}
         response = requests.post(api_endpoint, headers=headers, json=payload, timeout=30)
         
         # 4. Process the response
+        response_json = response.json()
         if response.status_code == 200:
-            response_json = response.json()
             if "data" in response_json and len(response_json["data"]) > 0:
-                # Gradio API wraps results in a "data" list. The actual result is the first element.
                 return response_json["data"][0]
             elif "error" in response_json:
                 raise gr.Error(f"API returned an error: {response_json['error']}")
-            else:
-                raise gr.Error(f"API returned an unexpected response format: {response_json}")
         else:
             # Handle non-200 responses with more detail
-            error_text = response.text
-            raise gr.Error(f"API Error (Status {response.status_code}): {error_text}")
+            error_detail = response_json.get("error", "Unknown error.")
+            raise gr.Error(f"API Error (Status {response.status_code}): {error_detail}")
 
     except requests.exceptions.RequestException as e:
         logger.error(f"Network error calling API: {e}")
         raise gr.Error(f"Could not connect to the API. Check the URL and server status. Error: {e}")
     except Exception as e:
-        logger.error(f"An unexpected error occurred: {e}", exc_info=True)
+        logger.error(f"An unexpected client-side error occurred: {e}", exc_info=True)
         raise gr.Error(f"An unexpected error occurred: {e}")
 
 # ==============================================================================
@@ -77,34 +66,28 @@ def call_decoder_api(server_base_url: str, image: Image.Image) -> dict:
 with gr.Blocks(theme=gr.themes.Soft(), title="KeyLock API Client") as demo:
     gr.Markdown("# 🔑 KeyLock API Client")
     gr.Markdown(
-        "This is a user interface for the **Secure Decoder API**. It sends an encrypted image "
-        "to the server for decryption."
+        "This UI calls the **Secure Decoder API**. It sends an encrypted image to the server for decryption."
     )
 
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### 1. Configure Server URL")
+            gr.Markdown("### 1. Configure Server Endpoint")
             server_url_input = gr.Textbox(
-                label="Decoder API Server URL",
-                placeholder="Enter the direct URL of your Python server space...",
-                info="Example: https://your-name-keylock-api-python.hf.space"
+                label="Full Decoder API Endpoint URL",
+                placeholder="https://your-server-space.hf.space/run/mcp_decode",
+                info="You must include the /run/mcp_decode path."
             )
 
             gr.Markdown("### 2. Upload Encrypted Image")
-            image_input = gr.Image(
-                type="pil",
-                label="Upload Encrypted PNG Image",
-                sources=["upload", "clipboard"]
-            )
+            image_input = gr.Image(type="pil", label="Image encrypted with the server's public key", sources=["upload", "clipboard"])
             submit_button = gr.Button("Decrypt via API", variant="primary")
 
         with gr.Column(scale=2):
             gr.Markdown("### 3. Decrypted Data")
             json_output = gr.JSON(label="Result from Server")
 
-    # Connect the UI components to the API call function
     submit_button.click(
-        fn=call_decoder_api,
+        fn=call_api,
         inputs=[server_url_input, image_input],
         outputs=[json_output]
     )