change to http requests

.gradio/flagged/dataset1.csv

@@ -0,0 +1,2 @@
+Upload Image,Question,Max Tokens,Response,timestamp
+.gradio/flagged/Upload Image/7f96a1c033f4c556e208/example_2.jpg,What color is this dress? ,128,"Based on the image provided, the cat appears to be a domestic short-haired breed, characterized by its short fur and the distinctive pattern of its coat. The coloration and markings are reminiscent of a tabby, which is a common coat pattern in many domestic cats. The tabby pattern often includes stripes, dots, and swirling patterns along the coat, which can be seen on this cat. However, without more information or a view of the cat's body shape and size, it is not possible to determine the exact breed with certainty. Cats with similar color patterns, such as the one pictured, can be found in many breeds, including but",2024-12-17 22:20:30.337640

app.py

@@ -1,62 +1,82 @@
 import gradio as gr
-import websockets
-import asyncio
+import requests
 import json
 import base64
 from PIL import Image
 import io
+import os
+from dotenv import load_dotenv
 
-async def process_image_stream(image_path, prompt, max_tokens=512):
+# Load environment variables
+load_dotenv()
+API_KEY = os.getenv("API_KEY")
+if not API_KEY:
+    raise ValueError("API_KEY environment variable must be set")
+
+def process_image_stream(image_path, prompt, max_tokens=512):
     """
-    Process image with streaming response via WebSocket
+    Process image with streaming response via HTTP
     """
     if not image_path:
         yield "Please upload an image first."
         return
     
     try:
-        # Read and convert image to base64
-        with Image.open(image_path) as img:
-            img = img.convert('RGB')
-            buffer = io.BytesIO()
-            img.save(buffer, format="JPEG")
-            base64_image = base64.b64encode(buffer.getvalue()).decode('utf-8')
+        # Read and prepare image file
+        with open(image_path, 'rb') as img_file:
+            files = {
+                'image': ('image.jpg', img_file, 'image/jpeg')
+            }
+            data = {
+                'prompt': prompt,
+                'task': 'instruct',
+                'max_tokens': max_tokens
+            }
+            headers = {
+                'X-API-Key': API_KEY
+            }
             
-        # Connect to WebSocket
-        async with websockets.connect('wss://nexa-omni.nexa4ai.com/ws/process-image/') as websocket:
-            # Send image data and parameters as JSON
-            await websocket.send(json.dumps({
-                "image": f"data:image/jpeg;base64,{base64_image}",
-                "prompt": prompt,
-                "task": "instruct",  # Fixed to instruct
-                "max_tokens": max_tokens
-            }))
+            # Make streaming request
+            response = requests.post(
+                'https://nexa-omni.nexa4ai.com/process-image/',
+                files=files,
+                data=data,
+                headers=headers,
+                stream=True
+            )
             
+            if response.status_code != 200:
+                yield f"Error: Server returned status code {response.status_code}"
+                return
+
             # Initialize response and token counter
-            response = ""
+            response_text = ""
             token_count = 0
             
-            # Receive streaming response
-            async for message in websocket:
-                try:
-                    data = json.loads(message)
-                    if data["status"] == "generating":
-                        # Skip first three tokens if they match specific patterns
-                        if token_count < 3 and data["token"] in [" ", " \n", "\n", "<|im_start|>", "assistant"]:
-                            token_count += 1
+            # Process the streaming response
+            for line in response.iter_lines():
+                if line:
+                    line = line.decode('utf-8')
+                    if line.startswith('data: '):
+                        try:
+                            data = json.loads(line[6:])  # Skip 'data: ' prefix
+                            if data["status"] == "generating":
+                                # Skip first three tokens if they match specific patterns
+                                if token_count < 3 and data["token"] in [" ", " \n", "\n", "<|im_start|>", "assistant"]:
+                                    token_count += 1
+                                    continue
+                                response_text += data["token"]
+                                yield response_text
+                            elif data["status"] == "complete":
+                                break
+                            elif data["status"] == "error":
+                                yield f"Error: {data['error']}"
+                                break
+                        except json.JSONDecodeError:
                             continue
-                        response += data["token"]
-                        yield response
-                    elif data["status"] == "complete":
-                        break
-                    elif data["status"] == "error":
-                        yield f"Error: {data['error']}"
-                        break
-                except json.JSONDecodeError:
-                    continue
                 
     except Exception as e:
-        yield f"Error connecting to server: {str(e)}"
+        yield f"Error processing request: {str(e)}"
 
 # Create Gradio interface
 demo = gr.Interface(