qwenchat2api

.gitignore

@@ -0,0 +1 @@
+.idea

Dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.13-slim
+WORKDIR /app
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . /app/
+RUN touch /app/app.log && chmod 777 /app/app.log
+EXPOSE 8080
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8080"]

README.md

@@ -5,6 +5,7 @@ colorFrom: red
 colorTo: indigo
 sdk: docker
 pinned: false
+app_port: 8080
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,287 @@
+import json
+import time
+import traceback
+from fastapi import FastAPI, HTTPException, Request, Depends, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse, JSONResponse
+import httpx
+import logging
+import random
+import uvicorn
+import asyncio
+
+QWEN_API_URL = 'https://chat.qwenlm.ai/api/chat/completions'
+QWEN_MODELS_URL = 'https://chat.qwenlm.ai/api/models'
+MAX_RETRIES = 3
+RETRY_DELAY = 1
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+client = httpx.AsyncClient()
+
+async def fetch_with_retry(url, options, retries=MAX_RETRIES):
+    last_error = None
+    auth_header = options.get('headers', {}).get('Authorization', '')
+    if auth_header.startswith('Bearer '):
+        logger.info(f"Processing request with session identifier: {auth_header[7:]}")
+
+    for i in range(retries):
+        try:
+            async with httpx.AsyncClient() as client:
+                if 'headers' in options:
+                    client.headers.update(options['headers'])
+
+                response = await client.request(
+                    method=options.get('method', 'GET'),
+                    url=url,
+                    content=options.get('body'),
+                    timeout=60
+                )
+
+                content_type = response.headers.get('content-type', '')
+
+                if 'text/html' in content_type or response.status_code == 500:
+                    last_error = {
+                        'status': response.status_code,
+                        'contentType': content_type,
+                        'responseText': response.text[:1000],
+                        'headers': dict(response.headers)
+                    }
+                    if i < retries - 1:
+                        logger.error(f"Retry attempt {i+1} for session {auth_header[7:]} failed")
+                        await asyncio.sleep(RETRY_DELAY * (i + 1))
+                        continue
+
+                return response
+
+        except Exception as error:
+            last_error = error
+            logger.error(f"Connection error for session {auth_header[7:]} on attempt {i+1}")
+            traceback.print_exc()
+            if i < retries - 1:
+                await asyncio.sleep(RETRY_DELAY * (i + 1))
+                continue
+
+    raise Exception(json.dumps({
+        'error': True,
+        'message': 'All retry attempts failed',
+        'lastError': str(last_error),
+        'retries': retries
+    }))
+
+async def process_line(line, previous_content):
+    try:
+        data = json.loads(line[6:])
+        if data.get('choices') and data['choices'][0].get('delta') and data['choices'][0]['delta'].get('content'):
+            current_content = data['choices'][0]['delta']['content']
+            new_content = current_content
+            if current_content.startswith(previous_content) and len(previous_content) > 0:
+                new_content = current_content[len(previous_content):]
+
+            new_data = {
+                **data,
+                'choices': [{
+                    **data['choices'][0],
+                    'delta': {
+                        **data['choices'][0]['delta'],
+                        'content': new_content
+                    }
+                }]
+            }
+            yield f"data: {json.dumps(new_data)}\n\n"
+        else:
+            yield f"data: {json.dumps(data)}\n\n"
+
+    except Exception:
+        yield f"{line}\n\n"
+
+async def handle_stream(response, previous_content):
+    buffer = ''
+    try:
+        async for chunk in response.aiter_bytes():
+            decoded_chunk = chunk.decode('utf-8')
+            buffer += decoded_chunk
+
+            lines = buffer.split('\n')
+            buffer = lines.pop() or ''
+
+            for line in lines:
+                if line.strip().startswith('data: '):
+                    async for processed_chunk in process_line(line, previous_content):
+                        yield processed_chunk
+                        result = processed_chunk.split("\n\n")[0].replace("data: ", "")
+                        result = json.loads(result)['choices'][0]['delta']['content']
+                        if result:
+                            previous_content = previous_content + result
+
+        yield "data: [DONE]\n\n"
+
+    except Exception as error:
+        yield f"data: {{\"error\":true,\"message\":\"{str(error)}\"}}\n\n"
+        yield "data: [DONE]\n\n"
+
+async def get_openai_auth_headers(request: Request) -> dict:
+    auth_header = request.headers.get("Authorization")
+    if not auth_header:
+        raise HTTPException(status_code=401, detail="Missing Authorization header")
+    logger.info(f"New request authenticated with session {auth_header[7:]}")
+    return {"Authorization": auth_header}
+
+async def make_request(method, url, headers, body, api_keys=None, retry_count=0):
+    try:
+        if api_keys and len(api_keys) > 1:
+            remaining_keys = api_keys.copy()
+            while remaining_keys and retry_count < 3:
+                selected_key = random.choice(remaining_keys)
+                remaining_keys.remove(selected_key)
+                headers = {**headers, "Authorization": f"Bearer {selected_key}"}
+                logger.info(f"Attempting request with API key: {selected_key}")
+
+                try:
+                    async with httpx.AsyncClient() as client:
+
+                        r = await client.request(
+                            method,
+                            url,
+                            headers=headers,
+                            content=body,
+                            timeout=600
+                        )
+                        if r.status_code < 400:
+                            return r
+                        logger.error(f"Request failed with key {selected_key}, status code: {r.status_code}")
+                except Exception as e:
+                    logger.error(f"Request failed with key {selected_key}: {str(e)}")
+                retry_count += 1
+
+            raise HTTPException(status_code=500, detail="All API keys failed")
+        else:
+            while retry_count < 3:
+                single_key = api_keys[0] if api_keys else headers.get("authorization", "").replace("Bearer ", "").strip()
+                request_headers = {**headers, "Authorization": f"Bearer {single_key}"}
+                logger.info(f"Attempting request with API key: {single_key}")
+                try:
+                    async with httpx.AsyncClient() as client:
+                        r = await client.request(
+                            method,
+                            url,
+                            headers=request_headers,
+                            content=body,
+                            timeout=600
+                        )
+                        if r.status_code < 400:
+                            return r
+                        logger.error(f"Request attempt {retry_count + 1} failed for session {single_key}")
+                except Exception as e:
+                    logger.error(f"Connection attempt {retry_count + 1} failed for session {single_key}")
+                retry_count += 1
+
+            raise HTTPException(status_code=500, detail="Request failed after 3 retries")
+
+    except Exception as e:
+        logger.error(f"Request failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.api_route(
+    "/api/chat/completions",
+    methods=["POST", "OPTIONS"],
+)
+async def chat_completions(request: Request, auth_headers: dict = Depends(get_openai_auth_headers)):
+    headers = dict(request.headers)
+    if "content-length" in headers:
+        del headers["content-length"]
+    if "host" in headers:
+        del headers["host"]
+
+    request_body = await request.body()
+
+    try:
+        request_data = json.loads(request_body.decode('utf-8'))
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+
+    messages = request_data.get('messages')
+    stream = request_data.get('stream', False)
+    model = request_data.get('model')
+    max_tokens = request_data.get('max_tokens')
+
+    if not model:
+        raise HTTPException(status_code=400, detail="Model parameter is required")
+
+    qwen_request = {
+        'model': model,
+        'messages': messages,
+        'stream': stream
+    }
+
+    if max_tokens is not None:
+        qwen_request['max_tokens'] = max_tokens
+
+    try:
+        response = await fetch_with_retry(QWEN_API_URL, {
+            'method': 'POST',
+            'headers': {
+                'Content-Type': 'application/json',
+                **auth_headers
+            },
+            'body': json.dumps(qwen_request),
+            'stream': stream
+        })
+
+        if stream:
+            previous_content = ''
+            return StreamingResponse(handle_stream(response, previous_content), media_type="text/event-stream")
+        else:
+            return Response(content=response.content, status_code=response.status_code, headers=response.headers)
+
+    except Exception as error:
+        raise HTTPException(status_code=500, detail=str(error))
+
+@app.get("/api/models")
+async def models(request: Request, auth_headers: dict = Depends(get_openai_auth_headers)):
+    try:
+        response = await fetch_with_retry(QWEN_MODELS_URL, {
+            'method': 'GET',
+            'headers': {
+                'Content-Type': 'application/json',
+                **auth_headers
+            },
+            'timeout': 30
+        })
+
+        response_data = response.json()
+        return JSONResponse(content=response_data)
+
+    except Exception as e:
+        logger.error(f"Error in /api/models: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/')
+async def index(request: Request):
+    return Response(status_code=302, headers={"Location": "https://chat.qwenlm.ai"})
+
+@app.get('/{path:path}')
+@app.post('/{path:path}')
+async def redirect_all(path: str, request: Request):
+    if any(keyword in path.lower() for keyword in ['php', 'admin', 'login', 'wp-admin', 'manager', 'user', 'signin']):
+        return Response(status_code=301, headers={"Location": "http://127.0.0.1"})
+    if request.method == 'POST':
+        return Response(status_code=301, headers={"Location": "http://127.0.0.1"})
+    return Response(status_code=302, headers={"Location": "https://linux.do/u/f-droid"})
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8080)

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+httpx
+python-multipart