Commit changes in app.py

app.py

@@ -1,236 +1,177 @@
-import ssl
-import certifi
-from functools import partial
+import os
+import json
+from g4f.providers.response import Reasoning, JsonConversation, FinishReason
+from g4f.typing import AsyncResult, Messages
+import json
+import re
+import time
+from urllib.parse import quote_plus
+from fastapi import FastAPI, Response, Request
+from fastapi.responses import RedirectResponse
 
-ssl.default_ca_certs = certifi.where()
-ssl.create_default_context = partial(
-    ssl.create_default_context,
-    cafile=certifi.where()
-)
+from g4f.image import images_dir, copy_images
 
 import g4f.api
 import g4f.Provider
 
-import json
-import time
-import requests
-
-from g4f.Provider.helper import filter_none
-from g4f.Provider.base_provider import AsyncGeneratorProvider, ProviderModelMixin, RaiseErrorMixin
-from g4f.typing import Union, Optional, AsyncResult, Messages, ImagesType
-from g4f.requests import StreamSession, raise_for_status
-from g4f.providers.response import FinishReason, ToolCalls, Usage, Reasoning, ImageResponse
-from g4f.errors import MissingAuthError, ResponseError
-from g4f.image import to_data_uri
+from g4f.Provider.base_provider import AsyncGeneratorProvider, ProviderModelMixin
+from g4f.typing import AsyncResult, Messages
+from g4f.requests import StreamSession
+from g4f.providers.response import ProviderInfo, JsonConversation, PreviewResponse, SynthesizeData, TitleGeneration, RequestLogin
+from g4f.providers.response import Parameters, FinishReason, Usage, Reasoning
+from g4f.errors import ModelNotSupportedError
 from g4f import debug
 
-class OpenaiTemplate(AsyncGeneratorProvider, ProviderModelMixin, RaiseErrorMixin):
-    api_base = ""
-    supports_message_history = True
-    supports_system_message = True
-    default_model = ""
-    fallback_models = []
-    sort_models = True
-    verify = None
-
-    @classmethod
-    def get_models(cls, api_key: str = None, api_base: str = None) -> list[str]:
-        if not cls.models:
-            try:
-                headers = {}
-                if api_base is None:
-                    api_base = cls.api_base
-                if api_key is not None:
-                    headers["authorization"] = f"Bearer {api_key}"
-                response = requests.get(f"{api_base}/models", headers=headers, verify=cls.verify)
-                raise_for_status(response)
-                data = response.json()
-                data = data.get("data") if isinstance(data, dict) else data
-                cls.image_models = [model.get("id") for model in data if model.get("image")]
-                cls.models = [model.get("id") for model in data]
-                if cls.sort_models:
-                    cls.models.sort()
-            except Exception as e:
-                debug.log(e)
-                return cls.fallback_models
-        return cls.models
-
-    @classmethod
-    async def create_async_generator(
-        cls,
-        model: str,
-        messages: Messages,
-        proxy: str = None,
-        timeout: int = 120,
-        images: ImagesType = None,
-        api_key: str = None,
-        api_endpoint: str = None,
-        api_base: str = None,
-        temperature: float = None,
-        max_tokens: int = None,
-        top_p: float = None,
-        stop: Union[str, list[str]] = None,
-        stream: bool = False,
-        prompt: str = None,
-        headers: dict = None,
-        impersonate: str = None,
-        tools: Optional[list] = None,
-        extra_data: dict = {},
-        **kwargs
-    ) -> AsyncResult:
-        if cls.needs_auth and api_key is None:
-            raise MissingAuthError('Add a "api_key"')
-        async with StreamSession(
-            proxy=proxy,
-            headers=cls.get_headers(stream, api_key, headers),
-            timeout=timeout,
-            impersonate=impersonate,
-        ) as session:
-            model = cls.get_model(model, api_key=api_key, api_base=api_base)
-            if api_base is None:
-                api_base = cls.api_base
-
-            # Proxy for image generation feature
-            if prompt and model and model in cls.image_models:
-                data = {
-                    "prompt": messages[-1]["content"] if prompt is None else prompt,
-                    "model": model,
-                }
-                async with session.post(f"{api_base.rstrip('/')}/images/generations", json=data, ssl=cls.verify) as response:
-                    data = await response.json()
-                    cls.raise_error(data)
-                    await raise_for_status(response)
-                    yield ImageResponse([image["url"] for image in data["data"]], prompt)
-                return
-
-            if images is not None and messages:
-                if not model and hasattr(cls, "default_vision_model"):
-                    model = cls.default_vision_model
-                last_message = messages[-1].copy()
-                last_message["content"] = [
-                    *[{
-                        "type": "image_url",
-                        "image_url": {"url": to_data_uri(image)}
-                    } for image, _ in images],
-                    {
-                        "type": "text",
-                        "text": messages[-1]["content"]
-                    }
-                ]
-                messages[-1] = last_message
-            data = filter_none(
-                messages=messages,
-                model=model,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                top_p=top_p,
-                stop=stop,
-                stream=stream,
-                tools=tools,
-                **extra_data
-            )
-            if api_endpoint is None:
-                api_endpoint = f"{api_base.rstrip('/')}/chat/completions"
-            async with session.post(api_endpoint, json=data, ssl=cls.verify) as response:
-                content_type = response.headers.get("content-type", "text/event-stream" if stream else "application/json")
-                if content_type.startswith("application/json"):
-                    data = await response.json()
-                    cls.raise_error(data)
-                    await raise_for_status(response)
-                    choice = data["choices"][0]
-                    if "content" in choice["message"] and choice["message"]["content"]:
-                        yield choice["message"]["content"].strip()
-                    elif "tool_calls" in choice["message"]:
-                        yield ToolCalls(choice["message"]["tool_calls"])
-                    if "usage" in data:
-                        yield Usage(**data["usage"])
-                    if "finish_reason" in choice and choice["finish_reason"] is not None:
-                        yield FinishReason(choice["finish_reason"])
-                        return
-                elif content_type.startswith("text/event-stream"):
-                    await raise_for_status(response)
-                    first = True
-                    is_thinking = 0
-                    async for line in response.iter_lines():
-                        if line.startswith(b"data: "):
-                            chunk = line[6:]
-                            if chunk == b"[DONE]":
-                                break
-                            data = json.loads(chunk)
-                            cls.raise_error(data)
-                            choice = data["choices"][0]
-                            if "content" in choice["delta"] and choice["delta"]["content"]:
-                                delta = choice["delta"]["content"]
-                                if first:
-                                    delta = delta.lstrip()
-                                if delta:
-                                    first = False
-                                    if is_thinking:
-                                        if "</think>" in delta:
-                                            yield Reasoning(None, f"Finished in {round(time.time()-is_thinking, 2)} seconds")
-                                            is_thinking = 0
-                                        else:
-                                            yield Reasoning(delta)
-                                    elif "<think>" in delta:
-                                        is_thinking = time.time()
-                                        yield Reasoning(None, "Is thinking...")
-                                    else:
-                                        yield delta
-                            if "usage" in data and data["usage"]:
-                                yield Usage(**data["usage"])
-                            if "finish_reason" in choice and choice["finish_reason"] is not None:
-                                yield FinishReason(choice["finish_reason"])
-                                break
-                else:
-                    await raise_for_status(response)
-                    raise ResponseError(f"Not supported content-type: {content_type}")
-
-    @classmethod
-    def get_headers(cls, stream: bool, api_key: str = None, headers: dict = None) -> dict:
-        return {
-            "Accept": "text/event-stream" if stream else "application/json",
-            "Content-Type": "application/json",
-            **(
-                {"Authorization": f"Bearer {api_key}"}
-                if api_key is not None else {}
-            ),
-            **({} if headers is None else headers)
-        }
-
-class Feature(OpenaiTemplate):
+class BackendApi(AsyncGeneratorProvider, ProviderModelMixin):
     url = "https://ahe.hopto.org"
     working = True
-    verify = False
+    ssl = False
 
     models = [
-        *list(set(g4f.Provider.OpenaiAccount.get_models())),
+        *g4f.Provider.OpenaiAccount.get_models(),
         *g4f.Provider.HuggingChat.get_models(),
-        "MiniMax"
+        "flux",
+        "flux-pro",
+        "MiniMax-01",
+        "Microsoft Copilot",
     ]
 
     @classmethod
-    def get_model(cls, model, **kwargs):
-        if model == "MiniMax":
-            cls.api_base = f"{cls.url}/api/HailuoAI"
+    def get_model(cls, model):
+        if "MiniMax" in model:
+            model = "MiniMax"
+        elif "Copilot" in model:
+            model = "Copilot"
+        elif "FLUX" in model:
+            model = f"flux-{model.split('-')[-1]}"
+        elif "flux" in model:
+            model = model.split(' ')[-1]
         elif model in g4f.Provider.OpenaiAccount.get_models():
-            cls.api_base = f"{cls.url}/api/OpenaiAccount"
+            pass
         elif model in g4f.Provider.HuggingChat.get_models():
-            cls.api_base = f"{cls.url}/api/HuggingChat"
+            pass
         else:
-            cls.api_base = f"{cls.url}/v1"
+            raise ModelNotSupportedError(f"Model: {model}")
         return model
 
+    @classmethod
+    def get_provider(cls, model):
+        if model.startswith("MiniMax"):
+            return "HailuoAI"
+        elif model == "Copilot":
+            return "CopilotAccount"
+        elif model in g4f.Provider.OpenaiAccount.get_models():
+            return "OpenaiAccount"
+        elif model in g4f.Provider.HuggingChat.get_models():
+            return "HuggingChat"
+        return None
+
     @classmethod
     async def create_async_generator(
         cls,
         model: str,
         messages: Messages,
         api_key: str = None,
+        proxy: str = None,
+        timeout: int = 0,
         **kwargs
     ) -> AsyncResult:
-        async for chunk in super().create_async_generator(model, messages, **kwargs):
-            yield chunk
-
-g4f.Provider.__map__["Feature"] = Feature
+        debug.log(f"{__name__}: {api_key}")
 
-app = g4f.api.create_app_with_demo_and_debug()
+        async with StreamSession(
+            proxy=proxy,
+            headers={"Accept": "text/event-stream"},
+            timeout=timeout
+        ) as session:
+            model = cls.get_model(model)
+            provider = cls.get_provider(model)
+            async with session.post(f"{cls.url}/backend-api/v2/conversation", json={
+                "model": model,
+                "messages": messages,
+                "provider": provider,
+                **kwargs
+            }, ssl=cls.ssl) as response:
+                async for line in response.iter_lines():
+                    data = json.loads(line)
+                    data_type = data.pop("type")
+                    if data_type == "provider":
+                        yield ProviderInfo(**data[data_type])
+                        provider = data[data_type]["name"]
+                    elif data_type == "conversation":
+                        yield JsonConversation(**data[data_type][provider] if provider in data[data_type] else data[data_type][""])
+                    elif data_type == "conversation_id":
+                        pass
+                    elif data_type == "message":
+                        yield Exception(data)
+                    elif data_type == "preview":
+                        yield PreviewResponse(data[data_type])
+                    elif data_type == "content":
+                        def on_image(match):
+                            extension = match.group(3).split(".")[-1].split("?")[0]
+                            extension = "" if not extension or len(extension) > 4 else f".{extension}"
+                            filename = f"{int(time.time())}_{quote_plus(match.group(1)[:100], '')}{extension}"
+                            download_url = f"/download/{filename}?url={cls.url}{match.group(3)}"
+                            return f"[![{match.group(1)}]({download_url})](/images/{filename})"
+                        yield re.sub(r'\[\!\[(.+?)\]\(([^)]+?)\)\]\(([^)]+?)\)', on_image, data["content"])
+                    elif data_type =="synthesize":
+                        yield SynthesizeData(**data[data_type])
+                    elif data_type == "parameters":
+                        yield Parameters(**data[data_type])
+                    elif data_type == "usage":
+                        yield Usage(**data[data_type])
+                    elif data_type == "reasoning":
+                        yield Reasoning(**data)
+                    elif data_type == "login":
+                        pass
+                    elif data_type == "title":
+                        yield TitleGeneration(data[data_type])
+                    elif data_type == "finish":
+                        yield FinishReason(data[data_type]["reason"])
+                    elif data_type == "log":
+                        debug.log(data[data_type])
+                    else:
+                        debug.log(f"Unknown data: ({data_type}) {data}")
+
+g4f.Provider.__map__["Feature"] = BackendApi
+
+def create_app():
+    g4f.debug.logging = True
+    g4f.api.AppConfig.gui = True
+    g4f.api.AppConfig.demo = True
+
+    app = FastAPI()
+
+    # Add CORS middleware
+    app.add_middleware(
+        g4f.api.CORSMiddleware,
+        allow_origin_regex=".*",
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    api = g4f.api.Api(app)
+
+    api.register_routes()
+    api.register_authorization()
+    api.register_validation_exception_handler()
+
+    @app.get("/download/{filename}", response_class=RedirectResponse)
+    async def download(filename, request: Request):
+        filename = os.path.basename(filename)
+        target = os.path.join(images_dir, filename)
+        if not os.path.exists(target):
+            url = str(request.query_params).split("url=", 1)[1]
+            if url:
+                source_url = url.replace("%2F", "/").replace("%3A", ":").replace("%3F", "?").replace("%3D", "=")
+                await copy_images([source_url], target=target, ssl=False)
+            if not os.path.exists(target):
+                return Response(status_code=404)
+        return RedirectResponse(f"/images/{filename}")
+
+    gui_app = g4f.api.WSGIMiddleware(g4f.api.get_gui_app(g4f.api.AppConfig.demo))
+    app.mount("/", gui_app)
+
+    return app
+
+app = create_app()

start

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+uvicorn app:app --port 8000 --reload