Upload 3 files

Dockerfile

@@ -1,53 +1,21 @@
-# --- Stage 1: Build Dependencies ---
-FROM python:3.9-slim as builder
-
-# Set environment variables to prevent writing .pyc files and for unbuffered output
-ENV PYTHONDONTWRITEBYTECODE 1
-ENV PYTHONUNBUFFERED 1
-
-# Set working directory
-WORKDIR /app
-
-# Install uvloop and gunicorn first as they are core dependencies
-RUN pip install --no-cache-dir uvloop gunicorn
-
-# Copy requirements and install the rest of the packages
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-
-# --- Stage 2: Final Production Image ---
+# Use an official Python runtime as a parent image
 FROM python:3.9-slim
 
-# Set the working directory
+# Set the working directory in the container
 WORKDIR /app
 
-# Set same environment variables for consistency
-ENV PYTHONDONTWRITEBYTECODE 1
-ENV PYTHONUNBUFFERED 1
-
-# Create a non-root user and group for security
-# This is a more robust way to create a user with a home directory
-RUN addgroup --system app && adduser --system --ingroup app --shell /bin/sh --home /app app
-
-# Copy installed packages AND binaries from the builder stage
-# This is the CRUCIAL FIX: copying /usr/local/bin where gunicorn lives
-COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
-COPY --from=builder /usr/local/bin /usr/local/bin
-
-# Copy the application code
-COPY . .
+# Copy the dependencies file to the working directory
+COPY requirements.txt .
 
-# Change ownership of the app directory to the non-root user
-# This ensures the user can read the files
-RUN chown -R app:app /app
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Switch to the non-root user
-USER app
+# Copy the rest of the application's code to the working directory
+COPY main.py .
 
 # Expose the port the app runs on
 EXPOSE 8000
 
-# Run the application using Gunicorn
-# The command is now guaranteed to be in the PATH
-CMD ["gunicorn", "-c", "gunicorn_conf.py", "main:app"]
+# Run the application with Uvicorn
+# The host 0.0.0.0 makes the server accessible from outside the container
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

main.py

@@ -1,121 +1,111 @@
 import httpx
 from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import StreamingResponse
-import json
-import random
-import logging
-import ipaddress
+from starlette.responses import StreamingResponse
+from starlette.background import BackgroundTask
+import os
+from contextlib import asynccontextmanager
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S",
-)
-
-app = FastAPI()
+# --- Configuration ---
+# The target URL is configurable via an environment variable.
+TARGET_URL = os.getenv("TARGET_URL", "https://console.gmicloud.ai")
 
-# List of API URLs to be randomized
-API_URLS = [
-    "https://api.deepinfra.com/v1/openai/chat/completions",
-    "https://stage.api.deepinfra.com/v1/openai/chat/completions",
-]
+# --- HTTPX Client Lifecycle Management ---
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Manages the lifecycle of the HTTPX client.
+    The client is created on startup and gracefully closed on shutdown.
 
-# A pool of User-Agents (you can expand this list)
-USER_AGENTS = [
-    # Chrome (Windows)
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
-    # Firefox (Windows)
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0",
-    # Safari (macOS)
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15",
-    # Edge (Windows)
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 Edg/140.0.0.0",
-    # Chrome (Android)
-    "Mozilla/5.0 (Linux; Android 14; Pixel 7 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Mobile Safari/537.36",
-    # Safari (iOS)
-    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1",
-]
+    WARNING: This client has no timeout and no explicit connection pool limits.
+    """
+    # timeout=None disables all client-side timeouts.
+    # The absence of a `limits` parameter means we rely on system defaults.
+    async with httpx.AsyncClient(base_url=TARGET_URL, timeout=None) as client:
+        app.state.http_client = client
+        yield
 
-def generate_random_ip() -> str:
-    """Generate a random IPv4 address, avoiding reserved ranges."""
-    while True:
-        ip = ipaddress.IPv4Address(random.getrandbits(32))
-        if not (ip.is_private or ip.is_multicast or ip.is_reserved or ip.is_loopback):
-            return str(ip)
+# Initialize the FastAPI app with the lifespan manager and disable default docs
+app = FastAPI(docs_url=None, redoc_url=None, lifespan=lifespan)
 
-@app.post("/v1/openai/chat/completions")
-async def proxy_deepinfra(request: Request):
+# --- Reverse Proxy Logic ---
+async def _reverse_proxy(request: Request):
     """
-    Proxies chat completion requests to the DeepInfra API.
-    Randomizes API URLs, spoofed random IP, fake headers, and User-Agent rotation.
+    Forwards a request specifically for the /chat endpoint to the target URL.
+    It injects required headers and strips any user-provided Authorization header.
     """
-    try:
-        body = await request.json()
-    except json.JSONDecodeError:
-        raise HTTPException(status_code=400, detail="Invalid JSON in request body")
+    client: httpx.AsyncClient = request.app.state.http_client
+
+    # Construct the URL for the outgoing request using the incoming path and query.
+    url = httpx.URL(path=request.url.path, query=request.url.query.encode("utf-8"))
+
+    # --- Header Processing ---
+    # Start with headers from the incoming request.
+    request_headers = dict(request.headers)
 
-    # Random spoofed IP + random User-Agent
-    random_ip = generate_random_ip()
-    user_agent = random.choice(USER_AGENTS)
+    # 1. CRITICAL: Remove host and authorization headers.
+    #    The 'host' header is managed by httpx.
+    #    Removing 'authorization' prevents the user's key from reaching the backend.
+    request_headers.pop("host", None)
+    request_headers.pop("authorization", None)
 
-    headers = {
-        # Browser/device headers
-        "User-Agent": user_agent,
-        "accept": "text/event-stream",
-        "sec-ch-ua": '"Chromium";v="140", "Not=A?Brand";v="24", "Google Chrome";v="140"',
+    # 2. Set the specific, required headers for the target API.
+    #    This will overwrite any conflicting headers from the original request.
+    specific_headers = {
+        "accept": "application/json, text/plain, */*",
+        "accept-language": "en-US,en;q=0.9,ru;q=0.8",
+        "content-type": "application/json",
+        "origin": "https://console.gmicloud.ai",
+        "priority": "u=1, i",
+        "referer": "https://console.gmicloud.ai/playground/llm/deepseek-r1-0528/01da5dd6-aa6a-40cb-9dbd-241467aa5cbb?tab=playground",
+        "sec-ch-ua": '"Not;A=Brand";v="99", "Google Chrome";v="139", "Chromium";v="139"',
         "sec-ch-ua-mobile": "?0",
         "sec-ch-ua-platform": '"Windows"',
-        "Referer": "https://deepinfra.com/",
-        "Origin": "https://deepinfra.com",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36",
+    }
+    request_headers.update(specific_headers)
 
-        # Spoofed IP headers
-        "X-Forwarded-For": random_ip,
-        "X-Real-IP": random_ip,
-        "Forwarded": f"for={random_ip};proto=https",
+    # Build the final request to the target service.
+    rp_req = client.build_request(
+        method=request.method,
+        url=url,
+        headers=request_headers,
+        content=await request.body(),
+    )
 
-        # Extra fake headers
-        "DNT": "1",
-        "Pragma": "no-cache",
-        "Cache-Control": "no-cache",
-        "Accept-Encoding": "gzip, deflate, br, zstd",
-        "Accept-Language": "en-US,en;q=0.9,fr;q=0.8,de;q=0.7",
-        "Upgrade-Insecure-Requests": "1",
-        "Sec-Fetch-Dest": "document",
-        "Sec-Fetch-Mode": "navigate",
-        "Sec-Fetch-Site": "none",
-        "Sec-Fetch-User": "?1",
+    try:
+        # Send the request and get a streaming response.
+        rp_resp = await client.send(rp_req, stream=True)
+    except httpx.ConnectError as e:
+        # This error occurs if the target service is down or unreachable.
+        raise HTTPException(status_code=502, detail=f"Bad Gateway: Cannot connect to target service. {e}")
 
-        # Deepinfra-specific
-        "X-Deepinfra-Source": request.headers.get("X-Deepinfra-Source", "web-embed"),
-        "Content-Type": "application/json",
-    }
+    # Stream the response from the target service back to the original client.
+    return StreamingResponse(
+        rp_resp.aiter_raw(),
+        status_code=rp_resp.status_code,
+        headers=rp_resp.headers,
+        background=BackgroundTask(rp_resp.aclose),
+    )
 
-    shuffled_urls = random.sample(API_URLS, len(API_URLS))
+# --- API Endpoint ---
+@app.api_route(
+    "/chat",
+    methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]
+)
+async def chat_proxy_handler(request: Request):
+    """
+    This endpoint captures requests specifically for the "/chat" path
+    and forwards them through the reverse proxy.
+    """
+    return await _reverse_proxy(request)
 
-    async def stream_generator():
-        last_error = None
-        for url in shuffled_urls:
-            logging.info(
-                f"Attempting to connect to: {url} with spoofed IP {random_ip} and UA {user_agent}"
-            )
-            try:
-                async with httpx.AsyncClient() as client:
-                    async with client.stream(
-                        "POST", url, headers=headers, json=body, timeout=None
-                    ) as response:
-                        response.raise_for_status()
-                        logging.info(f"Successfully connected. Streaming from: {url}")
-                        async for chunk in response.aiter_bytes():
-                            yield chunk
-                        return
-            except (httpx.RequestError, httpx.HTTPStatusError) as e:
-                last_error = e
-                logging.warning(
-                    f"Failed to connect to {url}: {e}. Trying next URL."
-                )
-                continue
-        if last_error:
-            logging.error(f"All API endpoints failed. Last error: {last_error}")
+# A simple root endpoint for health checks.
+@app.get("/")
+async def health_check():
+    """Provides a basic health check endpoint."""
+    return {"status": "ok", "proxying_endpoint": "/chat", "target": "TypeGPT"}
 
-    return StreamingResponse(stream_generator(), media_type="text-event-stream")
+# Any request to a path other than "/chat" or "/" will result in a 404 Not Found.

requirements.txt

@@ -1,5 +1,3 @@
 fastapi
 uvicorn
 httpx
-gunicorn
-uvloop