diff --git a/g4f/api/__init__.py b/g4f/api/__init__.py
index 83df469a..754a48f1 100644
--- a/g4f/api/__init__.py
+++ b/g4f/api/__init__.py
@@ -14,17 +14,18 @@ from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY, HTTP_401_UNAUTHORIZE
from fastapi.encoders import jsonable_encoder
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
-from typing import Union, Optional
+from typing import Union, Optional, Iterator
import g4f
import g4f.debug
-from g4f.client import Client
+from g4f.client import Client, ChatCompletion, ChatCompletionChunk, ImagesResponse
from g4f.typing import Messages
from g4f.cookies import read_cookie_files
-def create_app():
+def create_app(g4f_api_key: str = None):
app = FastAPI()
- api = Api(app)
+
+ # Add CORS middleware
app.add_middleware(
CORSMiddleware,
allow_origin_regex=".*",
@@ -32,18 +33,19 @@ def create_app():
allow_methods=["*"],
allow_headers=["*"],
)
+
+ api = Api(app, g4f_api_key=g4f_api_key)
api.register_routes()
api.register_authorization()
api.register_validation_exception_handler()
+
+ # Read cookie files if not ignored
if not AppConfig.ignore_cookie_files:
read_cookie_files()
+
return app
-def create_app_debug():
- g4f.debug.logging = True
- return create_app()
-
-class ChatCompletionsForm(BaseModel):
+class ChatCompletionsConfig(BaseModel):
messages: Messages
model: str
provider: Optional[str] = None
@@ -55,15 +57,12 @@ class ChatCompletionsForm(BaseModel):
web_search: Optional[bool] = None
proxy: Optional[str] = None
-class ImagesGenerateForm(BaseModel):
- model: Optional[str] = None
- provider: Optional[str] = None
+class ImageGenerationConfig(BaseModel):
prompt: str
- response_format: Optional[str] = None
- api_key: Optional[str] = None
- proxy: Optional[str] = None
+ model: Optional[str] = None
+ response_format: str = "url"
-class AppConfig():
+class AppConfig:
ignored_providers: Optional[list[str]] = None
g4f_api_key: Optional[str] = None
ignore_cookie_files: bool = False
@@ -74,16 +73,23 @@ class AppConfig():
for key, value in data.items():
setattr(cls, key, value)
+list_ignored_providers: list[str] = None
+
+def set_list_ignored_providers(ignored: list[str]):
+ global list_ignored_providers
+ list_ignored_providers = ignored
+
class Api:
- def __init__(self, app: FastAPI) -> None:
+ def __init__(self, app: FastAPI, g4f_api_key=None) -> None:
self.app = app
self.client = Client()
+ self.g4f_api_key = g4f_api_key
self.get_g4f_api_key = APIKeyHeader(name="g4f-api-key")
def register_authorization(self):
@self.app.middleware("http")
async def authorization(request: Request, call_next):
- if AppConfig.g4f_api_key and request.url.path in ["/v1/chat/completions", "/v1/completions"]:
+ if self.g4f_api_key and request.url.path in ["/v1/chat/completions", "/v1/completions", "/v1/images/generate"]:
try:
user_g4f_api_key = await self.get_g4f_api_key(request)
except HTTPException as e:
@@ -92,22 +98,26 @@ class Api:
status_code=HTTP_401_UNAUTHORIZED,
content=jsonable_encoder({"detail": "G4F API key required"}),
)
- if not secrets.compare_digest(AppConfig.g4f_api_key, user_g4f_api_key):
+ if not secrets.compare_digest(self.g4f_api_key, user_g4f_api_key):
return JSONResponse(
status_code=HTTP_403_FORBIDDEN,
content=jsonable_encoder({"detail": "Invalid G4F API key"}),
)
- return await call_next(request)
+
+ response = await call_next(request)
+ return response
def register_validation_exception_handler(self):
@self.app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
details = exc.errors()
- modified_details = [{
- "loc": error["loc"],
- "message": error["msg"],
- "type": error["type"],
- } for error in details]
+ modified_details = []
+ for error in details:
+ modified_details.append({
+ "loc": error["loc"],
+ "message": error["msg"],
+ "type": error["type"],
+ })
return JSONResponse(
status_code=HTTP_422_UNPROCESSABLE_ENTITY,
content=jsonable_encoder({"detail": modified_details}),
@@ -121,25 +131,23 @@ class Api:
@self.app.get("/v1")
async def read_root_v1():
return HTMLResponse('g4f API: Go to '
- 'chat/completions '
- 'or models.')
+ 'chat/completions, '
+ 'models, or '
+ 'images/generate.')
@self.app.get("/v1/models")
async def models():
- model_list = {
- model: g4f.models.ModelUtils.convert[model]
+ model_list = dict(
+ (model, g4f.models.ModelUtils.convert[model])
for model in g4f.Model.__all__()
- }
+ )
model_list = [{
'id': model_id,
'object': 'model',
'created': 0,
'owned_by': model.base_provider
} for model_id, model in model_list.items()]
- return JSONResponse({
- "object": "list",
- "data": model_list,
- })
+ return JSONResponse(model_list)
@self.app.get("/v1/models/{model_name}")
async def model_info(model_name: str):
@@ -155,7 +163,7 @@ class Api:
return JSONResponse({"error": "The model does not exist."})
@self.app.post("/v1/chat/completions")
- async def chat_completions(config: ChatCompletionsForm, request: Request = None, provider: str = None):
+ async def chat_completions(config: ChatCompletionsConfig, request: Request = None, provider: str = None):
try:
config.provider = provider if config.provider is None else config.provider
if config.api_key is None and request is not None:
@@ -164,17 +172,27 @@ class Api:
auth_header = auth_header.split(None, 1)[-1]
if auth_header and auth_header != "Bearer":
config.api_key = auth_header
- # Use the asynchronous create method and await it
- response = await self.client.chat.completions.async_create(
+
+ # Create the completion response
+ response = self.client.chat.completions.create(
**{
**AppConfig.defaults,
**config.dict(exclude_none=True),
},
ignored=AppConfig.ignored_providers
)
- if not config.stream:
+
+ # Check if the response is synchronous or asynchronous
+ if isinstance(response, ChatCompletion):
+ # Synchronous response
return JSONResponse(response.to_json())
+ if not config.stream:
+ # If the response is an iterator but not streaming, collect the result
+ response_list = list(response) if isinstance(response, Iterator) else [response]
+ return JSONResponse(response_list[0].to_json())
+
+ # Streaming response
async def streaming():
try:
async for chunk in response:
@@ -185,41 +203,38 @@ class Api:
logging.exception(e)
yield f'data: {format_exception(e, config)}\n\n'
yield "data: [DONE]\n\n"
+
return StreamingResponse(streaming(), media_type="text/event-stream")
except Exception as e:
logging.exception(e)
return Response(content=format_exception(e, config), status_code=500, media_type="application/json")
+ @self.app.post("/v1/images/generate")
+ async def generate_image(config: ImageGenerationConfig):
+ try:
+ response: ImagesResponse = await self.client.images.async_generate(
+ prompt=config.prompt,
+ model=config.model,
+ response_format=config.response_format
+ )
+ # Convert Image objects to dictionaries
+ response_data = [image.to_dict() for image in response.data]
+ return JSONResponse({"data": response_data})
+ except Exception as e:
+ logging.exception(e)
+ return Response(content=format_exception(e, config), status_code=500, media_type="application/json")
+
@self.app.post("/v1/completions")
async def completions():
return Response(content=json.dumps({'info': 'Not working yet.'}, indent=4), media_type="application/json")
- @self.app.post("/v1/images/generations")
- async def images_generate(config: ImagesGenerateForm, request: Request = None, provider: str = None):
- try:
- config.provider = provider if config.provider is None else config.provider
- if config.api_key is None and request is not None:
- auth_header = request.headers.get("Authorization")
- if auth_header is not None:
- auth_header = auth_header.split(None, 1)[-1]
- if auth_header and auth_header != "Bearer":
- config.api_key = auth_header
- # Use the asynchronous generate method and await it
- response = await self.client.images.async_generate(
- **config.dict(exclude_none=True),
- )
- return JSONResponse(response.to_json())
- except Exception as e:
- logging.exception(e)
- return Response(content=format_exception(e, config), status_code=500, media_type="application/json")
-
-def format_exception(e: Exception, config: ChatCompletionsForm) -> str:
+def format_exception(e: Exception, config: Union[ChatCompletionsConfig, ImageGenerationConfig]) -> str:
last_provider = g4f.get_last_provider(True)
return json.dumps({
"error": {"message": f"{e.__class__.__name__}: {e}"},
- "model": last_provider.get("model") if last_provider else config.model,
- "provider": last_provider.get("name") if last_provider else config.provider
+ "model": last_provider.get("model") if last_provider else getattr(config, 'model', None),
+ "provider": last_provider.get("name") if last_provider else getattr(config, 'provider', None)
})
def run_api(
@@ -228,18 +243,22 @@ def run_api(
bind: str = None,
debug: bool = False,
workers: int = None,
- use_colors: bool = None
+ use_colors: bool = None,
+ g4f_api_key: str = None
) -> None:
print(f'Starting server... [g4f v-{g4f.version.utils.current_version}]' + (" (debug)" if debug else ""))
if use_colors is None:
use_colors = debug
if bind is not None:
host, port = bind.split(":")
+ if debug:
+ g4f.debug.logging = True
uvicorn.run(
- f"g4f.api:create_app{'_debug' if debug else ''}",
- host=host, port=int(port),
- workers=workers,
- use_colors=use_colors,
- factory=True,
+ "g4f.api:create_app",
+ host=host,
+ port=int(port),
+ workers=workers,
+ use_colors=use_colors,
+ factory=True,
reload=debug
)