Update main.py

main.py

@@ -1,104 +1,81 @@
-import gradio as gr
-import requests
-import uuid
 import os
+import tempfile
+import requests
+import gradio as gr
 
-def string_to_binary(input_string):
-    binary_string = ''.join(format(ord(char), '08b') for char in input_string)
-    return binary_string
-
-
-def upload_protocol(protocol_name):
-    robot_ip = "localhost"
-    # robot_url = "https://baxin-ot-analysis.hf.space"
-    endpoint = f"http://{robot_ip}:31950/protocols"
-    # protocol_name = generate_unique_name()
-
-    protocol_file = open(protocol_name, "rb")
-    files = {
-        "files": (protocol_name, protocol_file),
-    }
-
-
-    headers = {"Opentrons-Version": "3"}
-    response = requests.post(endpoint, headers=headers, files=files)
-    response_data = response.json()
-    
-    protocol_file.close()
-    if os.path.exists(protocol_name):
-    # if the protocol file is existing, remove it
-        os.remove(protocol_name)
-
-    if 'data' in response_data:
-        response_data = response.json()
-        protocol_id = response_data["data"]["id"]
-        analysis_result=response_data["data"]["analyses"]
-        analysis_id = response_data["data"]["analysisSummaries"][0]["id"]
-        analysis_status = response_data["data"]["analysisSummaries"][0]["status"]
-        print(protocol_id)
-        print(analysis_result)
-        print(analysis_id)
-        print(analysis_status)
-        return f"success\n protocol_id:{protocol_id}\n analysis_id:{analysis_id}"
-    else:
-        print("analysis error")
-        error_id = response_data["errors"][0]['id']
-        error_code = response_data["errors"][0]["errorCode"]
-        error_detail = response_data["errors"][0]['detail']
-        print(error_id)
-        print(error_code)
-        print(error_detail)
-        return f"{error_id}\n{error_code}\n{error_detail}"
-
-def generate_unique_name():
-    unique_name = str(uuid.uuid4()) + ".py"
-    return unique_name
-
-def send_post_request(payload):
-    url = "https://baxin-simulator.hf.space/protocol"
-    protocol_name = generate_unique_name()
-    data = {"name": protocol_name, "content": payload}
-    headers = {"Content-Type": "application/json"}
-
-    response = requests.post(url, json=data, headers=headers)
-
-    if response.status_code != 200:
-        print("Error: " + response.text)
-        return "Error: " + response.text
-
-    # Check the response before returning it
-    response_data = response.json()
-    if "error_message" in response_data:
-        print("Error in response:", response_data["error_message"])
-        return response_data["error_message"]
-    elif "protocol_name" in response_data:
-        print("Protocol executed successfully. Run log:", response_data["run_log"])
-        return response_data["run_log"]
-    else:
-        print("Unexpected response:", response_data)
-        return "Unexpected response"
-
-
-
-
-def send_message(text, chatbot):
-   # Send POST request and get response
-#    response = send_post_request(text)
-#    binary_protocol = string_to_binary(text)
-    protocol_name = generate_unique_name()
-    with open(protocol_name, "w") as file:
-        file.write(text)
-
-    response = upload_protocol(protocol_name)
-    # Update chatbot with response
-    chatbot.append(("opentrons analysis result", response))
-    return chatbot
+ROBOT_IP = os.getenv("ROBOT_IP", "localhost")
+ROBOT_PORT = int(os.getenv("ROBOT_PORT", "31950"))
+OT_API_VERSION = os.getenv("OT_API_VERSION", "3")
+TIMEOUT_SEC = float(os.getenv("HTTP_TIMEOUT", "30"))
+
+def upload_protocol_file(filepath: str) -> str:
+    endpoint = f"http://{ROBOT_IP}:{ROBOT_PORT}/protocols"
+    headers = {"Opentrons-Version": OT_API_VERSION}
+    filename = os.path.basename(filepath)
+
+    try:
+        with open(filepath, "rb") as f:
+            files = {"files": (filename, f, "text/x-python")}
+            resp = requests.post(endpoint, headers=headers, files=files, timeout=TIMEOUT_SEC)
+    except requests.RequestException as e:
+        return f"HTTP error: {e}"
+
+    try:
+        data = resp.json()
+    except ValueError:
+        return f"Non-JSON response (status={resp.status_code}):\n{resp.text[:1000]}"
+
+    if resp.status_code >= 400:
+        if isinstance(data, dict) and data.get("errors"):
+            err = data["errors"][0]
+            return (
+                f"Upload failed (HTTP {resp.status_code})\n"
+                f"id: {err.get('id')}\n"
+                f"code: {err.get('errorCode')}\n"
+                f"detail: {err.get('detail')}"
+            )
+        return f"Upload failed (HTTP {resp.status_code}):\n{data}"
+
+    if isinstance(data, dict) and "data" in data:
+        d = data["data"]
+        summaries = d.get("analysisSummaries") or []
+        return (
+            "✅ success\n"
+            f"protocol_id: {d.get('id')}\n"
+            f"analysis_id: {(summaries[0].get('id') if summaries else None)}\n"
+            f"analysis_status: {(summaries[0].get('status') if summaries else None)}"
+        )
+
+    return f"Unexpected response:\n{data}"
+
+def send_message(text, history):
+    text = (text or "").strip()
+    if not text:
+        return history
+
+    fd, path = tempfile.mkstemp(prefix="protocol_", suffix=".py")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(text)
+        result = upload_protocol_file(path)
+    finally:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+    history.append((text, result))
+    return history
 
 with gr.Blocks() as app:
-    textbox = gr.Textbox()
-    send_button = gr.Button(value="Send")
-    chatbot = gr.Chatbot()
+    gr.Markdown("## Opentrons Protocol Analyzer")
+    textbox = gr.Textbox(lines=12, label="Paste protocol Python code")
+    send_button = gr.Button(value="Analyze")
+    chatbot = gr.Chatbot(label="Results")
     clear_button = gr.ClearButton([textbox, chatbot])
+
     send_button.click(send_message, [textbox, chatbot], [chatbot])
+    textbox.submit(send_message, [textbox, chatbot], [chatbot])  # Enterでも送信
 
-app.launch()
+if __name__ == "__main__":
+    app.launch(server_name="0.0.0.0", server_port=7860)