Update app.py

app.py

@@ -10,89 +10,77 @@ client = None
 
 def initialize_client(api_key=None):
     global client
-    # Fetch the API key from the environment if it's not provided directly
     api_key = os.getenv("TOGETHER_API_KEY")
-    print(api_key)
-    
-    client = Together()
+    if api_key:
+        client = Together()
+        print("Client initialized successfully.")
+    else:
+        print("API key not found. Please set TOGETHER_API_KEY environment variable.")
 
 def encode_image(image_path):
-    with Image.open(image_path) as img:
-        buffered = io.BytesIO()
-        img.save(buffered, format="PNG")
-        return base64.b64encode(buffered.getvalue()).decode("utf-8")
+    try:
+        with Image.open(image_path) as img:
+            buffered = io.BytesIO()
+            img.save(buffered, format="PNG")
+            return base64.b64encode(buffered.getvalue()).decode("utf-8")
+    except Exception as e:
+        print(f"Error encoding image: {str(e)}")
+        return None
 
-def bot_streaming(image_path, history):
-    max_new_tokens = 350  # Increase for potentially longer responses
-    temperature = 0.7
+def detect_accident(image_path):
     if client is None:
-        try:
-            initialize_client()
-        except Exception as e:
-            history.append(("Error initializing client", f"{str(e)}"))
-            yield history
-            return
+        initialize_client()
+        if client is None:
+            return "Error: Client not initialized."
 
-    prompt = """
-      Determine if the radiator in the image shows signs of being involved in an accident or not
-    """
-
-    messages = [{"role": "system", "content": prompt}]
-    
-    # Encode the image and add to messages
+    # This is a simple prompt to guide the model
+    prompt = "Given the image of a radiator, respond with 'accident' if it shows signs of an accident or 'not accident' if it does not."
     image_base64 = encode_image(image_path)
-    messages.append({
-        "role": "user",
-        "content": [
-            {
-                "type": "image_url",
-                "image_url": {"url": f"data:image/png;base64,{image_base64}"}
-            }
-        ]
-    })
-    history = history + [("Image uploaded", "")]
+    
+    if not image_base64:
+        return "Error: Could not encode the image. Please try again with a different one."
+
+    messages = [
+        {"role": "system", "content": prompt},
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}},
+            ],
+        },
+    ]
 
     try:
-        stream = client.chat.completions.create(
+        response = client.chat.completions.create(
             model="meta-llama/Llama-Vision-Free",
             messages=messages,
-            max_tokens=max_new_tokens,
-            temperature=temperature,
-            stream=True,
+            max_tokens=10,  # Keep this low to limit the response
+            temperature=0.0,  # Reduce randomness
         )
 
-        response = ""
-        for chunk in stream:
-            if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content is not None:
-                response += chunk.choices[0].delta.content
-                history[-1] = ("Image uploaded", response)
-                yield history
-
-        # Handle incomplete responses
-        if not response.strip():
-            history[-1] = ("Image uploaded", "No response generated. Please try again.")
-            yield history
+        # Extract the response and clean it
+        response_text = response.choices[0].message.content.strip().lower()
+        
+        # Validate the response
+        if response_text == "accident" or response_text == "not accident":
+            return response_text
+        else:
+            return "Error: Unexpected response format."
 
     except Exception as e:
-        error_message = (
-            "The image is too large. Please try with a smaller image or compress the existing one."
-            if "Request Entity Too Large" in str(e)
-            else f"An error occurred: {str(e)}"
-        )
-        history[-1] = ("Image uploaded", error_message)
-        yield history
+        print(f"Error during model call: {str(e)}")
+        return f"Error: Could not process the image. Details: {str(e)}"
 
-# Set up Gradio interface
+# Gradio interface
 with gr.Blocks() as demo:
     gr.Markdown("# Radiator Accident Detection")
-    gr.Markdown("Upload an image of a radiator to determine if it shows signs of an accident")
+    gr.Markdown("Upload an image of a radiator to determine if it shows signs of an accident.")
 
-    chatbot = gr.Chatbot()
-    img = gr.Image(type="filepath", label="Upload Radiator Image")
-    clear = gr.Button("Clear")
+    image_input = gr.Image(type="filepath")
+    result = gr.Textbox(label="Result")
+    submit = gr.Button("Submit")
 
-    img.upload(bot_streaming, inputs=[img, chatbot], outputs=chatbot)
-    clear.click(lambda: None, None, chatbot, queue=False)
+    submit.click(detect_accident, inputs=image_input, outputs=result)
 
 if __name__ == "__main__":
-    demo.launch(share=True, debug=True)  # Set share=True to create a public link
+    demo.launch(debug=True)