init

app.py

@@ -140,25 +140,29 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
     """
     Interface function for processing image editing
     """
-    # 提取用户IP
-    client_ip = request.client.host
-    x_forwarded_for = dict(request.headers).get('x-forwarded-for')
-    if x_forwarded_for:
-        client_ip = x_forwarded_for   
-    if client_ip not in IP_Dict:
-        IP_Dict[client_ip] = 0
-    IP_Dict[client_ip] += 1
+    try:
+        # 提取用户IP
+        client_ip = request.client.host
+        x_forwarded_for = dict(request.headers).get('x-forwarded-for')
+        if x_forwarded_for:
+            client_ip = x_forwarded_for   
+        if client_ip not in IP_Dict:
+            IP_Dict[client_ip] = 0
+        IP_Dict[client_ip] += 1
 
-    
-    if input_image is None:
-        return None, "Please upload an image first"
-    
-    if not prompt or prompt.strip() == "":
-        return None, "Please enter editing prompt"
-    
-    # 检查prompt长度是否大于3个字符
-    if len(prompt.strip()) <= 3:
-        return None, "❌ Editing prompt must be more than 3 characters"
+        
+        if input_image is None:
+            return None, "Please upload an image first"
+        
+        if not prompt or prompt.strip() == "":
+            return None, "Please enter editing prompt"
+        
+        # 检查prompt长度是否大于3个字符
+        if len(prompt.strip()) <= 3:
+            return None, "❌ Editing prompt must be more than 3 characters"
+    except Exception as e:
+        print(f"⚠️ Request preprocessing error: {e}")
+        return None, "❌ Request processing error"
     
     # 检查图片是否包含NSFW内容
     nsfw_result = None
@@ -196,9 +200,14 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
     status_message = ""
     
     def progress_callback(message):
-        nonlocal status_message
-        status_message = message
-        progress(0.5, desc=message)
+        try:
+            nonlocal status_message
+            status_message = message
+            # 增加错误处理，防止 progress 更新失败
+            if progress is not None:
+                progress(0.5, desc=message)
+        except Exception as e:
+            print(f"⚠️ Progress update failed: {e}")
     
     try:
         # 打印成功访问的信息
@@ -209,93 +218,59 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
         
         if result_url:
             print(f"✅ Processing completed successfully - IP: {client_ip}, result_url: {result_url}", flush=True)
-            progress(1.0, desc="Processing completed")
+            try:
+                if progress is not None:
+                    progress(1.0, desc="Processing completed")
+            except Exception as e:
+                print(f"⚠️ Final progress update failed: {e}")
             return result_url, "✅ " + message
         else:
             print(f"❌ Processing failed - IP: {client_ip}, error: {message}", flush=True)
             return None, "❌ " + message
             
     except Exception as e:
+        print(f"❌ Processing exception - IP: {client_ip}, error: {str(e)}")
         return None, f"❌ Error occurred during processing: {str(e)}"
 
-# 局部编辑处理函数
-# 状态更新函数
-def update_global_input_state(image):
-    """更新全局编辑输入图片状态"""
-    return image
-
-def update_global_output_state(image):
-    """更新全局编辑输出图片状态"""
-    return image
-
-def update_local_input_state(image):
-    """更新局部编辑输入图片状态"""
-    return image
-
-def update_local_output_state(image):
-    """更新局部编辑输出图片状态"""
-    return image
-
-def use_global_output_as_input(output_image):
-    """将全局编辑的输出图片设为输入图片"""
-    if output_image is not None:
-        return output_image, output_image
-    return None, None
-
-def use_local_output_as_input(output_image):
-    """将局部编辑的输出图片设为输入图片"""
-    if output_image is not None:
-        # 对于局部编辑，我们需要创建一个新的ImageEditor格式
-        # 将输出图片作为背景，不包含任何编辑层
-        editor_data = {
-            "background": output_image, 
-            "layers": [],
-            "composite": output_image  # 添加composite键以避免KeyError
-        }
-        return editor_data, output_image
-    return None, None
-
-def load_global_input_from_state(state_image):
-    """从状态加载全局编辑输入图片"""
-    return state_image
-
-def load_local_input_from_state(state_image):
-    """从状态加载局部编辑输入图片"""
-    return state_image
+# 不再需要复杂的状态管理函数，已简化为内联函数
 
 def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Progress()):
     """
     处理局部编辑请求
     """
-    # 提取用户IP
-    client_ip = request.client.host
-    x_forwarded_for = dict(request.headers).get('x-forwarded-for')
-    if x_forwarded_for:
-        client_ip = x_forwarded_for   
-    if client_ip not in IP_Dict:
-        IP_Dict[client_ip] = 0
-    IP_Dict[client_ip] += 1
+    try:
+        # 提取用户IP
+        client_ip = request.client.host
+        x_forwarded_for = dict(request.headers).get('x-forwarded-for')
+        if x_forwarded_for:
+            client_ip = x_forwarded_for   
+        if client_ip not in IP_Dict:
+            IP_Dict[client_ip] = 0
+        IP_Dict[client_ip] += 1
 
-    
-    if image_dict is None:
-        return None, "Please upload an image and draw the area to edit"
-    
-    # Check if background and layers exist
-    if "background" not in image_dict or "layers" not in image_dict:
-        return None, "Please draw the area to edit on the image"
-    
-    base_image = image_dict["background"]
-    layers = image_dict["layers"]
-    
-    if not layers:
-        return None, "Please draw the area to edit on the image"
         
-    if not prompt or prompt.strip() == "":
-        return None, "Please enter editing prompt"
-    
-    # Check prompt length
-    if len(prompt.strip()) <= 3:
-        return None, "❌ Editing prompt must be more than 3 characters"
+        if image_dict is None:
+            return None, "Please upload an image and draw the area to edit"
+        
+        # Check if background and layers exist
+        if "background" not in image_dict or "layers" not in image_dict:
+            return None, "Please draw the area to edit on the image"
+        
+        base_image = image_dict["background"]
+        layers = image_dict["layers"]
+        
+        if not layers:
+            return None, "Please draw the area to edit on the image"
+            
+        if not prompt or prompt.strip() == "":
+            return None, "Please enter editing prompt"
+        
+        # Check prompt length
+        if len(prompt.strip()) <= 3:
+            return None, "❌ Editing prompt must be more than 3 characters"
+    except Exception as e:
+        print(f"⚠️ Local edit request preprocessing error: {e}")
+        return None, "❌ Request processing error"
     
     # 检查图片是否包含NSFW内容
     nsfw_result = None
@@ -330,9 +305,14 @@ def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Pr
     status_message = ""
     
     def progress_callback(message):
-        nonlocal status_message
-        status_message = message
-        progress(0.5, desc=message)
+        try:
+            nonlocal status_message
+            status_message = message
+            # 增加错误处理，防止 progress 更新失败
+            if progress is not None:
+                progress(0.5, desc=message)
+        except Exception as e:
+            print(f"⚠️ Local edit progress update failed: {e}")
     
     try:
         print(f"✅ Local editing started - IP: {client_ip}, count: {IP_Dict[client_ip]}, prompt: {prompt.strip()}", flush=True)
@@ -342,13 +322,18 @@ def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Pr
         
         if result_url:
             print(f"✅ Local editing completed successfully - IP: {client_ip}, result_url: {result_url}", flush=True)
-            progress(1.0, desc="Processing completed")
+            try:
+                if progress is not None:
+                    progress(1.0, desc="Processing completed")
+            except Exception as e:
+                print(f"⚠️ Local edit final progress update failed: {e}")
             return result_url, "✅ " + message
         else:
             print(f"❌ Local editing processing failed - IP: {client_ip}, error: {message}", flush=True)
             return None, "❌ " + message
             
     except Exception as e:
+        print(f"❌ Local editing exception - IP: {client_ip}, error: {str(e)}")
         return None, f"❌ Error occurred during processing: {str(e)}"
 
 # Create Gradio interface
@@ -377,14 +362,20 @@ def create_app():
             margin-top: 10px;
             width: 100%;
         }
+        """,
+        # 改善并发性能的配置
+        head="""
+        <script>
+        // 减少客户端状态更新频率，避免过度的 SSE 连接
+        if (window.gradio) {
+            window.gradio.update_frequency = 2000; // 2秒更新一次
+        }
+        </script>
         """
     ) as app:
         
-        # 使用State组件保持图片状态，防止切换tab时丢失
-        global_input_state = gr.State()
-        global_output_state = gr.State()
-        local_input_state = gr.State()
-        local_output_state = gr.State()
+        # 减少State组件，只保留必要的
+        # 移除了大部分State组件以减少状态管理复杂度
         
         gr.Markdown(
             """
@@ -463,30 +454,27 @@ def create_app():
                             outputs=prompt_input
                         )
                 
-                # 绑定按钮点击事件
+                # 绑定按钮点击事件 - 简化，移除状态管理
                 edit_button.click(
                     fn=edit_image_interface,
                     inputs=[input_image, prompt_input],
                     outputs=[output_image, status_output],
-                    show_progress=True
-                ).then(
-                    fn=update_global_output_state,
-                    inputs=[output_image],
-                    outputs=[global_output_state]
+                    show_progress=True,
+                    # 增加并发设置
+                    concurrency_limit=10,  # 限制并发数
+                    api_name="global_edit"
                 )
                 
-                # 绑定 "Use as Input" 按钮
+                # 简化 "Use as Input" 按钮，直接复制图片
+                def simple_use_as_input(output_img):
+                    if output_img is not None:
+                        return output_img
+                    return None
+                
                 use_as_input_btn.click(
-                    fn=use_global_output_as_input,
+                    fn=simple_use_as_input,
                     inputs=[output_image],
-                    outputs=[input_image, global_input_state]
-                )
-                
-                # 绑定输入图片变化事件以更新状态
-                input_image.change(
-                    fn=update_global_input_state,
-                    inputs=[input_image],
-                    outputs=[global_input_state]
+                    outputs=[input_image]
                 )
             
             # Local editing tab  
@@ -559,35 +547,51 @@ def create_app():
                             outputs=local_prompt_input
                         )
                 
-                # 绑定局部编辑按钮点击事件
+                # 绑定局部编辑按钮点击事件 - 简化，移除状态管理
                 local_edit_button.click(
                     fn=local_edit_interface,
                     inputs=[local_input_image, local_prompt_input],
                     outputs=[local_output_image, local_status_output],
-                    show_progress=True
-                ).then(
-                    fn=update_local_output_state,
-                    inputs=[local_output_image],
-                    outputs=[local_output_state]
+                    show_progress=True,
+                    # 增加并发设置
+                    concurrency_limit=8,  # 局部编辑更复杂，限制更少的并发
+                    api_name="local_edit"
                 )
                 
-                # 绑定局部编辑 "Use as Input" 按钮
+                # 简化局部编辑 "Use as Input" 按钮
+                def simple_local_use_as_input(output_img):
+                    if output_img is not None:
+                        # 创建简单的 ImageEditor 格式
+                        editor_data = {
+                            "background": output_img, 
+                            "layers": [],
+                            "composite": output_img
+                        }
+                        return editor_data
+                    return None
+                
                 local_use_as_input_btn.click(
-                    fn=use_local_output_as_input,
+                    fn=simple_local_use_as_input,
                     inputs=[local_output_image],
-                    outputs=[local_input_image, local_input_state]
-                )
-                
-                # 绑定局部编辑输入图片变化事件以更新状态
-                local_input_image.change(
-                    fn=update_local_input_state,
-                    inputs=[local_input_image],
-                    outputs=[local_input_state]
+                    outputs=[local_input_image]
                 )
     
     return app
 
 if __name__ == "__main__":
     app = create_app()
-    app.queue()  # Enable queue to handle concurrent requests
-    app.launch()
+    # 改善队列配置以处理高并发和防止 SSE 连接问题
+    app.queue(
+        default_concurrency_limit=20,  # 默认并发限制
+        max_size=50,  # 队列最大大小
+        api_open=False  # 关闭 API 访问，减少资源消耗
+    )
+    app.launch(
+        server_name="0.0.0.0",
+        show_error=True,  # 显示详细错误信息
+        quiet=False,  # 保持日志输出
+        max_threads=40,  # 增加线程池大小
+        height=800,
+        favicon_path=None,  # 减少资源加载
+        enable_queue=True
+    )

util.py

@@ -118,12 +118,18 @@ class R2Api:
         retry_count = 0
         while retry_count < 3:
             try:
-                self.session.put(url, data=image_data, headers=headers, timeout=8)
-                break
-            except (requests.exceptions.Timeout, requests.exceptions.RequestException):
+                response = self.session.put(url, data=image_data, headers=headers, timeout=15)
+                if response.status_code == 200:
+                    break
+                else:
+                    print(f"⚠️ Upload failed with status code: {response.status_code}")
+                    retry_count += 1
+            except (requests.exceptions.Timeout, requests.exceptions.RequestException) as e:
+                print(f"⚠️ Upload retry {retry_count + 1}/3 failed: {e}")
                 retry_count += 1
                 if retry_count == 3:
-                    raise Exception('Failed to upload file to R2 after 3 retries!')
+                    raise Exception(f'Failed to upload file to R2 after 3 retries! Last error: {str(e)}')
+                time.sleep(1)  # 等待1秒后重试
                 continue
         print("upload_from_memory time is ====>", time.time() - t1)
         return f"{self.domain}{cloud_path}"
@@ -284,7 +290,7 @@ def upload_mask_image_r2(client_ip, time_id, mask_image):
 
 def submit_image_edit_task(user_image_url, prompt, task_type="80", mask_image_url=""):
     """
-    Submit image editing task
+    Submit image editing task with improved error handling
     """
     headers = {
         'Content-Type': 'application/json',
@@ -300,28 +306,52 @@ def submit_image_edit_task(user_image_url, prompt, task_type="80", mask_image_ur
         "is_private": "0"
     }
     
-    try:
-        response = requests.post(
-            f'{UKAPIURL}/public_image_edit',
-            headers=headers,
-            json=data
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            if result.get('code') == 0:
-                return result['data']['task_id'], None
+    retry_count = 0
+    max_retries = 3
+    
+    while retry_count < max_retries:
+        try:
+            response = requests.post(
+                f'{UKAPIURL}/public_image_edit',
+                headers=headers,
+                json=data,
+                timeout=30  # 增加超时时间
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if result.get('code') == 0:
+                    return result['data']['task_id'], None
+                else:
+                    return None, f"API Error: {result.get('message', 'Unknown error')}"
+            elif response.status_code in [502, 503, 504]:  # 服务器错误，可以重试
+                retry_count += 1
+                if retry_count < max_retries:
+                    print(f"⚠️ Server error {response.status_code}, retrying {retry_count}/{max_retries}")
+                    time.sleep(2)  # 等待2秒后重试
+                    continue
+                else:
+                    return None, f"HTTP Error after {max_retries} retries: {response.status_code}"
             else:
-                return None, f"API Error: {result.get('message', 'Unknown error')}"
-        else:
-            return None, f"HTTP Error: {response.status_code}"
-    except Exception as e:
-        return None, f"Request Exception: {str(e)}"
+                return None, f"HTTP Error: {response.status_code}"
+                
+        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
+            retry_count += 1
+            if retry_count < max_retries:
+                print(f"⚠️ Network error, retrying {retry_count}/{max_retries}: {e}")
+                time.sleep(2)
+                continue
+            else:
+                return None, f"Network error after {max_retries} retries: {str(e)}"
+        except Exception as e:
+            return None, f"Request Exception: {str(e)}"
+    
+    return None, f"Failed after {max_retries} retries"
 
 
 def check_task_status(task_id):
     """
-    Query task status
+    Query task status with improved error handling
     """
     headers = {
         'Content-Type': 'application/json',
@@ -332,24 +362,48 @@ def check_task_status(task_id):
         "task_id": task_id
     }
     
-    try:
-        response = requests.post(
-            f'{UKAPIURL}/status_image_edit',
-            headers=headers,
-            json=data
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            if result.get('code') == 0:
-                task_data = result['data']
-                return task_data['status'], task_data.get('output1'), task_data
+    retry_count = 0
+    max_retries = 2  # 状态查询重试次数少一些
+    
+    while retry_count < max_retries:
+        try:
+            response = requests.post(
+                f'{UKAPIURL}/status_image_edit',
+                headers=headers,
+                json=data,
+                timeout=15  # 状态查询超时时间短一些
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                if result.get('code') == 0:
+                    task_data = result['data']
+                    return task_data['status'], task_data.get('output1'), task_data
+                else:
+                    return 'error', None, result.get('message', 'Unknown error')
+            elif response.status_code in [502, 503, 504]:  # 服务器错误，可以重试
+                retry_count += 1
+                if retry_count < max_retries:
+                    print(f"⚠️ Status check server error {response.status_code}, retrying {retry_count}/{max_retries}")
+                    time.sleep(1)  # 状态查询重试间隔短一些
+                    continue
+                else:
+                    return 'error', None, f"HTTP Error after {max_retries} retries: {response.status_code}"
             else:
-                return 'error', None, result.get('message', 'Unknown error')
-        else:
-            return 'error', None, f"HTTP Error: {response.status_code}"
-    except Exception as e:
-        return 'error', None, f"Request Exception: {str(e)}"
+                return 'error', None, f"HTTP Error: {response.status_code}"
+                
+        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
+            retry_count += 1
+            if retry_count < max_retries:
+                print(f"⚠️ Status check network error, retrying {retry_count}/{max_retries}: {e}")
+                time.sleep(1)
+                continue
+            else:
+                return 'error', None, f"Network error after {max_retries} retries: {str(e)}"
+        except Exception as e:
+            return 'error', None, f"Request Exception: {str(e)}"
+    
+    return 'error', None, f"Failed after {max_retries} retries"
 
 
 def process_image_edit(img_input, prompt, progress_callback=None):