Merge pull request #2272 from kqlio67/main

Integrate New Providers and Enhance Existing Functionality

Author: xtekky

docs/async_client.md

@@ -1,3 +1,4 @@
+
 # How to Use the G4F AsyncClient API
 
 The AsyncClient API is the asynchronous counterpart to the standard G4F Client API. It offers the same functionality as the synchronous API, but with the added benefit of improved performance due to its asynchronous nature.
@@ -25,7 +26,7 @@ from g4f.Provider import BingCreateImages, OpenaiChat, Gemini
 client = AsyncClient(
     provider=OpenaiChat,
     image_provider=Gemini,
-    ...
+    # Add any other necessary parameters
 )
 ```
 
@@ -43,7 +44,7 @@ from g4f.client import AsyncClient
 client = AsyncClient(
     api_key="your_api_key_here",
     proxies="http://user:pass@host",
-    ...
+    # Add any other necessary parameters
 )
 ```
 
@@ -57,28 +58,44 @@ client = AsyncClient(
 You can use the `ChatCompletions` endpoint to generate text completions. Here’s how you can do it:
 
 ```python
-response = await client.chat.completions.create(
-    model="gpt-3.5-turbo",
-    messages=[{"role": "user", "content": "Say this is a test"}],
-    ...
-)
-print(response.choices[0].message.content)
+import asyncio
+
+from g4f.client import Client
+
+async def main():
+    client = Client()
+    response = await client.chat.completions.async_create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": "say this is a test"}],
+        # Add any other necessary parameters
+    )
+    print(response.choices[0].message.content)
+
+asyncio.run(main())
 ```
 
 ### Streaming Completions
 
 The `AsyncClient` also supports streaming completions. This allows you to process the response incrementally as it is generated:
 
 ```python
-stream = client.chat.completions.create(
-    model="gpt-4",
-    messages=[{"role": "user", "content": "Say this is a test"}],
-    stream=True,
-    ...
-)
-async for chunk in stream:
-    if chunk.choices[0].delta.content:
-        print(chunk.choices[0].delta.content or "", end="")
+import asyncio
+
+from g4f.client import Client
+
+async def main():
+    client = Client()
+    stream = await client.chat.completions.async_create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "say this is a test"}],
+        stream=True,
+        # Add any other necessary parameters
+    )
+    async for chunk in stream:
+        if chunk.choices[0].delta.content:
+            print(chunk.choices[0].delta.content or "", end="")
+
+asyncio.run(main())
 ```
 
 In this example:
@@ -89,48 +106,69 @@ In this example:
 The following code snippet demonstrates how to use a vision model to analyze an image and generate a description based on the content of the image. This example shows how to fetch an image, send it to the model, and then process the response.
 
 ```python
+import g4f
 import requests
+import asyncio
+
 from g4f.client import Client
-from g4f.Provider import Bing
 
-client = AsyncClient(
-    provider=Bing
-)
+image = requests.get("https://raw.githubusercontent.com/xtekky/gpt4free/refs/heads/main/docs/cat.jpeg", stream=True).raw
+# Or: image = open("docs/cat.jpeg", "rb")
 
-image = requests.get("https://my_website/image.jpg", stream=True).raw
-# Or: image = open("local_path/image.jpg", "rb")
 
-response = client.chat.completions.create(
-    "",
-    messages=[{"role": "user", "content": "what is in this picture?"}],
-    image=image
-)
-print(response.choices[0].message.content)
+async def main():
+    client = Client()
+    response = await client.chat.completions.async_create(
+        model=g4f.models.default,
+        provider=g4f.Provider.Bing,
+        messages=[{"role": "user", "content": "What are on this image?"}],
+        image=image
+        # Add any other necessary parameters
+    )
+    print(response.choices[0].message.content)
+
+asyncio.run(main())
 ```
 
 ### Image Generation:
 
 You can generate images using a specified prompt:
 
 ```python
-response = await client.images.generate(
-    model="dall-e-3",
-    prompt="a white siamese cat",
-    ...
-)
+import asyncio
+from g4f.client import Client
+
+async def main():
+    client = Client()
+    response = await client.images.async_generate(
+        prompt="a white siamese cat",
+        model="dall-e-3",
+        # Add any other necessary parameters
+    )
+    image_url = response.data[0].url
+    print(f"Generated image URL: {image_url}")
 
-image_url = response.data[0].url
+asyncio.run(main())
 ```
 
 #### Base64 as the response format
 
 ```python
-response = await client.images.generate(
-    prompt="a cool cat",
-    response_format="b64_json"
-)
+import asyncio
+from g4f.client import Client
 
-base64_text = response.data[0].b64_json
+async def main():
+    client = Client()
+    response = await client.images.async_generate(
+        prompt="a white siamese cat",
+        model="dall-e-3",
+        response_format="b64_json"
+        # Add any other necessary parameters
+    )
+    base64_text = response.data[0].b64_json
+    print(base64_text)
+
+asyncio.run(main())
 ```
 
 ### Example usage with asyncio.gather
@@ -140,27 +178,32 @@ Start two tasks at the same time:
 ```python
 import asyncio
 
-from g4f.client import AsyncClient
-from g4f.Provider import BingCreateImages, OpenaiChat, Gemini
+from g4f.client import Client
 
 async def main():
-    client = AsyncClient(
-        provider=OpenaiChat,
-        image_provider=Gemini,
-        # other parameters...
-    )
+    client = Client()
 
-    task1 = client.chat.completions.create(
+    task1 = client.chat.completions.async_create(
         model="gpt-3.5-turbo",
         messages=[{"role": "user", "content": "Say this is a test"}],
     )
     task2 = client.images.generate(
         model="dall-e-3",
         prompt="a white siamese cat",
     )
+
     responses = await asyncio.gather(task1, task2)
+    
+    chat_response, image_response = responses
 
-    print(responses)
+    print("Chat Response:")
+    print(chat_response.choices[0].message.content)
+
+    print("\nImage Response:")
+    image_url = image_response.data[0].url
+    print(image_url)
 
 asyncio.run(main())
-```
+```
+
+[Return to Home](/)

docs/client.md

@@ -1,3 +1,4 @@
+
 ### G4F - Client API
 
 #### Introduction
@@ -33,7 +34,7 @@ from g4f.Provider import BingCreateImages, OpenaiChat, Gemini
 client = Client(
     provider=OpenaiChat,
     image_provider=Gemini,
-    ...
+    # Add any other necessary parameters
 )
 ```
 
@@ -48,7 +49,7 @@ from g4f.client import Client
 client = Client(
     api_key="...",
     proxies="http://user:pass@host",
-    ...
+    # Add any other necessary parameters
 )
 ```
 
@@ -59,23 +60,30 @@ client = Client(
 You can use the `ChatCompletions` endpoint to generate text completions as follows:
 
 ```python
+from g4f.client import Client
+client = Client()
+
 response = client.chat.completions.create(
     model="gpt-3.5-turbo",
     messages=[{"role": "user", "content": "Say this is a test"}],
-    ...
+    # Add any other necessary parameters
 )
 print(response.choices[0].message.content)
 ```
 
 Also streaming are supported:
 
 ```python
+from g4f.client import Client
+
+client = Client()
+
 stream = client.chat.completions.create(
     model="gpt-4",
     messages=[{"role": "user", "content": "Say this is a test"}],
     stream=True,
-    ...
 )
+
 for chunk in stream:
     if chunk.choices[0].delta.content:
         print(chunk.choices[0].delta.content or "", end="")
@@ -86,27 +94,35 @@ for chunk in stream:
 Generate images using a specified prompt:
 
 ```python
+from g4f.client import Client
+
+client = Client()
 response = client.images.generate(
     model="dall-e-3",
     prompt="a white siamese cat",
-    ...
+    # Add any other necessary parameters
 )
 
 image_url = response.data[0].url
+print(f"Generated image URL: {image_url}")
 ```
 
 **Creating Image Variations:**
 
 Create variations of an existing image:
 
 ```python
+from g4f.client import Client
+
+client = Client()
 response = client.images.create_variation(
     image=open("cat.jpg", "rb"),
     model="bing",
-    ...
+    # Add any other necessary parameters
 )
 
 image_url = response.data[0].url
+print(f"Generated image URL: {image_url}")
 ```
 Original / Variant:
 
@@ -120,6 +136,7 @@ from g4f.Provider import RetryProvider, Phind, FreeChatgpt, Liaobots
 
 import g4f.debug
 g4f.debug.logging = True
+g4f.debug.version_check = False
 
 client = Client(
     provider=RetryProvider([Phind, FreeChatgpt, Liaobots], shuffle=False)
@@ -154,22 +171,45 @@ response = client.chat.completions.create(
 )
 print(response.choices[0].message.content)
 ```
+
 ```
 User: What are on this image?
 ```
-![Waterfall](/docs/waterfall.jpeg)
 
+![Waterfall](/docs/waterfall.jpeg)
 ```
 Bot: There is a waterfall in the middle of a jungle. There is a rainbow over...
 ```
 
+### Example: Using a Vision Model
+The following code snippet demonstrates how to use a vision model to analyze an image and generate a description based on the content of the image. This example shows how to fetch an image, send it to the model, and then process the response.
+
+```python
+import g4f
+import requests
+from g4f.client import Client
+
+image = requests.get("https://raw.githubusercontent.com/xtekky/gpt4free/refs/heads/main/docs/cat.jpeg", stream=True).raw
+# Or: image = open("docs/cat.jpeg", "rb")
+
+client = Client()
+response = client.chat.completions.create(
+    model=g4f.models.default,
+    messages=[{"role": "user", "content": "What are on this image?"}],
+    provider=g4f.Provider.Bing,
+    image=image,
+    # Add any other necessary parameters
+)
+print(response.choices[0].message.content)
+```
+
 #### Advanced example: A command-line program
 ```python
 import g4f
 from g4f.client import Client
 
 # Initialize the GPT client with the desired provider
-client = Client(provider=g4f.Provider.Bing)
+client = Client()
 
 # Initialize an empty conversation history
 messages = []
@@ -203,4 +243,4 @@ while True:
         print(f"An error occurred: {e}")
 ```
 
-[Return to Home](/)
+[Return to Home](/)