g4f 6.9.6__tar.gz → 6.9.8__tar.gz

{g4f-6.9.6/g4f.egg-info → g4f-6.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: g4f
-Version: 6.9.6
+Version: 6.9.8
 Summary: The official gpt4free repository | various collection of powerful language models
 Home-page: https://github.com/xtekky/gpt4free
 Author: Tekky

{g4f-6.9.6 → g4f-6.9.8}/g4f/Provider/PollinationsAI.py

@@ -24,6 +24,7 @@ from ..providers.response import ImageResponse, Reasoning, VideoResponse, JsonRe
 from ..tools.media import render_messages
 from ..tools.run_tools import AuthManager
 from ..cookies import get_cookies_dir
+from ..tools.files import secure_filename
 from .template.OpenaiTemplate import read_response
 from .. import debug
 
@@ -31,7 +32,6 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
     label = "Pollinations AI 🌸"
     url = "https://pollinations.ai"
     login_url = "https://enter.pollinations.ai"
-    api_key = "pk", "_B9YJX5SBohhm2ePq"
     active_by_default = True
     working = True
     supports_system_message = True
@@ -44,7 +44,9 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
     gen_text_api_endpoint = "https://gen.pollinations.ai/v1/chat/completions"
     image_models_endpoint = "https://gen.pollinations.ai/image/models"
     text_models_endpoint = "https://gen.pollinations.ai/text/models"
-    BALANCE_ENDPOINT = "https://gen.pollinations.ai/account/balance"
+    balance_endpoint = "https://api.gpt4free.workers.dev/api/pollinations/account/balance"
+    worker_api_endpoint = "https://api.gpt4free.workers.dev/api/pollinations/chat/completions"
+    worker_models_endpoint = "https://api.gpt4free.workers.dev/api/pollinations/text/models"
 
     # Models configuration
     default_model = "openai"
@@ -56,8 +58,6 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
     image_models = [default_image_model, "turbo", "kontext"]
     audio_models = {}
     vision_models = [default_vision_model]
-    _gen_models_loaded = False
-    _free_models_loaded = False
     model_aliases = {
         "gpt-4.1-nano": "openai-fast",
         "llama-4-scout": "llamascout",
@@ -74,12 +74,15 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
     }
     swap_model_aliases = {v: k for k, v in model_aliases.items()}
     balance: Optional[float] = None
+    current_models_endpoint: Optional[str] = None
 
     @classmethod
     def get_balance(cls, api_key: str, timeout: Optional[float] = None) -> Optional[float]:
         try:
-            headers = {"authorization": f"Bearer {api_key}"}
-            response = requests.get(cls.BALANCE_ENDPOINT, headers=headers, timeout=timeout)
+            headers = None
+            if api_key:
+                headers = {"authorization": f"Bearer {api_key}"}
+            response = requests.get(cls.balance_endpoint, headers=headers, timeout=timeout)
             response.raise_for_status()
             data = response.json()
             cls.balance = float(data.get("balance", 0.0))
@@ -103,17 +106,18 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
         
         if not api_key:
             api_key = AuthManager.load_api_key(cls)
-        if not api_key or api_key.startswith("g4f_") or api_key.startswith("gfs_"):
-            api_key = "".join(cls.api_key)
-        
-        if cls.balance or cls.balance is None and cls.get_balance(api_key, timeout) and cls.balance > 0:
-            debug.log(f"Authenticated with Pollinations AI using API key.")
+        if (not api_key or api_key.startswith("g4f_") or api_key.startswith("gfs_")) and cls.balance or cls.balance is None and cls.get_balance(api_key, timeout) and cls.balance > 0:
+            debug.log(f"Authenticated with Pollinations AI using G4F API.")
+            models_url = cls.worker_models_endpoint
+        elif api_key:
+            debug.log(f"Using Pollinations AI with provided API key.")
+            models_url = cls.gen_text_api_endpoint
         else:
             debug.log(f"Using Pollinations AI without authentication.")
-            api_key = None
+            models_url = cls.text_models_endpoint
 
-        if not cls._free_models_loaded or api_key and not cls._gen_models_loaded:
-            path = Path(get_cookies_dir()) / "models" / datetime.today().strftime('%Y-%m-%d') / f"{cls.__name__}{'-auth' if api_key else ''}.json"
+        if cls.current_models_endpoint != models_url:
+            path = Path(get_cookies_dir()) / "models" / datetime.today().strftime('%Y-%m-%d') / f"{secure_filename(models_url)}.json"
             if path.exists():
                 try:
                     data = path.read_text()
@@ -180,10 +184,7 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
                 cls.swap_model_aliases = {v: k for k, v in cls.model_aliases.items()}
 
             finally:
-                if api_key:
-                    cls._gen_models_loaded = True
-                else:
-                    cls._free_models_loaded = True
+                cls.current_models_endpoint = models_url
             # Return unique models across all categories
             all_models = cls.text_models.copy()
             all_models.extend(cls.image_models)
@@ -251,7 +252,7 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
         **kwargs
     ) -> AsyncResult:
         if cache is None:
-            cache = kwargs.get("action") != "variant"
+            cache = kwargs.get("action") is None or kwargs.get("action") != "variant"
         if extra_body is None:
             extra_body = {}
         if not model:
@@ -262,7 +263,7 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
                         has_audio = True
                         break
             model = "openai-audio" if has_audio else cls.default_model
-        if cls.get_models(api_key=api_key, timeout=kwargs.get("timeout")):
+        if cls.get_models(api_key=api_key, timeout=kwargs.get("timeout", 15)):
             if model in cls.model_aliases:
                 model = cls.model_aliases[model]
         debug.log(f"Using model: {model}")
@@ -480,17 +481,17 @@ class PollinationsAI(AsyncGeneratorProvider, ProviderModelMixin):
                 seed=None if "tools" in extra_body else seed,
                 **extra_body
             )
+            if (not api_key or api_key.startswith("g4f_") or api_key.startswith("gfs_")) and cls.balance and cls.balance > 0:
+                endpoint = cls.worker_api_endpoint
+            elif api_key:
+                endpoint = cls.gen_text_api_endpoint
+            else:
+                endpoint = cls.text_api_endpoint
             headers = None
-            if api_key and not api_key.startswith("g4f_") and not api_key.startswith("gfs_"):
+            if api_key:
                 headers = {"authorization": f"Bearer {api_key}"}
-            elif cls.balance > 0:
-                headers = {"authorization": f"Bearer {''.join(cls.api_key)}"}
             yield JsonRequest.from_dict(data)
-            if headers:
-                url = cls.gen_text_api_endpoint
-            else:
-                url = cls.text_api_endpoint
-            async with session.post(url, json=data, headers=headers) as response:
+            async with session.post(endpoint, json=data, headers=headers) as response:
                 if response.status in (400, 500):
                     debug.error(f"Error: {response.status} - Bad Request: {data}")
                 async for chunk in read_response(response, stream, format_media_prompt(messages), cls.get_dict(),

{g4f-6.9.6 → g4f-6.9.8}/g4f/Provider/Yupp.py

@@ -11,7 +11,7 @@ try:
     import cloudscraper
     from cloudscraper import CloudScraper
 except ImportError:
-    CloudScraper = None
+    from typing import Type as CloudScraper
 
 from .helper import get_last_user_message
 from .yupp.models import YuppModelManager
@@ -47,7 +47,6 @@ def create_scraper():
     scraper.headers.update({
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36 Edg/137.0.0.0",
         "Accept": "text/x-component, */*",
-        "Accept-Encoding": "gzip, deflate, br, zstd",
         "Accept-Language": "en-US,en;q=0.9",
         "Sec-Fetch-Dest": "empty",
         "Sec-Fetch-Mode": "cors",

{g4f-6.9.6 → g4f-6.9.8}/g4f/Provider/needs_auth/LMArena.py

@@ -116,7 +116,7 @@ class LMArena(AsyncGeneratorProvider, ProviderModelMixin, AuthFileMixin):
         "getProxyImage": "60049198d4936e6b7acc63719b63b89284c58683e6"
     }
     @classmethod
-    def get_models(cls, timeout: int = None) -> list[str]:
+    def get_models(cls, timeout: int = None, **kwargs) -> list[str]:
         if not cls._models_loaded and has_curl_cffi:
             cache_file = cls.get_cache_file()
             args = {}

{g4f-6.9.6 → g4f-6.9.8}/g4f/client/__init__.py

@@ -15,7 +15,7 @@ from typing import Union, AsyncIterator, Iterator, Awaitable, Optional, List, Di
 
 from ..image.copy_images import copy_media, get_media_dir
 from ..typing import Messages, ImageType
-from ..providers.types import ProviderType, BaseRetryProvider, BaseProvider
+from ..providers.types import ProviderType, BaseProvider
 from ..providers.response import *
 from ..errors import NoMediaResponseError, ProviderNotFoundError
 from ..providers.retry_provider import IterListProvider
@@ -70,14 +70,15 @@ def iter_response(
     stream: bool,
     response_format: Optional[dict] = None,
     max_tokens: Optional[int] = None,
-    stop: Optional[list[str]] = None
+    stop: Optional[list[str]] = None,
+    provider_info: Optional[ProviderInfo] = None
 ) -> ChatCompletionResponseType:
     content = ""
     reasoning = []
     finish_reason = None
     tool_calls = None
     usage = None
-    provider: ProviderInfo = None
+    provider_info: ProviderInfo = None
     conversation: JsonConversation = None
     completion_id = ''.join(random.choices(string.ascii_letters + string.digits, k=28))
     idx = 0
@@ -100,7 +101,7 @@ def iter_response(
             usage = chunk
             continue
         elif isinstance(chunk, ProviderInfo):
-            provider = chunk
+            provider_info = chunk
             continue
         elif isinstance(chunk, Reasoning):
             reasoning.append(chunk)
@@ -122,9 +123,9 @@ def iter_response(
 
         if stream:
             chunk = ChatCompletionChunk.model_construct(chunk, None, completion_id, int(time.time()))
-            if provider is not None:
-                chunk.provider = provider.name
-                chunk.model = provider.model
+            if provider_info is not None:
+                chunk.provider = provider_info.name
+                chunk.model = provider_info.model
             yield chunk
 
         if finish_reason is not None:
@@ -153,29 +154,18 @@ def iter_response(
             conversation=None if conversation is None else conversation.get_dict(),
             reasoning=reasoning if reasoning else None
         )
-    if provider is not None:
-        chat_completion.provider = provider.name
-        chat_completion.model = provider.model
+    if provider_info is not None:
+        chat_completion.provider = provider_info.name
+        chat_completion.model = provider_info.model
     yield chat_completion
 
-# Synchronous iter_append_model_and_provider function
-def iter_append_model_and_provider(response: ChatCompletionResponseType, last_model: str, last_provider: ProviderType) -> ChatCompletionResponseType:
-    if isinstance(last_provider, BaseRetryProvider):
-        yield from response
-        return
-    for chunk in response:
-        if isinstance(chunk, (ChatCompletion, ChatCompletionChunk)):
-            if chunk.provider is None and last_provider is not None:
-                chunk.model = getattr(last_provider, "last_model", last_model)
-                chunk.provider = last_provider.__name__
-        yield chunk
-
 async def async_iter_response(
     response: AsyncIterator[Union[str, ResponseType]],
     stream: bool,
     response_format: Optional[dict] = None,
     max_tokens: Optional[int] = None,
-    stop: Optional[list[str]] = None
+    stop: Optional[list[str]] = None,
+    provider_info: Optional[ProviderInfo] = None
 ) -> AsyncChatCompletionResponseType:
     content = ""
     reasoning = []
@@ -184,7 +174,6 @@ async def async_iter_response(
     idx = 0
     tool_calls = None
     usage = None
-    provider: ProviderInfo = None
     conversation: JsonConversation = None
 
     try:
@@ -203,7 +192,7 @@ async def async_iter_response(
                 usage = chunk
                 continue
             elif isinstance(chunk, ProviderInfo):
-                provider = chunk
+                provider_info = chunk
                 continue
             elif isinstance(chunk, Reasoning) and not stream:
                 reasoning.append(chunk)
@@ -225,9 +214,9 @@ async def async_iter_response(
 
             if stream:
                 chunk = ChatCompletionChunk.model_construct(chunk, None, completion_id, int(time.time()))
-                if provider is not None:
-                    chunk.provider = provider.name
-                    chunk.model = provider.model
+                if provider_info is not None:
+                    chunk.provider = provider_info.name
+                    chunk.model = provider_info.model
                 yield chunk
 
             if finish_reason is not None:
@@ -256,32 +245,13 @@ async def async_iter_response(
                 conversation=conversation,
                 reasoning=reasoning if reasoning else None
             )
-        if provider is not None:
-            chat_completion.provider = provider.name
-            chat_completion.model = provider.model
+        if provider_info is not None:
+            chat_completion.provider = provider_info.name
+            chat_completion.model = provider_info.model
         yield chat_completion
     finally:
         await safe_aclose(response)
 
-async def async_iter_append_model_and_provider(
-        response: AsyncChatCompletionResponseType,
-        last_model: str,
-        last_provider: ProviderType
-    ) -> AsyncChatCompletionResponseType:
-    try:
-        if isinstance(last_provider, BaseRetryProvider):
-            async for chunk in response:
-                yield chunk
-            return
-        async for chunk in response:
-            if isinstance(chunk, (ChatCompletion, ChatCompletionChunk)):
-                if chunk.provider is None and last_provider is not None:
-                    chunk.model = getattr(last_provider, "last_model", last_model)
-                    chunk.provider = last_provider.__name__
-            yield chunk
-    finally:
-        await safe_aclose(response)
-
 class Client(BaseClient):
     def __init__(
         self,
@@ -350,9 +320,10 @@ class Completions:
             **kwargs
         )
 
+        provider_info = ProviderInfo(**provider.get_dict(), model=model)
+
         def fallback(response):
-            response = iter_response(response, stream, response_format, max_tokens, stop)
-            return iter_append_model_and_provider(response, model, provider)
+            return iter_response(response, stream, response_format, max_tokens, stop, provider_info)
 
         if raw:
             def raw_response(response):
@@ -689,8 +660,8 @@ class AsyncCompletions:
         )
 
         def fallback(response):
-            response = async_iter_response(response, stream, response_format, max_tokens, stop)
-            return async_iter_append_model_and_provider(response, model, provider)
+            provider_info = ProviderInfo(**provider.get_dict(), model=model)
+            return async_iter_response(response, stream, response_format, max_tokens, stop, provider_info)
 
         if raw:
             async def raw_response(response):
@@ -816,7 +787,7 @@ class ClientFactory:
         )
         
         # Create async client
-        async_client = ClientFactory.createAsyncClient("PollinationsAI")
+        async_client = ClientFactory.create_async_client("PollinationsAI")
     """
     
     # Registry of live/custom providers
@@ -850,7 +821,7 @@ class ClientFactory:
         elif provider.startswith("custom:"):
             if provider.startswith("custom:"):
                 serverId = provider[7:]
-                base_url = f"https://g4f.dev/custom/{serverId}"
+                base_url = f"https://api.gpt4free.workers.dev/custom/{serverId}"
             if not base_url:
                 raise ValueError("base_url is required for custom providers")
             provider = create_custom_provider(base_url, api_key, name=name, **kwargs)

{g4f-6.9.6 → g4f-6.9.8/g4f.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: g4f
-Version: 6.9.6
+Version: 6.9.8
 Summary: The official gpt4free repository | various collection of powerful language models
 Home-page: https://github.com/xtekky/gpt4free
 Author: Tekky