gemini-rproxy

Paused

App Files Files Community

Moonfanz commited on Jan 14, 2025

Commit

dd71ca7

verified ·

1 Parent(s): 2781d8a

Upload 2 files

Browse files

Files changed (1) hide show

app.py +110 -99

app.py CHANGED Viewed

@@ -59,6 +59,10 @@ safety_settings = [
     {
         "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
         "threshold": "BLOCK_NONE"
     }
 ]
 safety_settings_g2 = [
@@ -77,6 +81,10 @@ safety_settings_g2 = [
     {
         "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
         "threshold": "OFF"
     }
 ]
 @dataclass
@@ -230,7 +238,7 @@ GEMINI_MODELS = [
 @app.route('/')
 def index():
-    main_content = "Moonfanz Reminiproxy v2.3.3 2025-01-14"
     html_template = """
 <!DOCTYPE html>
 <html>
@@ -289,98 +297,102 @@ def increment_request_count(api_key):
         request_counts[api_key] = deque()
     request_counts[api_key].append(now)
-def handle_api_error(error, attempt):
     if attempt > MAX_RETRIES:
         logger.error(f"{MAX_RETRIES} 次尝试后仍然失败，请修改预设或输入")
         return 0, jsonify({
-                'error': {
-                    'message': f"{MAX_RETRIES} 次尝试后仍然失败，请修改预设或输入",
-                    'type': 'max_retries_exceeded'
-                }
         })
-    if isinstance(error, InvalidArgument):
-        logger.error(f"{current_api_key[:8]} → 无效，可能已过期或被删除")
-        key_manager.blacklist_key(current_api_key)
-        switch_api_key()
-        return 0, None
-    elif isinstance(error, ResourceExhausted):
-        delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
-        logger.warning(f"{current_api_key[:8]} ... {current_api_key[-3:]} → 429 官方资源耗尽 → {delay} 秒后重试...")
-        key_manager.blacklist_key(current_api_key)
-        switch_api_key()
-        time.sleep(delay)
-        return 0, None
-    elif isinstance(error, Aborted):
-        delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
-        logger.warning(f"{current_api_key[:8]} ... {current_api_key[-3:]} → 操作被中止 → {delay} 秒后重试...")
-        switch_api_key()
-        time.sleep(delay)
-        return 0, None
-    elif isinstance(error, InternalServerError):
         delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
-        logger.warning(f"{current_api_key[:8]} ... {current_api_key[-3:]} → 500 服务器内部错误 → {delay} 秒后重试...")
-        switch_api_key()
         time.sleep(delay)
         return 0, None
-    elif isinstance(error, ServiceUnavailable):
         delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
-        logger.warning(f"{current_api_key[:8]} ... {current_api_key[-3:]} → 503 服务不可用 → {delay} 秒后重试...")
-        switch_api_key()
         time.sleep(delay)
         return 0, None
-    elif isinstance(error, PermissionDenied):
-        logger.error(f"{current_api_key[:8]} ... {current_api_key[-3:]} → 403 权限被拒绝，该 API KEY 可能已经被官方封禁")
-        key_manager.blacklist_key(current_api_key)
-        switch_api_key()
-        return 0, None
-    elif isinstance(error, StopCandidateException):
-        logger.warning(f"AI输出内容被Gemini官方阻挡，代理没有得到有效回复")
-        switch_api_key()
-        return 0, None
-    elif isinstance(error, BlockedPromptException):
-        try:
-            full_reason_str = str(error.args[0])
-            logger.error(f"{full_reason_str}")
-            if "block_reason:" in full_reason_str:
-                start_index = full_reason_str.find("block_reason:") + len("block_reason:")
-                block_reason_str = full_reason_str[start_index:].strip()
-                if block_reason_str == "SAFETY":
-                    logger.warning(f"用户输入因安全原因被阻止")
-                    return 1, None
-                elif block_reason_str == "BLOCKLIST":
-                    logger.warning(f"用户输入因包含阻止列表中的术语而被阻止")
-                    return 1, None
-                elif block_reason_str == "PROHIBITED_CONTENT":
-                    logger.warning(f"用户输入因包含禁止内容而被阻止")
-                    return 1, None
-                elif block_reason_str == "OTHER":
-                    logger.warning(f"用户输入因未知原因被阻止")
-                    return 1, None
-                else:
-                    logger.warning(f"用户输入被阻止，原因: {block_reason_str}")
-                    return 1, None
-            else:
-                logger.warning(f"用户输入被阻止，原因: {full_reason_str}")
-                return 1, None
-        except (IndexError, AttributeError) as e:
-            logger.error(f"获取提示原因失败↙\n{e}")
-            logger.error(f"提示被阻止↙\n{error}")
-            return 2, None
     else:
-        logger.error(f"该模型还未发布，暂时不可用，请更换模型或未来一段时间再试")
-        logger.error(f"证明↙\n{error}")
-        return 2, None
 @app.route('/hf/v1/chat/completions', methods=['POST'])
 def chat_completions():
@@ -436,16 +448,14 @@ def chat_completions():
         try:
             response = requests.post(url, headers=headers, json=data, stream=True)
-            response.raise_for_status()
             if stream:
                 return 1, response
             else:
                 return 1, ResponseWrapper(response.json())
         except requests.exceptions.RequestException as e:
-            return handle_api_error(e, attempt)
-        except (StopCandidateException, BlockedPromptException) as e:
-            return handle_api_error(e, attempt)
     def generate_stream(response):
         logger.info(f"流式开始 →")
@@ -512,23 +522,14 @@ def chat_completions():
         if success == 0:
             continue
-        elif success == 2:
-            logger.error(f"{model} 很可能暂时不可用，请更换模型或未来���段时间再试")
-            response = {
-                'error': {
-                    'message': f'{model} 很可能暂时不可用，请更换模型或未来一段时间再试',
-                    'type': 'internal_server_error'
-                }
-            }
-            return jsonify(response), 503
-        if stream:
             return Response(
-                    stream_with_context(generate_stream(response)),
-                    mimetype='text/event-stream'
-                )
-        else:
             try:
                 text_content = response.text
                 prompt_tokens = response.prompt_token_count
@@ -550,7 +551,7 @@ def chat_completions():
                 continue
             response_data = {
-                'id': 'chatcmpl-xxxxxxxxxxxx',
                 'object': 'chat.completion',
                 'created': int(datetime.now().timestamp()),
                 'model': model,
@@ -570,7 +571,17 @@ def chat_completions():
             }
             logger.info(f"200!")
             return jsonify(response_data)
     else:
         logger.error(f"{MAX_RETRIES} 次尝试均失败，请调整配置，或等待官方恢复，或向Moonfanz反馈")
         response = {
@@ -655,7 +666,7 @@ if __name__ == '__main__':
     scheduler.add_job(keep_alive, 'interval', hours=12)
     scheduler.start()
-    logger.info(f"Reminiproxy v2.3.3 启动")
     logger.info(f"最大尝试次数/MaxRetries: {MAX_RETRIES}")
     logger.info(f"最大请求次数/MaxRequests: {MAX_REQUESTS}")
     logger.info(f"请求限额窗口/LimitWindow: {LIMIT_WINDOW} 秒")

     {
         "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
         "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'BLOCK_NONE'
     }
 ]
 safety_settings_g2 = [
     {
         "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
         "threshold": "OFF"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'OFF'
     }
 ]
 @dataclass
 @app.route('/')
 def index():
+    main_content = "Moonfanz Reminiproxy v2.3.4 2025-01-14"
     html_template = """
 <!DOCTYPE html>
 <html>
         request_counts[api_key] = deque()
     request_counts[api_key].append(now)
+def handle_api_error(error, attempt, current_api_key):
     if attempt > MAX_RETRIES:
         logger.error(f"{MAX_RETRIES} 次尝试后仍然失败，请修改预设或输入")
         return 0, jsonify({
+            'error': {
+                'message': f"{MAX_RETRIES} 次尝试后仍然失败，请修改预设或输入",
+                'type': 'max_retries_exceeded'
+            }
         })
+    if isinstance(error, requests.exceptions.HTTPError):
+        status_code = error.response.status_code
+        if status_code == 400:
+            try:
+                error_data = error.response.json()
+                if 'error' in error_data:
+                    if error_data['error'].get('code') == "invalid_argument":
+                        logger.error(f"{current_api_key[:8]} ... {current_api_key[-3:]} → 无效，可能已过期或被删除")
+                        key_manager.blacklist_key(current_api_key)
+                        switch_api_key()
+                        return 0, None
+                    error_message = error_data['error'].get('message', 'Bad Request')
+                    error_type = error_data['error'].get('type', 'invalid_request_error')
+                    logger.warning(f"400 Bad Request: {error_message}")
+                    return 1, jsonify({'error': {'message': error_message, 'type': error_type}})
+            except ValueError:
+                logger.warning("400 Bad Request (Unable to parse error response)")
+                return 1, jsonify({'error': {'message': 'Bad Request', 'type': 'invalid_request_error'}})
+        elif status_code == 429:
+            delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
+            logger.warning(
+                f"{current_api_key[:8]} ... {current_api_key[-3:]} → 429 官方资源耗尽 → {delay} 秒后重试..."
+            )
+            key_manager.blacklist_key(current_api_key)
+            switch_api_key()
+            time.sleep(delay)
+            return 0, None
+        elif status_code == 403:
+            logger.error(
+                f"{current_api_key[:8]} ... {current_api_key[-3:]} → 403 权限被拒绝，该 API KEY 可能已经被官方封禁"
+            )
+            key_manager.blacklist_key(current_api_key)
+            switch_api_key()
+            return 0, None
+        elif status_code == 500:
+            delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
+            logger.warning(
+                f"{current_api_key[:8]} ... {current_api_key[-3:]} → 500 服务器内部错误 → {delay} 秒后重试..."
+            )
+            switch_api_key()
+            time.sleep(delay)
+            return 0, None
+        elif status_code == 503:
+            delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
+            logger.warning(
+                f"{current_api_key[:8]} ... {current_api_key[-3:]} → 503 ��务不可用 → {delay} 秒后重试..."
+            )
+            switch_api_key()
+            time.sleep(delay)
+            return 0, None
+        else:
+            delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
+            logger.warning(
+                f"{current_api_key[:8]} ... {current_api_key[-3:]} → {status_code} 未知错误 → {delay} 秒后重试..."
+            )
+            switch_api_key()
+            time.sleep(delay)
+            return 0, None
+    elif isinstance(error, requests.exceptions.ConnectionError):
         delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
+        logger.warning(f"连接错误 → {delay} 秒后重试...")
         time.sleep(delay)
         return 0, None
+    elif isinstance(error, requests.exceptions.Timeout):
         delay = min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY)
+        logger.warning(f"请求超时 → {delay} 秒后重试...")
         time.sleep(delay)
         return 0, None
     else:
+        logger.error(f"发生未知错误: {error}")
+        return 0, jsonify({
+            'error': {
+                'message': f"发生未知错误: {error}",
+                'type': 'unknown_error'
+            }
+        })
 @app.route('/hf/v1/chat/completions', methods=['POST'])
 def chat_completions():
         try:
             response = requests.post(url, headers=headers, json=data, stream=True)
+            response.raise_for_status()  # This will raise an HTTPError for bad responses
             if stream:
                 return 1, response
             else:
                 return 1, ResponseWrapper(response.json())
         except requests.exceptions.RequestException as e:
+            return handle_api_error(e, attempt, current_api_key)
     def generate_stream(response):
         logger.info(f"流式开始 →")
         if success == 0:
             continue
+        elif success == 1 and response is None:
+            continue
+        elif success == 1 and isinstance(response, Response):
             return Response(
+                stream_with_context(generate_stream(response)),
+                mimetype='text/event-stream'
+            )
+        elif success == 1 and isinstance(response, ResponseWrapper):
             try:
                 text_content = response.text
                 prompt_tokens = response.prompt_token_count
                 continue
             response_data = {
+                'id': 'chatcmpl-xxxxxxxxxxxx',
                 'object': 'chat.completion',
                 'created': int(datetime.now().timestamp()),
                 'model': model,
             }
             logger.info(f"200!")
             return jsonify(response_data)
+        elif success == 1 and isinstance(response, tuple):
+            return response[1], response[0]
+        elif success == 2:
+            logger.error(f"{model} 很可能暂时不可用，请更换模型或未来一段时间再试")
+            response = {
+                'error': {
+                    'message': f'{model} 很可能暂时不可用，请更换模型或未来一段时间再试',
+                    'type': 'internal_server_error'
+                }
+            }
+            return jsonify(response), 503
     else:
         logger.error(f"{MAX_RETRIES} 次尝试均失败，请调整配置，或等待官方恢复，或向Moonfanz反馈")
         response = {
     scheduler.add_job(keep_alive, 'interval', hours=12)
     scheduler.start()
+    logger.info(f"Reminiproxy v2.3.4 启动")
     logger.info(f"最大尝试次数/MaxRetries: {MAX_RETRIES}")
     logger.info(f"最大请求次数/MaxRequests: {MAX_REQUESTS}")
     logger.info(f"请求限额窗口/LimitWindow: {LIMIT_WINDOW} 秒")