init

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["python", "app.py"]

README.md

@@ -1,7 +1,7 @@
 ---
-title: My 2
-emoji: 📊
-colorFrom: yellow
+title: my_2
+emoji: 🔥
+colorFrom: green
 colorTo: yellow
 sdk: docker
 pinned: false

app.py

@@ -0,0 +1,273 @@
+from flask import Flask, request, jsonify, Response, stream_with_context, render_template, session, redirect, url_for
+from apscheduler.schedulers.background import BackgroundScheduler
+import google.generativeai as genai
+import json
+from datetime import datetime
+import os
+from termcolor import colored
+import logging
+import func
+import requests
+import time
+
+os.environ['TZ'] = 'Asia/Shanghai'
+app = Flask(__name__)
+if not os.environ.get('TERM'):
+    os.environ['TERM'] = 'xterm'
+app.secret_key = os.urandom(24)
+
+ProxyPasswords = os.environ.get('ProxyPasswords').split(',')
+
+formatter = logging.Formatter('%(message)s') 
+ADMIN_PASSWORD = os.environ.get('AdminPassword')
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO) 
+
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+
+logger.addHandler(handler) 
+
+safety_settings = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "BLOCK_NONE"
+    },
+]
+class APIKeyManager:
+    def __init__(self):
+        self.api_keys = os.environ.get('API_KEYS').split(',')
+        self.current_index = 0  
+        
+            
+    def get_available_key(self):
+        if self.current_index >= len(self.api_keys):
+            self.current_index = 0
+        current_key = self.api_keys[self.current_index]
+        self.current_index += 1
+        return current_key
+
+key_manager = APIKeyManager()
+current_api_key = key_manager.get_available_key()
+logger.info(f"Current API key: {current_api_key[:11]}...")
+genai.configure(api_key=current_api_key)
+models = genai.list_models()
+logger.info("Available models:")
+for model in models:
+    logger.info(f"- {model.name}: {model.supported_generation_methods}")
+GEMINI_MODELS = [
+    {"id": "gemini-pro"},
+    {"id": "gemini-pro-vision"},
+    {"id": "gemini-1.0-pro"},
+    {"id": "gemini-1.0-pro-vision"},
+    {"id": "gemini-1.5-pro-002"},
+    {"id": "gemini-exp-1114"},
+    {"id": "gemini-exp-1121"},
+    {"id": "gemini-exp-1206"},
+    {"id": "gemini-2.0-flash-exp"},
+    {"id": "gemini-2.0-flash-thinking-exp-1219"},
+    {"id": "gemini-2.0-flash-thinking-exp-01-21"},
+    {"id": "gemini-2.0-pro-exp"},
+]
+
+@app.route("/", methods=["GET", "POST"])
+def login():
+    if request.method == "POST":
+        password = request.form.get("password")
+        if password == ADMIN_PASSWORD:
+            session["logged_in"] = True
+            return redirect(url_for("manage_keys"))
+        else:
+            return render_template("login.html", error="Incorrect password")
+    return render_template("login.html", error=None)
+
+@app.route("/manage", methods=["GET", "POST"])
+def manage_keys():
+    if not session.get("logged_in"):
+        return redirect(url_for("login"))
+
+    if request.method == "POST":
+        action = request.form.get("action")
+        if action == "add":
+            new_key = request.form.get("new_key")
+            if new_key:
+                ProxyPasswords.append(new_key)
+        elif action == "delete":
+            key_to_delete = request.form.get("key_to_delete")
+            if key_to_delete in ProxyPasswords:
+                ProxyPasswords.remove(key_to_delete)
+
+    return render_template("manage.html", keys=ProxyPasswords)
+
+@app.route("/logout")
+def logout():
+    session.pop("logged_in", None)
+    return redirect(url_for("login"))
+
+@app.route('/hf/v1/chat/completions', methods=['POST'])
+def chat_completions():
+    global current_api_key
+    is_authenticated, auth_error, status_code = func.authenticate_request(request)
+    if not is_authenticated:
+        return auth_error if auth_error else jsonify({'error': 'Unauthorized'}), status_code if status_code else 401
+    try:
+        request_data = request.get_json()
+        r_data = func.sanitize_request_data(request_data)
+        r_data = json.dumps(r_data, indent=4, ensure_ascii=False).replace('\\n', '\n')
+        os.system('cls' if os.name == 'nt' else 'clear')
+        logger.info(r_data)
+        messages = request_data.get('messages', [])
+        model = request_data.get('model', 'gemini-exp-1206')  
+        temperature = request_data.get('temperature', 1)
+        max_tokens = request_data.get('max_tokens', 8192)
+        stream = request_data.get('stream', False)
+
+        logger.info(colored(f"\n{model} [r] -> {current_api_key[:11]}...", 'yellow'))
+    
+        # 将 OpenAI 格式的消息转换为 Gemini 格式
+        gemini_history, user_message, error_response = func.process_messages_for_gemini(messages)
+        
+        if error_response:
+            # 处理错误
+            print(error_response)
+            
+        genai.configure(api_key=current_api_key)
+
+        generation_config = {
+            "temperature": temperature,
+            "max_output_tokens": max_tokens
+        }
+
+        gen_model = genai.GenerativeModel(
+            model_name=model,
+            generation_config=generation_config,
+            safety_settings=safety_settings
+        )
+
+        
+        if stream:
+            # 流式响应
+            if gemini_history:
+                chat_session = gen_model.start_chat(history=gemini_history)
+                response = chat_session.send_message(user_message, stream=True)
+            else:
+                response = gen_model.generate_content(user_message, stream=True)
+
+            def generate():
+                try:
+                    for chunk in response:
+                        if chunk.text:
+                            data = {
+                                'choices': [
+                                    {
+                                        'delta': {
+                                            'content': chunk.text
+                                        },
+                                        'finish_reason': None,
+                                        'index': 0
+                                    }
+                                ],
+                                'object': 'chat.completion.chunk'
+                            }
+                            
+                            yield f"data: {json.dumps(data)}\n\n"
+                    data = {
+                        'choices': [
+                            {
+                                'delta': {},
+                                'finish_reason': 'stop',
+                                'index': 0
+                            }
+                        ],
+                        'object': 'chat.completion.chunk'
+                    }
+                    
+                    yield f"data: {json.dumps(data)}\n\n"
+                except Exception as e:
+                    logger.error(f"Error during streaming: {str(e)}")
+                    
+                    data = {
+                        'error': {
+                            'message': str(e),
+                            'type': 'internal_server_error'
+                        }
+                    }
+                    yield f"data: {json.dumps(data)}\n\n"
+
+            return Response(stream_with_context(generate()), mimetype='text/event-stream')
+        else:
+            # 调用 API
+            if gemini_history:
+                chat_session = gen_model.start_chat(history=gemini_history)
+                response = chat_session.send_message(user_message)
+            else:
+                response = gen_model.generate_content(user_message)
+            try:
+                text_content = response.candidates[0].content.parts[0].text
+
+            except (AttributeError, IndexError, TypeError) as e:
+                logger.error(colored(f"Error getting text content: {str(e)}",'red'))
+
+                text_content = "Error: Unable to get text content." 
+
+            response_data = {
+                'id': 'chatcmpl-xxxxxxxxxxxx',
+                'object': 'chat.completion',
+                'created': int(datetime.now().timestamp()),
+                'model': model,
+                'choices': [{
+                    'index': 0,
+                    'message': {
+                        'role': 'assistant',
+                        'content': text_content
+                    },
+                    'finish_reason': 'stop'
+                }],
+                'usage':{ 
+                    'prompt_tokens': 0,
+                    'completion_tokens': 0,
+                    'total_tokens': 0
+                }
+            }
+            logger.info(colored(f"Generation Success", 'green'))
+            return jsonify(response_data)
+
+    except Exception as e:
+        logger.error(f"Error in chat completions: {str(e)}")
+        return jsonify({
+            'error': {
+                'message': str(e),
+                'type': 'invalid_request_error'
+            }
+        }), 500
+    finally:
+        current_api_key = key_manager.get_available_key()
+        logger.info(colored(f"API KEY Switched -> {current_api_key[:11]}...", 'aqua'))
+
+@app.route('/hf/v1/models', methods=['GET'])
+def list_models():
+    is_authenticated, auth_error, status_code = func.authenticate_request(request)
+    if not is_authenticated:
+        return auth_error if auth_error else jsonify({'error': 'Unauthorized'}), status_code if status_code else 401
+    response = {"object": "list", "data": GEMINI_MODELS}
+    return jsonify(response)
+
+
+if __name__ == '__main__':
+    scheduler = BackgroundScheduler()
+    # 设置定时任务，每 12 小时执行一次 keep_alive 函数
+    scheduler.start()
+    app.run(debug=True, host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))

chat.txt

@@ -0,0 +1,146 @@
+@app.route('/hf/v1/chat/completions', methods=['POST'])
+def chat_completions():
+    global current_api_key
+    is_authenticated, auth_error, status_code = authenticate_request(request)
+    if not is_authenticated:
+        return auth_error if auth_error else jsonify({'error': 'Unauthorized'}), status_code if status_code else 401
+    try:
+        
+        request_data = request.get_json()
+        
+        messages = request_data.get('messages', [])
+        model = request_data.get('model', 'gemini-exp-1206')  
+        temperature = request_data.get('temperature', 1)
+        max_tokens = request_data.get('max_tokens', 8192)
+        stream = request_data.get('stream', False)  
+
+        logger.info(colored(f"\n{model} [r] -> {current_api_key[:11]}...", 'yellow'))
+        # 将 OpenAI 格式的消息转换为 Gemini 格式
+        gemini_history = []
+        for message in messages:
+            role = message.get('role')
+            content = message.get('content')
+            if role == 'system':
+                gemini_history.append({"role": "user", "parts": [content]})
+            elif role == 'user':
+                gemini_history.append({"role": "user", "parts": [content]})
+            elif role == 'assistant':
+                gemini_history.append({"role": "model", "parts": [content]})
+
+        user_message = gemini_history[-1]['parts'][0] if gemini_history else messages[-1]['content']
+        gemini_history = gemini_history[:-1] if gemini_history else []
+        genai.configure(api_key=current_api_key)
+        # 调用 Gemini API
+        generation_config = {
+            "temperature": temperature,
+            "max_output_tokens": max_tokens
+        }
+
+        gen_model = genai.GenerativeModel(
+            model_name=model,
+            generation_config=generation_config,
+            safety_settings=safety_settings
+        )
+
+        
+        if stream:
+            # 流式响应
+            if gemini_history:
+                chat_session = gen_model.start_chat(history=gemini_history)
+                response = chat_session.send_message(user_message, stream=True)
+            else:
+                response = gen_model.generate_content(user_message, stream=True)
+
+            def generate():
+                try:
+                    for chunk in response:
+                        if chunk.text:
+                            data = {
+                                'choices': [
+                                    {
+                                        'delta': {
+                                            'content': chunk.text
+                                        },
+                                        'finish_reason': None,
+                                        'index': 0
+                                    }
+                                ],
+                                'object': 'chat.completion.chunk'
+                            }
+                            
+                            yield f"data: {json.dumps(data)}\n\n"
+                    data = {
+                        'choices': [
+                            {
+                                'delta': {},
+                                'finish_reason': 'stop',
+                                'index': 0
+                            }
+                        ],
+                        'object': 'chat.completion.chunk'
+                    }
+                    
+                    yield f"data: {json.dumps(data)}\n\n"
+                except Exception as e:
+                    logger.error(f"Error during streaming: {str(e)}")
+                    
+                    data = {
+                        'error': {
+                            'message': str(e),
+                            'type': 'internal_server_error'
+                        }
+                    }
+                    yield f"data: {json.dumps(data)}\n\n"
+
+            return Response(stream_with_context(generate()), mimetype='text/event-stream')
+        else:
+            
+            # 调用 API
+            if gemini_history:
+                chat_session = gen_model.start_chat(history=gemini_history)
+                response = chat_session.send_message(user_message)
+            else:
+                response = gen_model.generate_content(user_message)
+                
+            try:
+                text_content = response.candidates[0].content.parts[0].text
+                
+            except (AttributeError, IndexError, TypeError) as e:
+                logger.error(colored(f"Error getting text content: {str(e)}",'red'))
+                
+                text_content = "Error: Unable to get text content." 
+                
+            response_data = {
+                'id': 'chatcmpl-xxxxxxxxxxxx',
+                'object': 'chat.completion',
+                'created': int(datetime.now().timestamp()),
+                'model': model,
+                'choices': [{
+                    'index': 0,
+                    'message': {
+                        'role': 'assistant',
+                        'content': text_content
+                    },
+                    'finish_reason': 'stop'
+                }],
+                'usage':{ 
+                    'prompt_tokens': 0,
+                    'completion_tokens': 0,
+                    'total_tokens': 0
+                }
+            }
+            logger.info(colored(f"Generation Success", 'green'))
+            return jsonify(response_data)
+            
+    except Exception as e:
+        logger.error(f"Error in chat completions: {str(e)}")
+        
+        return jsonify({
+            'error': {
+                'message': str(e),
+                'type': 'invalid_request_error'
+            }
+        }), 500
+    finally:
+        current_api_key = key_manager.get_available_key()
+        logger.info(colored(f"API KEY Switched -> {current_api_key[:11]}...", 'aqua'))

func.py

@@ -0,0 +1,160 @@
+from io import BytesIO
+import os
+from flask import jsonify
+import logging
+import json
+import re
+logger = logging.getLogger(__name__)
+
+ProxyPasswords = os.environ.get('ProxyPasswords').split(',')
+
+def authenticate_request(request):
+    auth_header = request.headers.get('Authorization')
+
+    if not auth_header:
+        return False, jsonify({'error': 'Authorization header is missing'}), 401
+    
+    try:
+        auth_type, api_key = auth_header.split(' ', 1)
+    except ValueError:
+        return False, jsonify({'error': 'Invalid Authorization header format'}), 401
+
+    if auth_type.lower() != 'bearer':
+        return False, jsonify({'error': 'Authorization type must be Bearer'}), 401
+
+    if api_key not in ProxyPasswords:
+        return False, jsonify({'error': 'Unauthorized'}), 401
+
+    return True, None, None
+
+def sanitize_request_data(request_data):
+    """
+    从请求数据中删除base64编码的数据。
+
+    Args:
+        request_data: 包含可能存在base64数据的字典。
+
+    Returns:
+        清理后的字典，其中base64数据被替换为"[Base64 Data Omitted]"。
+    """
+    
+    
+    def replace_base64(match):
+        # 替换base64数据为提示信息
+        return '"[Base64 Data Omitted]"'
+
+    
+    request_data_str = json.dumps(request_data)
+
+    # 使用正则表达式匹配base64数据，并替换为提示信息
+    sanitized_request_data_str = re.sub(
+        r'"(data:[^;]+;base64,)[^"]+"',
+        replace_base64,
+        request_data_str
+    )
+
+    return json.loads(sanitized_request_data_str)
+
+def process_messages_for_gemini(messages):
+    """
+    将通用的对话消息格式转换为Gemini API所需的格式
+    这个函数处理消息列表并将其转换为Gemini API兼容的格式。它支持文本、图片和文件内容的处理。
+    参数:
+        messages (list): 包含对话消息的列表。每条消息应该是一个字典，包含'role'和'content'字段。
+            - role: 可以是 'system', 'user' 或 'assistant'
+            - content: 可以是字符串或包含多个内容项的列表
+    返回:
+        tuple: 包含三个元素:
+            - gemini_history (list): 转换后的历史消息列表
+            - user_message (dict): 最新的用户消息
+            - error (tuple or None): 如果有错误，返回错误响应；否则返回None
+    错误处理:
+        - 检查角色是否有效
+        - 验证图片URL格式
+        - 验证文件URL格式
+    示例消息格式:
+        文本消息:
+        {
+            'role': 'user',
+            'content': '你好'
+        }
+        多模态消息:
+        {
+            'role': 'user',
+            'content': [
+                {'type': 'text', 'text': '这是什么图片?'},
+                {'type': 'image_url', 'image_url': {'url': 'data:image/jpeg;base64,...'}}
+            ]
+        }
+    """
+    gemini_history = []
+    errors = []
+    for message in messages:
+        role = message.get('role')
+        content = message.get('content')
+
+        if isinstance(content, str):
+            if role == 'system':
+                gemini_history.append({"role": "user", "parts": [content]})
+            elif role == 'user':
+                gemini_history.append({"role": "user", "parts": [content]})
+            elif role == 'assistant':
+                gemini_history.append({"role": "model", "parts": [content]})
+            else:
+                errors.append(f"Invalid role: {role}")
+        elif isinstance(content, list):
+            parts = []
+            for item in content:
+                if item.get('type') == 'text':
+                    parts.append({"text": item.get('text')})  
+                elif item.get('type') == 'image_url':
+                    image_data = item.get('image_url', {}).get('url', '')
+                    if image_data.startswith('data:image/'):
+
+                        try:
+                            mime_type, base64_data = image_data.split(';')[0].split(':')[1], image_data.split(',')[1]
+                            parts.append({
+                                "inline_data": {
+                                    "mime_type": mime_type,
+                                    "data": base64_data
+                                }
+                            })
+                        except (IndexError, ValueError):
+                            errors.append(f"Invalid data URI for image: {image_data}")
+                    else:
+                        errors.append(f"Invalid image URL format for item: {item}")
+                elif item.get('type') == 'file_url':
+                    file_data = item.get('file_url', {}).get('url', '')
+                    if file_data.startswith('data:'):
+
+                        try:
+                            mime_type, base64_data = file_data.split(';')[0].split(':')[1], file_data.split(',')[1]
+                            parts.append({
+                                "inline_data": {
+                                    "mime_type": mime_type,
+                                    "data": base64_data
+                                }
+                            })
+                        except (IndexError, ValueError):
+                            errors.append(f"Invalid data URI for file: {file_data}")
+                    else:
+                        errors.append(f"Invalid file URL format for item: {item}")
+
+            if parts: 
+                if role in ['user', 'system']:
+                    gemini_history.append({"role": "user", "parts": parts})
+                elif role == 'assistant':
+                    gemini_history.append({"role": "model", "parts": parts})
+                else:
+                    errors.append(f"Invalid role: {role}")
+
+    if gemini_history:
+        user_message = gemini_history[-1]
+        gemini_history = gemini_history[:-1]
+    else:
+        user_message = {"role": "user", "parts": [""]}
+
+    if errors:
+        return gemini_history, user_message, (jsonify({'error': errors}), 400)
+    else:
+        return gemini_history, user_message, None

requirements.txt

@@ -0,0 +1,9 @@
+Flask==2.0.3
+Flask-CORS==3.0.10
+requests==2.26.0
+Werkzeug==2.0.3
+google==3.0.0
+google-generativeai==0.8.3
+termcolor==2.5.0
+pillow==10.4.0
+apscheduler

templates/login.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <title>Login</title>
+</head>
+
+<body>
+    <h1>Admin Login</h1>
+    {% if error %}
+    <p style="color: red;">{{ error }}</p>
+    {% endif %}
+    <form method="POST">
+        <label for="password">Password:</label>
+        <input type="password" name="password" id="password" required>
+        <button type="submit">Login</button>
+    </form>
+</body>
+
+</html>

templates/manage.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <title>Manage API Keys</title>
+</head>
+
+<body>
+    <h1>Manage Hugging Face API Keys</h1>
+    <h2>Current Keys:</h2>
+    <ul>
+        {% for key in keys %}
+        <li>
+            {{ key }}
+            <form method="POST" style="display: inline;">
+                <input type="hidden" name="action" value="delete">
+                <input type="hidden" name="key_to_delete" value="{{ key }}">
+                <button type="submit">Delete</button>
+            </form>
+        </li>
+        {% endfor %}
+    </ul>
+    <h2>Add New Key:</h2>
+    <form method="POST">
+        <input type="hidden" name="action" value="add">
+        <input type="text" name="new_key" placeholder="Enter new API key">
+        <button type="submit">Add</button>
+    </form>
+    <br>
+    <a href="{{ url_for('logout') }}">Logout</a>
+</body>
+
+</html>