first commit

Dockerfile

@@ -0,0 +1,17 @@
+# Start from a standard Python base image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy all project files into the container
+COPY . .
+
+# Install the Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the application port
+EXPOSE 7860
+
+# Specify the command to run the application
+CMD ["python", "freeplay2api.py"]

README.md

@@ -0,0 +1,13 @@
+---
+title: FreePlay2API
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+---
+## How to Use
+
+1.  **Set the API Key**: This application requires an API key for authentication. You need to set a secret environment variable named `API_KEY` in your Hugging Face Space settings. The value can be any string you choose.
+2.  **Start the Application**: Once the environment variable is set, the application will start, and you can access the API.
+3.  **Accessing the API**: The API will be available at the port specified in the Dockerfile (default is 7860). You can use the API key you set in the `Authorization` header as a Bearer token.

freeplay2api.py

@@ -0,0 +1,675 @@
+import json
+import os
+import time
+import uuid
+import threading
+import logging
+import asyncio
+import concurrent.futures
+from typing import Any, List, Optional, Dict, Generator, Union
+
+from proxy_pool import ProxyPool
+from fastapi import FastAPI, HTTPException, Depends, Response, Request
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel, Field
+from faker import Faker
+import requests
+
+# --- 基本配置 ---
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+# --- 全局变量 ---
+config = {}
+account_manager = None
+freeplay_client = None
+proxy_pool = None
+valid_client_keys = set()
+app_lock = threading.Lock()  # 用于保护全局资源的初始化
+
+
+# --- Pydantic模型定义 (来自模板) ---
+class ChatMessage(BaseModel):
+    role: str
+    content: Union[str, List[Dict[str, Any]]]
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[ChatMessage]
+    stream: bool = False
+    temperature: Optional[float] = 1.0  # 映射到Freeplay参数
+    max_tokens: Optional[int] = 32000  # 映射到Freeplay参数
+    top_p: Optional[float] = 1.0  # 映射到Freeplay参数
+
+
+class ModelInfo(BaseModel):
+    id: str
+    object: str = "model"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    owned_by: str = "freeplay"
+
+
+class ModelList(BaseModel):
+    object: str = "list"
+    data: List[ModelInfo]
+
+
+class ChatCompletionChoice(BaseModel):
+    message: ChatMessage
+    index: int = 0
+    finish_reason: str = "stop"
+
+
+class ChatCompletionResponse(BaseModel):
+    id: str = Field(default_factory=lambda: f"chatcmpl-{uuid.uuid4().hex}")
+    object: str = "chat.completion"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    model: str
+    choices: List[ChatCompletionChoice]
+    usage: Dict[str, int] = Field(
+        default_factory=lambda: {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0,
+        }
+    )
+
+
+class StreamChoice(BaseModel):
+    delta: Dict[str, Any] = Field(default_factory=dict)
+    index: int = 0
+    finish_reason: Optional[str] = None
+
+
+class StreamResponse(BaseModel):
+    id: str = Field(default_factory=lambda: f"chatcmpl-{uuid.uuid4().hex}")
+    object: str = "chat.completion.chunk"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    model: str
+    choices: List[StreamChoice]
+
+
+# --- 模型映射 ---
+MODEL_MAPPING = {
+    "claude-3-7-sonnet-20250219": {
+        "model_id": "be71f37b-1487-49fa-a989-a9bb99c0b129",
+        "max_tokens": 64000,
+        "provider": "Anthropic",
+    },
+    "claude-4-opus-20250514": {
+        "model_id": "bebc7dd5-a24d-4147-85b0-8f62902ea1a3",
+        "max_tokens": 32000,
+        "provider": "Anthropic",
+    },
+    "claude-4-sonnet": {
+        "model_id": "884dde7c-8def-4365-b19a-57af2787ab84",
+        "max_tokens": 64000,
+        "provider": "Anthropic",
+    },
+}
+
+
+# --- 服务类 ---
+class FreeplayClient:
+    def __init__(self, proxy_pool_instance: Optional[ProxyPool] = None):
+        self.proxy_pool = proxy_pool_instance
+        self.faker = Faker()
+
+    def check_balance(self, session_id: str) -> float:
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+            "Accept": "application/json",
+        }
+        cookies = {"session": session_id}
+        
+        proxy_info = self.proxy_pool.get_proxy() if self.proxy_pool else None
+        proxies = {"http": proxy_info['full'], "https": proxy_info['full']} if proxy_info else None
+
+        try:
+            response = requests.get(
+                "https://app.freeplay.ai/app_data/settings/billing",
+                headers=headers,
+                cookies=cookies,
+                proxies=proxies,
+                timeout=10,
+            )
+            if response.status_code == 200:
+                data = response.json()
+                for feature in data.get("feature_usage", []):
+                    if feature.get("feature_name") == "Freeplay credits":
+                        return feature.get("usage_limit", 0) - feature.get(
+                            "usage_value", 0
+                        )
+                return 0.0
+            return 0.0
+        except requests.exceptions.ProxyError as e:
+            logging.warning(f"Proxy error during balance check: {e}")
+            if self.proxy_pool and proxy_info:
+                self.proxy_pool.remove_proxy(proxy_info['ip'], proxy_info['port'])
+            return 0.0
+        except Exception as e:
+            logging.warning(
+                f"Failed to check balance for session_id ending in ...{session_id[-4:]}: {e}"
+            )
+            return 0.0
+
+    def register(self) -> Optional[Dict]:
+        url = "https://app.freeplay.ai/app_data/auth/signup"
+        payload = {
+            "email": self.faker.email(),
+            "password": f"aA1!{uuid.uuid4().hex[:8]}",
+            "account_name": self.faker.name(),
+            "first_name": self.faker.first_name(),
+            "last_name": self.faker.last_name(),
+        }
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "origin": "https://app.freeplay.ai",
+            "referer": "https://app.freeplay.ai/signup",
+        }
+        try:
+            proxy_info = self.proxy_pool.get_proxy() if self.proxy_pool else None
+            proxies = {"http": proxy_info['full'], "https": proxy_info['full']} if proxy_info else None
+            response = requests.post(
+                url,
+                data=json.dumps(payload),
+                headers=headers,
+                proxies=proxies,
+                timeout=20,
+            )
+            response.raise_for_status()
+            project_id = response.json()["project_id"]
+            session = response.cookies.get("session")
+            if project_id and session:
+                return {
+                    "email": payload["email"],
+                    "password": payload["password"],
+                    "session_id": session,
+                    "project_id": project_id,
+                    "balance": 5.0,  # 新注册账号默认5刀
+                }
+        except requests.exceptions.ProxyError as e:
+            logging.warning(f"Proxy error during registration: {e}")
+            if self.proxy_pool and proxy_info:
+                self.proxy_pool.remove_proxy(proxy_info['ip'], proxy_info['port'])
+            return None
+        except Exception as e:
+            logging.error(f"Account registration failed: {e}")
+            return None
+
+    def chat(
+        self,
+        session_id: str,
+        project_id: str,
+        model_config: Dict,
+        messages: List[Dict],
+        params: Dict,
+    ) -> requests.Response:
+        url = f"https://app.freeplay.ai/app_data/projects/{project_id}/llm-completions"
+        headers = {
+            "accept": "*/*",
+            "origin": "https://app.freeplay.ai",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+        }
+        cookies = {"session": session_id}
+
+        # 将 system message 转换为 user message
+        for msg in messages:
+            if msg["role"] == "system":
+                msg["role"] = "user"
+        
+        json_payload = {
+            "messages": messages,
+            "params": [
+                {
+                    "name": "max_tokens",
+                    "value": params.get("max_tokens", model_config["max_tokens"]),
+                    "type": "integer",
+                },
+                {
+                    "name": "temperature",
+                    "value": params.get("temperature", 1.0),
+                    "type": "float",
+                },
+                {"name": "top_p", "value": params.get("top_p", 1.0), "type": "float"},
+            ],
+            "model_id": model_config["model_id"],
+            "variables": {},
+            "history": None,
+            "asset_references": {},
+        }
+        files = {"json_data": (None, json.dumps(json_payload))}
+        proxy_info = self.proxy_pool.get_proxy() if self.proxy_pool else None
+        proxies = {"http": proxy_info['full'], "https": proxy_info['full']} if proxy_info else None
+        try:
+            return requests.post(
+                url, headers=headers, cookies=cookies, files=files, stream=True, proxies=proxies
+            )
+        except requests.exceptions.ProxyError as e:
+            logging.warning(f"Proxy error during chat: {e}")
+            if self.proxy_pool and proxy_info:
+                self.proxy_pool.remove_proxy(proxy_info['ip'], proxy_info['port'])
+            raise  # Re-raise to be caught by the retry logic
+
+
+class AccountManager:
+    def __init__(self, filepath: str):
+        self.filepath = filepath
+        self.accounts = []
+        self.lock = threading.Lock()
+        self.load_accounts()
+
+    def load_accounts(self):
+        with self.lock:
+            if not os.path.exists(self.filepath):
+                self.accounts = []
+                return
+            with open(self.filepath, "r", encoding="utf-8") as f:
+                self.accounts = [json.loads(line) for line in f if line.strip()]
+            logging.info(f"Loaded {len(self.accounts)} accounts from {self.filepath}")
+
+    def save_accounts(self):
+        with self.lock:
+            with open(self.filepath, "w", encoding="utf-8") as f:
+                for account in self.accounts:
+                    f.write(json.dumps(account) + "\n")
+
+    def add_account(self, account: Dict):
+        with self.lock:
+            self.accounts.append(account)
+        self.save_accounts()
+        logging.info(f"Added new account: {account.get('email')}")
+
+    def get_account(self) -> Optional[Dict]:
+        with self.lock:
+            # 优先选择余额最高的
+            available_accounts = [
+                acc for acc in self.accounts if acc.get("balance", 0) > 0
+            ]
+            if not available_accounts:
+                return None
+            return max(available_accounts, key=lambda x: x.get("balance", 0))
+
+    def update_account(self, account_data: Dict):
+        with self.lock:
+            for i, acc in enumerate(self.accounts):
+                if acc["session_id"] == account_data["session_id"]:
+                    self.accounts[i] = account_data
+                    break
+        self.save_accounts()
+
+    def get_all_accounts(self) -> List[Dict]:
+        with self.lock:
+            return self.accounts.copy()
+
+
+class KeyMaintainer(threading.Thread):
+    def __init__(
+        self, account_manager: AccountManager, client: FreeplayClient, config: Dict
+    ):
+        super().__init__(daemon=True)
+        self.manager = account_manager
+        self.client = client
+        self.config = config
+
+    def run(self):
+        while True:
+            try:
+                logging.info("KeyMaintainer: Starting maintenance cycle.")
+                accounts = self.manager.get_all_accounts()
+
+                # 更新所有账户余额
+                for account in accounts:
+                    balance = self.client.check_balance(account["session_id"])
+                    if balance != account.get("balance"):
+                        account["balance"] = balance
+                        self.manager.update_account(account)
+                        logging.info(
+                            f"Account {account['email']} balance updated to ${balance:.4f}"
+                        )
+
+                # 检查是否需要注册新账号
+                healthy_accounts = [
+                    acc
+                    for acc in self.manager.get_all_accounts()
+                    if acc.get("balance", 0) > self.config["LOW_BALANCE_THRESHOLD"]
+                ]
+                needed = self.config["ACTIVE_KEY_THRESHOLD"] - len(healthy_accounts)
+
+                if needed > 0:
+                    logging.info(
+                        f"Healthy accounts ({len(healthy_accounts)}) below threshold ({self.config['ACTIVE_KEY_THRESHOLD']}). Need to register {needed} new accounts."
+                    )
+                    with concurrent.futures.ThreadPoolExecutor(
+                        max_workers=self.config["REGISTRATION_CONCURRENCY"]
+                    ) as executor:
+                        futures = [
+                            executor.submit(self.client.register) for _ in range(needed)
+                        ]
+                        for future in concurrent.futures.as_completed(futures):
+                            new_account = future.result()
+                            if new_account:
+                                self.manager.add_account(new_account)
+                else:
+                    logging.info(
+                        f"Sufficient healthy accounts ({len(healthy_accounts)}). No registration needed."
+                    )
+
+            except Exception as e:
+                logging.error(f"Error in KeyMaintainer cycle: {e}")
+
+            time.sleep(self.config["CHECK_INTERVAL_SECONDS"])
+
+
+# --- FastAPI应用 ---
+app = FastAPI(title="Freeplay.ai to OpenAI API Adapter")
+security = HTTPBearer()
+
+
+def initialize_app():
+    global config, account_manager, freeplay_client, valid_client_keys, proxy_pool
+
+    with app_lock:
+        if account_manager:  # 已经初始化
+            return
+
+        # 1. 加载配置
+        if not os.path.exists("config.json"):
+            default_config = {
+                "HOST": "0.0.0.0",
+                "PORT": 8057,
+                "ACCOUNTS_FILE": "accounts.json",
+                "LOW_BALANCE_THRESHOLD": 2.0,
+                "ACTIVE_KEY_THRESHOLD": 5,
+                "CHECK_INTERVAL_SECONDS": 300,
+                "REGISTRATION_CONCURRENCY": 2,
+                "USE_PROXY_POOL": True,
+                "PROXY_POOL_CONFIG": {
+                    "target_count": 20,
+                    "min_threshold": 5,
+                    "check_interval": 180,
+                }
+            }
+            with open("config.json", "w") as f:
+                json.dump(default_config, f, indent=4)
+            config = default_config
+            logging.info("Created default config.json")
+        else:
+            with open("config.json", "r") as f:
+                config = json.load(f)
+            logging.info("Loaded config from config.json")
+
+        # 2. 加载客户端密钥
+        api_key = os.environ.get("API_KEY", "sk-123456")
+        valid_client_keys = {api_key}
+        logging.info("Loaded API_KEY from environment variable.")
+
+        # 3. 初始化代理池
+        if config.get("USE_PROXY_POOL"):
+            logging.info("Initializing proxy pool...")
+            proxy_pool_config = config.get("PROXY_POOL_CONFIG", {})
+            proxy_pool = ProxyPool(proxy_pool_config)
+            proxy_pool.initialize()
+            logging.info("Proxy pool initialized.")
+        else:
+            logging.info("Proxy pool is disabled in config.")
+
+        # 4. 初始化服务
+        freeplay_client = FreeplayClient(proxy_pool_instance=proxy_pool)
+        account_manager = AccountManager(filepath=config["ACCOUNTS_FILE"])
+
+        # 5. 启动后台维护线程
+        maintainer = KeyMaintainer(account_manager, freeplay_client, config)
+        maintainer.start()
+        logging.info("Key maintenance service started.")
+
+
+async def authenticate_client(auth: HTTPAuthorizationCredentials = Depends(security)):
+    if not auth or auth.credentials not in valid_client_keys:
+        raise HTTPException(status_code=403, detail="Invalid client API key.")
+
+
+@app.on_event("startup")
+async def startup_event():
+    initialize_app()
+
+
+@app.get("/v1/models", response_model=ModelList)
+async def list_models(_: None = Depends(authenticate_client)):
+    model_infos = [
+        ModelInfo(id=name, owned_by=details["provider"])
+        for name, details in MODEL_MAPPING.items()
+    ]
+    return ModelList(data=model_infos)
+
+
+def stream_generator(
+    response: requests.Response, model_name: str, account: Dict
+) -> Generator[str, None, None]:
+    chat_id = f"chatcmpl-{uuid.uuid4().hex}"
+    created = int(time.time())
+
+    # Start chunk
+    start_chunk = StreamResponse(
+        model=model_name, choices=[StreamChoice(delta={"role": "assistant"})]
+    ).dict()
+    start_chunk["id"] = chat_id
+    start_chunk["created"] = created
+    yield f"data: {json.dumps(start_chunk)}\n\n"
+
+    try:
+        for line in response.iter_lines(decode_unicode=True):
+            if line and line.startswith("data: "):
+                try:
+                    data = json.loads(line[6:])
+                    if data.get("content"):
+                        chunk = StreamResponse(
+                            model=model_name,
+                            choices=[StreamChoice(delta={"content": data["content"]})],
+                        ).dict()
+                        chunk["id"] = chat_id
+                        chunk["created"] = created
+                        yield f"data: {json.dumps(chunk)}\n\n"
+                    if data.get("cost") is not None:
+                        break  # 结束
+                except json.JSONDecodeError:
+                    continue
+    finally:
+        # End chunk
+        end_chunk = StreamResponse(
+            model=model_name, choices=[StreamChoice(delta={}, finish_reason="stop")]
+        ).dict()
+        end_chunk["id"] = chat_id
+        end_chunk["created"] = created
+        yield f"data: {json.dumps(end_chunk)}\n\n"
+        yield "data: [DONE]\n\n"
+
+        # 更新余额
+        new_balance = freeplay_client.check_balance(account["session_id"])
+        if new_balance != account.get("balance"):
+            account["balance"] = new_balance
+            account_manager.update_account(account)
+            logging.info(
+                f"Post-chat balance update for {account['email']}: ${new_balance:.4f}"
+            )
+
+
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    req: ChatCompletionRequest, _: None = Depends(authenticate_client)
+):
+    if req.model not in MODEL_MAPPING:
+        raise HTTPException(status_code=404, detail=f"Model '{req.model}' not found.")
+
+    model_config = MODEL_MAPPING[req.model]
+    messages_dict = [msg.dict() for msg in req.messages]
+
+    # Convert OpenAI vision format to Anthropic format
+    for message in messages_dict:
+        if isinstance(message.get("content"), list):
+            new_content = []
+            for part in message["content"]:
+                if part.get("type") == "text":
+                    new_content.append({"type": "text", "text": part.get("text", "")})
+                elif part.get("type") == "image_url":
+                    image_url = part.get("image_url", {}).get("url", "")
+                    if image_url.startswith("data:"):
+                        try:
+                            # "data:image/jpeg;base64,{base64_string}"
+                            header, encoded = image_url.split(",", 1)
+                            media_type = header.split(":")[1].split(";")[0]
+                            new_content.append(
+                                {
+                                    "type": "image",
+                                    "source": {
+                                        "type": "base64",
+                                        "media_type": media_type,
+                                        "data": encoded,
+                                    },
+                                }
+                            )
+                        except Exception as e:
+                            logging.warning(f"Could not parse image data URL: {e}")
+            message["content"] = new_content
+
+    # 账户选择和重试逻辑
+    max_retries = len(account_manager.get_all_accounts())
+    for attempt in range(max_retries):
+        account = account_manager.get_account()
+        if not account:
+            raise HTTPException(
+                status_code=503, detail="No available accounts in the pool."
+            )
+
+        try:
+            params = {
+                "max_tokens": req.max_tokens,
+                "temperature": req.temperature,
+                "top_p": req.top_p,
+            }
+            response = freeplay_client.chat(
+                account["session_id"],
+                account["project_id"],
+                model_config,
+                messages_dict,
+                params,
+            )
+
+            if response.status_code == 200:
+                # 请求成功
+                if req.stream:
+                    return StreamingResponse(
+                        stream_generator(response, req.model, account),
+                        media_type="text/event-stream",
+                    )
+                else:
+                    full_content = ""
+                    for line in response.iter_lines(decode_unicode=True):
+                        if line and line.startswith("data: "):
+                            try:
+                                data = json.loads(line[6:])
+                                full_content += data.get("content", "")
+                                if data.get("cost") is not None:
+                                    break
+                            except json.JSONDecodeError:
+                                continue
+
+                    # 更新余额
+                    new_balance = freeplay_client.check_balance(account["session_id"])
+                    account["balance"] = new_balance
+                    account_manager.update_account(account)
+                    logging.info(
+                        f"Post-chat balance update for {account['email']}: ${new_balance:.4f}"
+                    )
+
+                    return ChatCompletionResponse(
+                        model=req.model,
+                        choices=[
+                            ChatCompletionChoice(
+                                message=ChatMessage(
+                                    role="assistant", content=full_content
+                                )
+                            )
+                        ],
+                    )
+
+            elif response.status_code in [401, 403, 404]:
+                logging.warning(
+                    f"Account {account['email']} failed with status {response.status_code}. Disabling it."
+                )
+                account["balance"] = 0.0  # 禁用账户
+                account_manager.update_account(account)
+                continue  # 重试下一个
+            else:
+                logging.error(
+                    f"API call failed with status {response.status_code}: {response.text}"
+                )
+                response.raise_for_status()
+
+        except requests.exceptions.ProxyError:
+            # Proxy error was already logged and handled in FreeplayClient
+            logging.warning(f"Retrying request due to proxy error.")
+            # Don't disable the account, just retry with a new proxy (and potentially new account)
+            continue
+        except Exception as e:
+            logging.error(
+                f"Error with account {account['email']}: {e}. Trying next account."
+            )
+            account["balance"] = 0.0  # 发生未知异常也禁用
+            account_manager.update_account(account)
+            continue
+
+    raise HTTPException(
+        status_code=503, detail="All available accounts failed to process the request."
+    )
+
+
+@app.get("/admin/accounts/status")
+async def accounts_status(_: None = Depends(authenticate_client)):
+    accounts = account_manager.get_all_accounts()
+    total_balance = sum(acc.get("balance", 0) for acc in accounts)
+    healthy_count = len(
+        [
+            acc
+            for acc in accounts
+            if acc.get("balance", 0) > config.get("LOW_BALANCE_THRESHOLD", 2.0)
+        ]
+    )
+
+    return JSONResponse(
+        {
+            "total_accounts": len(accounts),
+            "healthy_accounts": healthy_count,
+            "total_balance": f"${total_balance:.4f}",
+            "accounts": [
+                {
+                    "email": acc.get("email"),
+                    "balance": f"${acc.get('balance', 0):.4f}",
+                    "project_id": acc.get("project_id"),
+                }
+                for acc in accounts
+            ],
+        }
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    initialize_app()
+    logging.info("--- Freeplay.ai to OpenAI API Adapter ---")
+    logging.info(f"Starting server on {config['HOST']}:{config['PORT']}")
+    logging.info(f"Supported models: {list(MODEL_MAPPING.keys())}")
+    logging.info(f"Client keys loaded: {len(valid_client_keys)}")
+    logging.info(f"Accounts loaded: {len(account_manager.get_all_accounts())}")
+    logging.info("Endpoints:")
+    logging.info("  POST /v1/chat/completions (Client API Key Auth)")
+    logging.info("  GET  /v1/models (Client API Key Auth)")
+    logging.info("  GET  /admin/accounts/status (Client API Key Auth)")
+
+    uvicorn.run(app, host=config["HOST"], port=config["PORT"])

proxy_pool.py

@@ -0,0 +1,211 @@
+import requests
+import threading
+import time
+import random
+from datetime import datetime, timedelta
+
+class ProxyPool:
+    def __init__(self, options={}):
+        self.target_count = options.get('target_count', 20)
+        self.batch_size = options.get('batch_size', 20)
+        self.test_timeout = options.get('test_timeout', 5)
+        self.request_timeout = options.get('request_timeout', 10)
+        self.target_url = options.get('target_url', 'https://app.freeplay.ai/')
+        self.concurrent_requests = options.get('concurrent_requests', 10)
+        self.min_threshold = options.get('min_threshold', 5)
+        self.check_interval = options.get('check_interval', 30)
+        self.proxy_protocol = options.get('proxy_protocol', 'http')
+        self.max_refill_attempts = options.get('max_refill_attempts', 20)
+        self.retry_delay = options.get('retry_delay', 1)
+
+        self.available_proxies = []
+        self.current_index = 0
+        self.is_initialized = False
+        self.is_refilling = False
+        self.check_timer = None
+        self.lock = threading.Lock()
+
+    def initialize(self):
+        if self.is_initialized:
+            return
+        print(f"Initializing proxy pool, target count: {self.target_count}")
+        self.refill_proxies()
+        self.check_timer = threading.Timer(self.check_interval, self.check_and_refill)
+        self.check_timer.start()
+        self.is_initialized = True
+        print(f"Proxy pool initialized, current available proxies: {len(self.available_proxies)}")
+
+    def stop(self):
+        if self.check_timer:
+            self.check_timer.cancel()
+            self.check_timer = None
+        print("Proxy pool service stopped")
+
+    def check_and_refill(self):
+        with self.lock:
+            if len(self.available_proxies) <= self.min_threshold and not self.is_refilling:
+                print(f"Available proxies ({len(self.available_proxies)}) below threshold ({self.min_threshold}), starting refill")
+                self.refill_proxies()
+        if self.is_initialized:
+            self.check_timer = threading.Timer(self.check_interval, self.check_and_refill)
+            self.check_timer.start()
+
+    def refill_proxies(self):
+        if self.is_refilling:
+            return
+        self.is_refilling = True
+        print(f"Starting to refill proxies, current count: {len(self.available_proxies)}, target: {self.target_count}")
+        
+        attempts = 0
+        try:
+            while len(self.available_proxies) < self.target_count and attempts < self.max_refill_attempts:
+                attempts += 1
+                print(f"Refill attempt #{attempts}, current available: {len(self.available_proxies)}/{self.target_count}")
+                
+                remaining_needed = self.target_count - len(self.available_proxies)
+                batch_size_needed = max(self.batch_size, remaining_needed * 2)
+                
+                proxies = self.get_proxies_from_provider(batch_size_needed)
+                if not proxies:
+                    print(f"No proxies received, retrying in {self.retry_delay} seconds...")
+                    time.sleep(self.retry_delay)
+                    continue
+
+                new_proxies = self.filter_existing_proxies(proxies)
+                if not new_proxies:
+                    print("All fetched proxies already exist, getting new ones...")
+                    continue
+
+                threads = []
+                for proxy in new_proxies:
+                    thread = threading.Thread(target=self.test_and_add_proxy, args=(proxy,))
+                    threads.append(thread)
+                    thread.start()
+                
+                for thread in threads:
+                    thread.join()
+
+                if len(self.available_proxies) >= self.target_count:
+                    break
+                if len(self.available_proxies) < self.target_count:
+                    time.sleep(self.retry_delay)
+        except Exception as e:
+            print(f"Error during proxy refill: {e}")
+        finally:
+            self.is_refilling = False
+            if len(self.available_proxies) >= self.target_count:
+                print(f"Proxy refill complete, current available: {len(self.available_proxies)}/{self.target_count}")
+            else:
+                print(f"Max refill attempts reached, current available: {len(self.available_proxies)}/{self.target_count}")
+
+    def test_and_add_proxy(self, proxy):
+        if self.test_proxy(proxy):
+            with self.lock:
+                if not any(p['full'] == f"{self.proxy_protocol}://{proxy}" for p in self.available_proxies):
+                    ip, port = proxy.split(':')
+                    proxy_obj = {
+                        'ip': ip,
+                        'port': port,
+                        'protocol': self.proxy_protocol,
+                        'full': f"{self.proxy_protocol}://{proxy}",
+                        'added_at': datetime.now().isoformat()
+                    }
+                    self.available_proxies.append(proxy_obj)
+                    print(f"Successfully added proxy: {proxy_obj['full']}, current available: {len(self.available_proxies)}/{self.target_count}")
+
+    def filter_existing_proxies(self, proxies):
+        existing = {f"{p['ip']}:{p['port']}" for p in self.available_proxies}
+        return [p for p in proxies if p not in existing]
+
+    def get_proxies_from_provider(self, count=None):
+        try:
+            request_count = count or self.batch_size
+            url = f"https://proxy.scdn.io/api/get_proxy.php?protocol={self.proxy_protocol}&count={request_count}"
+            print(f"Getting proxies from: {url}")
+            response = requests.get(url, timeout=10)
+            if response.status_code == 200:
+                data = response.json()
+                if data.get('code') == 200:
+                    print(f"Successfully got {data['data']['count']} proxies")
+                    return data['data']['proxies']
+            print(f"Failed to get proxies: {response.text}")
+            return []
+        except Exception as e:
+            print(f"Error getting proxies: {e}")
+            return []
+
+    def test_proxy(self, proxy_url):
+        try:
+            proxies = {self.proxy_protocol: f"{self.proxy_protocol}://{proxy_url}"}
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            }
+            response = requests.get(self.target_url, proxies=proxies, headers=headers, timeout=self.request_timeout, allow_redirects=True)
+            is_valid = response.status_code == 200
+            if is_valid:
+                print(f"Proxy {proxy_url} successfully tested, status: {response.status_code}")
+            else:
+                print(f"Proxy {proxy_url} failed test, status: {response.status_code}")
+            return is_valid
+        except Exception as e:
+            print(f"Proxy {proxy_url} request error: {e}")
+            return False
+
+    def get_proxy(self):
+        with self.lock:
+            if not self.available_proxies:
+                print("No available proxies")
+                return None
+            proxy = self.available_proxies[self.current_index]
+            self.current_index = (self.current_index + 1) % len(self.available_proxies)
+            return proxy
+
+    def remove_proxy(self, ip, port):
+        with self.lock:
+            port_str = str(port)
+            initial_length = len(self.available_proxies)
+            self.available_proxies = [p for p in self.available_proxies if not (p['ip'] == ip and p['port'] == port_str)]
+            if self.current_index >= len(self.available_proxies) and self.available_proxies:
+                self.current_index = 0
+            removed = initial_length > len(self.available_proxies)
+            if removed:
+                print(f"Removed proxy {ip}:{port}, current available: {len(self.available_proxies)}")
+            else:
+                print(f"Could not find proxy to remove {ip}:{port}")
+            self.check_and_refill()
+            return removed
+
+    def get_all_proxies(self):
+        with self.lock:
+            return list(self.available_proxies)
+
+    def get_count(self):
+        with self.lock:
+            return len(self.available_proxies)
+
+if __name__ == '__main__':
+    proxy_pool = ProxyPool({
+        'target_count': 10,
+        'min_threshold': 3,
+        'check_interval': 60,
+        'target_url': 'https://app.freeplay.ai/',
+        'concurrent_requests': 15,
+        'max_refill_attempts': 15,
+        'retry_delay': 1
+    })
+    proxy_pool.initialize()
+    
+    time.sleep(5)
+    proxy = proxy_pool.get_proxy()
+    print(f"Got proxy: {proxy}")
+
+    if proxy:
+        time.sleep(5)
+        proxy_pool.remove_proxy(proxy['ip'], proxy['port'])
+
+    all_proxies = proxy_pool.get_all_proxies()
+    print(f"Current all proxies ({len(all_proxies)}): {all_proxies}")
+
+    time.sleep(5)
+    proxy_pool.stop()
+    print("Proxy pool example finished.")

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+faker
+requests
+uvicorn
+python-multipart
+pydantic==1.10.16