gpt4free

公开

关注 0 Fork 0 Star 0

返回提交历史

XFEstudio/gpt4free

Refactor model handling in PollinationsAI and related providers; update API endpoints, enhance model loading logic, and improve error handling in get_models method

0366acbc

hlohaus <983577+hlohaus@users.noreply.github.com>

提交于 2025-12-09 18:08

父提交 aa0aade

代码差异

6 个文件 +104 -46

Modified g4f/Provider/PollinationsAI.py +95 -41

@@ -4,9 +4,12 @@ import time

4 4 import random

5 5 import requests

6 6 import asyncio

7 import json

7 8 from urllib.parse import quote, quote_plus

9 from datetime import datetime

8 10 from typing import Optional

9 11 from aiohttp import ClientSession, ClientTimeout

12 from pathlib import Path

10 13

11 14 from .helper import filter_none, format_media_prompt

12 15 from .base_provider import AsyncGeneratorProvider, ProviderModelMixin

@@ -16,9 +19,11 @@ from ..errors import MissingAuthError

16 19 from ..requests.raise_for_status import raise_for_status

17 20 from ..requests.aiohttp import get_connector

18 21 from ..image import use_aspect_ratio

19 from ..providers.response import ImageResponse, Reasoning, TitleGeneration, SuggestedFollowups, JsonRequest

22 from ..providers.response import ImageResponse, Reasoning, VideoResponse, JsonRequest

20 23 from ..tools.media import render_messages

21 24 from ..config import REFFERER_URL

25 from ..tools.run_tools import AuthManager

26 from ..cookies import get_cookies_dir

22 27 from .template.OpenaiTemplate import read_response

23 28 from .. import debug

24 29

@@ -40,9 +45,16 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

40 45 supports_message_history = True

41 46

42 47 # API endpoints

43 text_api_endpoint = "https://text.pollinations.ai"

44 openai_endpoint = "https://text.pollinations.ai/openai"

45 image_api_endpoint = "https://image.pollinations.ai/"

48 text_api_endpoint = "https://text.pollinations.ai/openai"

49 image_api_endpoint = "https://image.pollinations.ai/prompt/{}"

50 gen_image_api_endpoint = "https://gen.pollinations.ai/image/{}"

51 gen_text_api_endpoint = "https://gen.pollinations.ai/v1/chat/completions"

52 image_models_endpoint = "https://image.pollinations.ai/models"

53 text_models_endpoint = "https://text.pollinations.ai/models"

54 gen_image_models_endpoint = "https://gen.pollinations.ai/image/models"

55 gen_text_models_endpoint = "https://gen.pollinations.ai/text/models"

56 g4f_text_models_endpoint = "https://g4f.dev/api/pollinations/models"

57 nectar_text_models_endpoint = "https://g4f.dev/api/nectar/models"

46 58

47 59 # Models configuration

48 60 default_model = "openai"

@@ -51,11 +63,12 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

51 63 default_vision_model = default_model

52 64 default_audio_model = "openai-audio"

53 65 default_voice = "alloy"

54 text_models = [default_model, "evil"]

66 text_models = [default_model]

55 67 image_models = [default_image_model, "turbo", "kontext"]

56 68 audio_models = {default_audio_model: []}

57 69 vision_models = [default_vision_model]

58 _models_loaded = False

70 _gen_models_loaded = False

71 _free_models_loaded = False

59 72 model_aliases = {

60 73 "gpt-4.1-nano": "openai-fast",

61 74 "llama-4-scout": "llamascout",

@@ -71,19 +84,34 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

71 84 swap_model_aliases = {v: k for k, v in model_aliases.items()}

72 85

73 86 @classmethod

74 def get_models(cls, **kwargs):

87 def get_models(cls, api_key: Optional[str] = None, timeout: Optional[float] = None, **kwargs):

75 88 def get_alias(model: dict) -> str:

76 89 alias = model.get("name")

77 90 if (model.get("aliases")):

78 91 alias = model.get("aliases")[0]

79 92 elif alias in cls.swap_model_aliases:

80 93 alias = cls.swap_model_aliases[alias]

94 if alias == "searchgpt":

95 return model.get("name")

81 96 return str(alias).replace("-instruct", "").replace("qwen-", "qwen").replace("qwen", "qwen-")

98 if not api_key:

99 api_key = AuthManager.load_api_key(cls)

82 100

83 if not cls._models_loaded:

101 if not cls._free_models_loaded or api_key and not cls._gen_models_loaded:

102

            path = Path(get_cookies_dir()) / "models" / datetime.today().strftime('%Y-%m-%d') / f"{cls.__name__}{'-auth' if api_key else ''}.json"

103 if path.exists():

104 try:

105 data = path.read_text()

106 models_data = json.loads(data)

107 for key, value in models_data.items():

108 setattr(cls, key, value)

109 return cls.models

110 except Exception as e:

111 debug.error(f"Failed to load cached models from {path}: {e}")

84 112 try:

85 113 # Update of image models

86 image_response = requests.get("https://image.pollinations.ai/models")

114

                image_response = requests.get(cls.gen_image_models_endpoint if api_key else cls.image_models_endpoint, timeout=timeout)

87 115 if image_response.ok:

88 116 new_image_models = image_response.json()

89 117 else:

@@ -94,14 +122,19 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

94 122

95 123 # Add extra image models if not already in the list

96 124 for model in new_image_models:

125 alias = get_alias(model) if isinstance(model, dict) else model

97 126 if model not in image_models:

98 image_models.append(model)

127 if isinstance(model, str) or "image" in model.get("output_modalities", []):

128 image_models.append(alias)

129 if isinstance(model, dict) and alias != model.get("name"):

130 cls.model_aliases[alias] = model.get("name") if isinstance(model, dict) else model

99 131

100 132 cls.image_models = image_models

133

                cls.video_models = [get_alias(model) for model in new_image_models if "video" in model.get("output_modalities", [])]

101 134

102 text_response = requests.get("https://g4f.dev/api/pollinations.ai/models")

135

                text_response = requests.get(cls.nectar_text_models_endpoint if api_key else cls.g4f_text_models_endpoint, timeout=timeout)

103 136 if not text_response.ok:

104 text_response = requests.get("https://text.pollinations.ai/models")

137

                    text_response = requests.get(cls.gen_text_models_endpoint if api_key else cls.text_models_endpoint, timeout=timeout)

105 138 text_response.raise_for_status()

106 139 models = text_response.json()

107 140

@@ -130,6 +163,7 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

130 163 elif model.get("name") not in cls.text_models:

131 164 cls.text_models.append(model.get("name"))

132 165 cls.live += 1

166 cls.swap_model_aliases = {v: k for k, v in cls.model_aliases.items()}

133 167

134 168 except Exception as e:

135 169 # Save default models in case of an error

@@ -140,22 +174,41 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

140 174 debug.error(f"Failed to fetch models: {e}")

141 175

142 176 finally:

143 cls._models_loaded = True

144

145 # Return unique models across all categories

146 all_models = cls.text_models.copy()

147 all_models.extend(cls.image_models)

148 all_models.extend(cls.audio_models.keys())

149 if cls.default_audio_model in cls.audio_models:

150 all_models.extend(cls.audio_models[cls.default_audio_model])

151 return list(dict.fromkeys(all_models))

177 if api_key:

178 cls._gen_models_loaded = True

179 else:

180 cls._free_models_loaded = True

181 # Return unique models across all categories

182 all_models = cls.text_models.copy()

183 all_models.extend(cls.image_models)

184 all_models.extend(cls.audio_models.keys())

185 if cls.default_audio_model in cls.audio_models:

186 all_models.extend(cls.audio_models[cls.default_audio_model])

187 cls.models = all_models

188 # Cache the models to a file

189 try:

190 path.parent.mkdir(parents=True, exist_ok=True)

191 with open(path, "w") as f:

192 json.dump({

193 "text_models": cls.text_models,

194 "image_models": cls.image_models,

195 "video_models": cls.video_models,

196 "audio_models": cls.audio_models,

197 "vision_models": cls.vision_models,

198 "model_aliases": cls.model_aliases,

199 "models": cls.models

200 }, f, indent=4)

201 except Exception as e:

202 debug.error(f"Failed to cache models to {path}: {e}")

203 return cls.models

152 204

153 205 @classmethod

154 def get_grouped_models(cls) -> dict[str, list[str]]:

155 cls.get_models()

206 def get_grouped_models(cls, **kwargs) -> dict[str, list[str]]:

207 cls.get_models(**kwargs)

156 208 return [

157 209 {"group": "Text Generation", "models": cls.text_models},

158 210 {"group": "Image Generation", "models": cls.image_models},

211 {"group": "Video Generation", "models": cls.video_models},

159 212 {"group": "Audio Generation", "models": list(cls.audio_models.keys())},

160 213 {"group": "Audio Voices", "models": cls.audio_models.get(cls.default_audio_model, [])},

161 214 ]

@@ -206,13 +259,15 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

206 259 has_audio = True

207 260 break

208 261 model = cls.default_audio_model if has_audio else cls.default_model

209 elif cls._models_loaded or cls.get_models():

262

        elif (cls._gen_models_loaded if api_key else cls._free_models_loaded) or cls.get_models(api_key=api_key, timeout=kwargs.get("timeout")):

210 263 if model in cls.model_aliases:

211 264 model = cls.model_aliases[model]

212 265 debug.log(f"Using model: {model}")

213 if model in cls.image_models:

266 alias = cls.swap_model_aliases.get(model, model)

267 if alias in cls.image_models or alias in cls.video_models:

214 268 async for chunk in cls._generate_image(

215 269 model="gptimage" if model == "transparent" else model,

270 alias=alias,

216 271 prompt=format_media_prompt(messages, prompt),

217 272 media=media,

218 273 proxy=proxy,

@@ -267,6 +322,7 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

267 322 async def _generate_image(

268 323 cls,

269 324 model: str,

325 alias: str,

270 326 prompt: str,

271 327 media: MediaListType,

272 328 proxy: str,

@@ -311,11 +367,9 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

311 367 if model == "gptimage" and aspect_ratio is not None:

312 368 encoded_prompt = f"{encoded_prompt} aspect-ratio: {aspect_ratio}"

313 369 encoded_prompt = quote_plus(encoded_prompt)[:4096 - len(cls.image_api_endpoint) - len(query) - 8].rstrip("%")

314 url = f"{cls.image_api_endpoint}prompt/{encoded_prompt}?{query}"

370 url = (cls.gen_image_api_endpoint if api_key else cls.image_api_endpoint).format(f"{encoded_prompt}?{query}")

315 371

316 372 def get_url_with_seed(i: int, seed: Optional[int] = None):

317 if model == "gptimage":

318 return url

319 373 if i == 0:

320 374 if not cache and seed is None:

321 375 seed = random.randint(0, 2 ** 32)

@@ -323,16 +377,16 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

323 377 seed = random.randint(0, 2 ** 32)

324 378 return f"{url}&seed={seed}" if seed else url

325 379

326 headers = {"referer": referrer}

380 headers = None

327 381 if api_key:

328 headers["authorization"] = f"Bearer {api_key}"

382 headers = {"authorization": f"Bearer {api_key}"}

329 383 async with ClientSession(

330 headers=DEFAULT_HEADERS,

331 connector=get_connector(proxy=proxy),

332 timeout=ClientTimeout(timeout)

384 headers=DEFAULT_HEADERS,

385 connector=get_connector(proxy=proxy),

386 timeout=ClientTimeout(timeout)

333 387 ) as session:

334 388 responses = set()

335 yield Reasoning(label=f"Generating {n} {'image' if n == 1 else 'images'}")

389

            yield Reasoning(label=f"Generating {n} {('video' if alias in cls.video_models else 'image') + '' if n == 1 else 's'}")

336 390 finished = 0

337 391 start = time.time()

338 392

@@ -344,12 +398,12 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

344 398 except Exception as e:

345 399 responses.add(e)

346 400 debug.error(f"Error fetching image:", e)

347 if response.headers['content-type'].startswith("image/"):

401 if response.headers.get('content-type', '').startswith("image/"):

348 402 responses.add(ImageResponse(str(response.url), prompt, {"headers": headers}))

403 elif response.headers.get('content-type', '').startswith("video/"):

404 responses.add(VideoResponse(str(response.url), prompt, {"headers": headers}))

349 405 else:

350 t_ = await response.text()

351 debug.error(f"UnHandel Error fetching image:", t_)

352 responses.add(t_)

406 responses.add(Exception(f"Unexpected content type: {response.headers.get('content-type')}"))

353 407

354 408 tasks: list[asyncio.Task] = []

355 409 for i in range(int(n)):

@@ -426,11 +480,11 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):

426 480 referrer=referrer,

427 481 **extra_body

428 482 )

429 headers = {"referer": referrer}

483 headers = None

430 484 if api_key:

431 headers["authorization"] = f"Bearer {api_key}"

485 headers = {"authorization": f"Bearer {api_key}"}

432 486 yield JsonRequest.from_dict(data)

433 async with session.post(cls.openai_endpoint, json=data, headers=headers) as response:

487

            async with session.post(cls.gen_text_api_endpoint if api_key else cls.text_api_endpoint, json=data, headers=headers) as response:

434 488 if response.status in (400, 500):

435 489 debug.error(f"Error: {response.status} - Bad Request: {data}")

436 490 async for chunk in read_response(response, stream, format_media_prompt(messages), cls.get_dict(),

Modified g4f/Provider/PollinationsImage.py +4 -0

@@ -55,8 +55,12 @@ class PollinationsImage(PollinationsAI):

55 55 ) -> AsyncResult:

56 56 # Calling model updates before creating a generator

57 57 cls.get_models()

58 alias = cls.swap_model_aliases.get(model, model)

59 if model in cls.model_aliases:

60 model = cls.model_aliases[model]

58 61 async for chunk in cls._generate_image(

59 62 model=model,

63 alias=alias,

60 64 prompt=format_media_prompt(messages, prompt),

61 65 media=media,

62 66 proxy=proxy,

Modified g4f/Provider/needs_auth/Azure.py +1 -1

@@ -18,7 +18,7 @@ class Azure(OpenaiTemplate):

18 18 working = True

19 19 needs_auth = True

20 20 models_needs_auth = True

21 active_by_default = True

21 active_by_default = False

22 22 login_url = "https://discord.gg/qXA4Wf4Fsm"

23 23 routes: dict[str, str] = {}

24 24 audio_models = ["gpt-4o-mini-audio-preview"]

Modified g4f/Provider/needs_auth/hf/HuggingChat.py +1 -1

@@ -47,7 +47,7 @@ class HuggingChat(AsyncAuthedProvider, ProviderModelMixin):

47 47 text_models = fallback_models

48 48

49 49 @classmethod

50 def get_models(cls):

50 def get_models(cls, **kwargs) -> list[str]:

51 51 if not cls.models:

52 52 try:

53 53 models = requests.get(f"{cls.url}/api/v2/models").json().get("json")

Modified g4f/gui/server/api.py +2 -2

@@ -115,7 +115,7 @@ class Api:

115 115 def get_all_models(self) -> dict[str, list]:

116 116 def safe_get_provider_models(provider: ProviderModelMixin) -> list[str]:

117 117 try:

118 return list(provider.get_models())

118 return list(provider.get_models(timeout=10))

119 119 except Exception as e:

120 120 debug.error(f"{provider.__name__}: get_models error:", e)

121 121 return []

@@ -223,7 +223,7 @@ class Api:

223 223 yield self._format_json("preview", chunk.to_string(), urls=chunk.urls, alt=chunk.alt)

224 224 elif isinstance(chunk, MediaResponse):

225 225 media = chunk

226 if download_media or chunk.get("cookies"):

226 if download_media or chunk.get("cookies") or chunk.get("headers"):

227 227 chunk.alt = format_media_prompt(kwargs.get("messages"), chunk.alt)

228 228 width, height = get_width_height(chunk.get("width"), chunk.get("height"))

229 229 tags = [model, kwargs.get("aspect_ratio"), kwargs.get("resolution")]

Modified g4f/providers/any_provider.py +1 -1

@@ -76,7 +76,7 @@ class AnyModelProviderMixin(ProviderModelMixin):

76 76 return ignored

77 77

78 78 @classmethod

79 def get_models(cls, ignored: list[str] = []) -> list[str]:

79 def get_models(cls, ignored: list[str] = [], **kwargs) -> list[str]:

80 80 if not cls.models:

81 81 cls.update_model_map()

82 82 if not ignored: