~ | code styling

2025-10-31 19:42:45 +08:00 · 2023-08-27 17:37:44 +02:00
parent 5d08c7201f
commit efd75a11b8
33 changed files with 842 additions and 967 deletions
--- a/g4f/Provider/AItianhu.py
+++ b/g4f/Provider/AItianhu.py
@@ -15,9 +15,8 @@ class AItianhu(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        base = ""
        for message in messages:
            base += "%s: %s\n" % (message["role"], message["content"])
--- a/g4f/Provider/Acytoo.py
+++ b/g4f/Provider/Acytoo.py
@@ -7,7 +7,7 @@ from .base_provider import BaseProvider


 class Acytoo(BaseProvider):
-    url = "https://chat.acytoo.com/"
+    url                   = 'https://chat.acytoo.com/'
    working               = True
    supports_gpt_35_turbo = True

@@ -16,33 +16,33 @@ class Acytoo(BaseProvider):
        cls,
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        headers = _create_header()
-        payload = _create_payload(messages, kwargs.get('temperature', 0.5))
+        stream: bool, **kwargs: Any) -> CreateResult:
+
+        response = requests.post(f'{cls.url}api/completions', 
+                                 headers=_create_header(), json=_create_payload(messages, kwargs.get('temperature', 0.5)))
        
-        response = requests.post("{cls.url}api/completions", headers=headers, json=payload)
        response.raise_for_status()
-        response.encoding = "utf-8"
+        response.encoding = 'utf-8'
+        
        yield response.text


 def _create_header():
    return {
-        "accept": "*/*",
-        "content-type": "application/json",
+        'accept': '*/*',
+        'content-type': 'application/json',
    }


 def _create_payload(messages: list[dict[str, str]], temperature):
    payload_messages = [
-        message | {"createdAt": int(time.time()) * 1000} for message in messages
+        message | {'createdAt': int(time.time()) * 1000} for message in messages
    ]
+    
    return {
-        "key": "",
-        "model": "gpt-3.5-turbo",
-        "messages": payload_messages,
-        "temperature": temperature,
-        "password": "",
+        'key'         : '',
+        'model'       : 'gpt-3.5-turbo',
+        'messages'    : payload_messages,
+        'temperature' : temperature,
+        'password'    : ''
    }
--- a/g4f/Provider/Aichat.py
+++ b/g4f/Provider/Aichat.py
@@ -13,11 +13,9 @@ class Aichat(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        base = ""
+        stream: bool, **kwargs: Any) -> CreateResult:
        
+        base = ""
        for message in messages:
            base += "%s: %s\n" % (message["role"], message["content"])
        base += "assistant:"
--- a/g4f/Provider/Ails.py
+++ b/g4f/Provider/Ails.py
@@ -9,7 +9,6 @@ import requests
 from ..typing import SHA256, Any, CreateResult
 from .base_provider import BaseProvider

-
 class Ails(BaseProvider):
    url: str              = "https://ai.ls"
    working               = True
@@ -20,9 +19,8 @@ class Ails(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        headers = {
            "authority": "api.caipacity.com",
            "accept": "*/*",
--- a/g4f/Provider/Bard.py
+++ b/g4f/Provider/Bard.py
@@ -19,9 +19,7 @@ class Bard(AsyncProvider):
        model: str,
        messages: list[dict[str, str]],
        proxy: str = None,
-        cookies: dict = get_cookies(".google.com"),
-        **kwargs: Any,
-    ) -> str:
+        cookies: dict = get_cookies(".google.com"), **kwargs: Any,) -> str:

        formatted = "\n".join(
            ["%s: %s" % (message["role"], message["content"]) for message in messages]
--- a/g4f/Provider/Bing.py
+++ b/g4f/Provider/Bing.py
@@ -1,12 +1,6 @@
-import asyncio
-import json
-import os
-import random
+import asyncio, aiohttp, json, os, random

-import aiohttp
-import asyncio
 from aiohttp        import ClientSession
-
 from ..typing       import Any, AsyncGenerator, CreateResult, Union
 from .base_provider import AsyncGeneratorProvider, get_cookies

@@ -21,9 +15,8 @@ class Bing(AsyncGeneratorProvider):
    def create_async_generator(
            model: str,
            messages: list[dict[str, str]],
-            cookies: dict = get_cookies(".bing.com"),
-            **kwargs
-        ) -> AsyncGenerator:
+            cookies: dict = get_cookies(".bing.com"), **kwargs) -> AsyncGenerator:
+        
        if len(messages) < 2:
            prompt = messages[0]["content"]
            context = None
--- a/g4f/Provider/ChatgptAi.py
+++ b/g4f/Provider/ChatgptAi.py
@@ -1,13 +1,11 @@
-import re
-
-import requests
+import re, requests

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider


 class ChatgptAi(BaseProvider):
-    url = "https://chatgpt.ai/gpt-4/"
+    url: str        = "https://chatgpt.ai/gpt-4/"
    working         = True
    supports_gpt_4  = True

@@ -15,9 +13,8 @@ class ChatgptAi(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        chat = ""
        for message in messages:
            chat += "%s: %s\n" % (message["role"], message["content"])
@@ -26,8 +23,7 @@ class ChatgptAi(BaseProvider):
        response = requests.get("https://chatgpt.ai/")
        nonce, post_id, _, bot_id = re.findall(
            r'data-nonce="(.*)"\n     data-post-id="(.*)"\n     data-url="(.*)"\n     data-bot-id="(.*)"\n     data-width',
-            response.text,
-        )[0]
+            response.text)[0]

        headers = {
            "authority"          : "chatgpt.ai",
@@ -55,7 +51,7 @@ class ChatgptAi(BaseProvider):
        }

        response = requests.post(
-            "https://chatgpt.ai/wp-admin/admin-ajax.php", headers=headers, data=data
-        )
+            "https://chatgpt.ai/wp-admin/admin-ajax.php", headers=headers, data=data)
+        
        response.raise_for_status()
        yield response.json()["data"]
--- a/g4f/Provider/ChatgptLogin.py
+++ b/g4f/Provider/ChatgptLogin.py
@@ -1,8 +1,4 @@
-import base64
-import os
-import re
-
-import requests
+import base64, os, re, requests

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider
@@ -17,9 +13,8 @@ class ChatgptLogin(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        headers = {
            "authority"          : "chatgptlogin.ac",
            "accept"             : "*/*",
@@ -56,14 +51,12 @@ class ChatgptLogin(BaseProvider):
            "service"        : "openai",
            "embeddingsIndex": "",
            "stop"           : "",
-            "clientId": os.urandom(6).hex(),
+            "clientId"       : os.urandom(6).hex()
        }

-        response = requests.post(
-            "https://opchatgpts.net/wp-json/ai-chatbot/v1/chat",
-            headers=headers,
-            json=json_data,
-        )
+        response = requests.post("https://opchatgpts.net/wp-json/ai-chatbot/v1/chat",
+            headers=headers, json=json_data)
+        
        response.raise_for_status()
        yield response.json()["reply"]

@@ -81,18 +74,15 @@ class ChatgptLogin(BaseProvider):


 def _get_nonce() -> str:
-    res = requests.get(
-        "https://opchatgpts.net/chatgpt-free-use/",
+    res = requests.get("https://opchatgpts.net/chatgpt-free-use/",
        headers = {
            "Referer"   : "https://opchatgpts.net/chatgpt-free-use/",
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
-        },
-    )
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"})

    result = re.search(
        r'class="mwai-chat mwai-chatgpt">.*<span>Send</span></button></div></div></div> <script defer src="(.*?)">',
-        res.text,
-    )
+        res.text)
+    
    if result is None:
        return ""
    
--- a/g4f/Provider/DeepAi.py
+++ b/g4f/Provider/DeepAi.py
@@ -1,14 +1,11 @@
-import json
-
-import js2py
-import requests
+import json, js2py, requests

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider


 class DeepAi(BaseProvider):
-    url = "https://deepai.org"
+    url: str              = "https://deepai.org"
    working               = True
    supports_stream       = True
    supports_gpt_35_turbo = True
@@ -17,10 +14,8 @@ class DeepAi(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
-        url = "https://api.deepai.org/make_me_a_pizza"
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        token_js = """
 var agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36'
 var a, b, c, d, e, h, f, l, g, k, m, n, r, x, C, E, N, F, T, O, P, w, D, G, Q, R, W, I, aa, fa, na, oa, ha, ba, X, ia, ja, ka, J, la, K, L, ca, S, U, M, ma, B, da, V, Y;
@@ -54,7 +49,9 @@ f = function () {
            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36",
        }

-        response = requests.post(url, headers=headers, data=payload, stream=True)
+        response = requests.post("https://api.deepai.org/make_me_a_pizza", 
+                                 headers=headers, data=payload, stream=True)
+        
        for chunk in response.iter_content(chunk_size=None):
            response.raise_for_status()
            yield chunk.decode()
--- a/g4f/Provider/DfeHub.py
+++ b/g4f/Provider/DfeHub.py
@@ -1,8 +1,4 @@
-import json
-import re
-import time
-
-import requests
+import json, re, time , requests

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider
@@ -17,9 +13,8 @@ class DfeHub(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        headers = {
            "authority"         : "chat.dfehub.com",
            "accept"            : "*/*",
@@ -44,14 +39,11 @@ class DfeHub(BaseProvider):
            "presence_penalty"  : kwargs.get("presence_penalty", 0),
            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
            "top_p"             : kwargs.get("top_p", 1),
-            "stream": True,
+            "stream"            : True
        }
-        response = requests.post(
-            "https://chat.dfehub.com/api/openai/v1/chat/completions",
-            headers=headers,
-            json=json_data,
-            timeout=3
-        )
+        
+        response = requests.post("https://chat.dfehub.com/api/openai/v1/chat/completions",
+            headers=headers, json=json_data, timeout=3)

        for chunk in response.iter_lines():
            if b"detail" in chunk:
--- a/g4f/Provider/EasyChat.py
+++ b/g4f/Provider/EasyChat.py
@@ -1,13 +1,11 @@
-import json
-
-import requests
+import json, requests, random

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider


 class EasyChat(BaseProvider):
-    url = "https://free.easychat.work"
+    url: str              = "https://free.easychat.work"
    supports_stream       = True
    supports_gpt_35_turbo = True
    working               = True
@@ -16,9 +14,8 @@ class EasyChat(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        active_servers = [
            "https://chat10.fastgpt.me",
            "https://chat9.fastgpt.me",
@@ -28,7 +25,8 @@ class EasyChat(BaseProvider):
            "https://chat4.fastgpt.me",
            "https://gxos1h1ddt.fastgpt.me"
        ]
-        server = active_servers[kwargs.get("active_server", 0)]
+        
+        server  = active_servers[kwargs.get("active_server", random.randint(0, 5))]
        headers = {
            "authority"         : f"{server}".replace("https://", ""),
            "accept"            : "text/event-stream",
@@ -56,31 +54,33 @@ class EasyChat(BaseProvider):
            "temperature"       : kwargs.get("temperature", 0.5),
            "presence_penalty"  : kwargs.get("presence_penalty", 0),
            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
-            "top_p": kwargs.get("top_p", 1),
+            "top_p"             : kwargs.get("top_p", 1)
        }

        session = requests.Session()
        # init cookies from server
        session.get(f"{server}/")

-        response = session.post(
-            f"{server}/api/openai/v1/chat/completions",
-            headers=headers,
-            json=json_data,
-            stream=stream,
-        )
+        response = session.post(f"{server}/api/openai/v1/chat/completions",
+            headers=headers, json=json_data, stream=stream)
+        
        if response.status_code == 200:
+            
            if stream == False:
                json_data = response.json()
+                
                if "choices" in json_data:
                    yield json_data["choices"][0]["message"]["content"]
                else:
                    raise Exception("No response from server")
+            
            else:
                
                for chunk in response.iter_lines():
+                    
                    if b"content" in chunk:
                        splitData = chunk.decode().split("data:")
+                        
                        if len(splitData) > 1:
                            yield json.loads(splitData[1])["choices"][0]["delta"]["content"]
                        else:
--- a/g4f/Provider/Equing.py
+++ b/g4f/Provider/Equing.py
@@ -1,6 +1,6 @@
 import requests, json
-from abc import ABC, abstractmethod

+from abc      import ABC, abstractmethod
 from ..typing import Any, CreateResult


@@ -17,8 +17,7 @@ class Equing(ABC):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:

        headers = {
            'authority'         : 'next.eqing.tech',
@@ -38,7 +37,7 @@ class Equing(ABC):
            'sec-fetch-site'    : 'same-origin',
            'user-agent'        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36',
            'usesearch'         : 'false',
-            'x-requested-with': 'XMLHttpRequest',
+            'x-requested-with'  : 'XMLHttpRequest'
        }

        json_data = {
@@ -53,6 +52,7 @@ class Equing(ABC):

        response = requests.post('https://next.eqing.tech/api/openai/v1/chat/completions',
            headers=headers, json=json_data, stream=stream)
+        
        if not stream:
            yield response.json()["choices"][0]["message"]["content"]
            return
--- a/g4f/Provider/FastGpt.py
+++ b/g4f/Provider/FastGpt.py
@@ -17,8 +17,7 @@ class FastGpt(ABC):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:

        headers = {
            'authority'         : 'chat9.fastgpt.me',
@@ -26,7 +25,6 @@ class FastGpt(ABC):
            'accept-language'   : 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
            'cache-control'     : 'no-cache',
            'content-type'      : 'application/json',
-            # 'cookie': 'cf_clearance=idIAwtoSCn0uCzcWLGuD.KtiAJv9a1GsPduEOqIkyHU-1692278595-0-1-cb11fd7a.ab1546d4.ccf35fd7-0.2.1692278595; Hm_lvt_563fb31e93813a8a7094966df6671d3f=1691966491,1692278597; Hm_lpvt_563fb31e93813a8a7094966df6671d3f=1692278597',
            'origin'            : 'https://chat9.fastgpt.me',
            'plugins'           : '0',
            'pragma'            : 'no-cache',
--- a/g4f/Provider/Forefront.py
+++ b/g4f/Provider/Forefront.py
@@ -15,9 +15,8 @@ class Forefront(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        json_data = {
            "text"          : messages[-1]["content"],
            "action"        : "noauth",
@@ -30,11 +29,9 @@ class Forefront(BaseProvider):
            "internetMode"  : "auto",
        }

-        response = requests.post(
-            "https://streaming.tenant-forefront-default.knative.chi.coreweave.com/free-chat",
-            json=json_data,
-            stream=True,
-        )
+        response = requests.post("https://streaming.tenant-forefront-default.knative.chi.coreweave.com/free-chat",
+            json=json_data, stream=True)
+        
        response.raise_for_status()
        for token in response.iter_lines():
            if b"delta" in token:
--- a/g4f/Provider/GetGpt.py
+++ b/g4f/Provider/GetGpt.py
@@ -1,16 +1,12 @@
-import json
-import os
-import uuid
+import os, json, uuid, requests

-import requests
 from Crypto.Cipher  import AES
-
 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider


 class GetGpt(BaseProvider):
-    url = "https://chat.getgpt.world/"
+    url                   = 'https://chat.getgpt.world/'
    supports_stream       = True
    working               = True
    supports_gpt_35_turbo = True
@@ -19,69 +15,68 @@ class GetGpt(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        headers = {
-            "Content-Type": "application/json",
-            "Referer": "https://chat.getgpt.world/",
-            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
+            'Content-Type'  : 'application/json',
+            'Referer'       : 'https://chat.getgpt.world/',
+            'user-agent'    : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36',
        }
+        
        data = json.dumps(
            {
-                "messages": messages,
-                "frequency_penalty": kwargs.get("frequency_penalty", 0),
-                "max_tokens": kwargs.get("max_tokens", 4000),
-                "model": "gpt-3.5-turbo",
-                "presence_penalty": kwargs.get("presence_penalty", 0),
-                "temperature": kwargs.get("temperature", 1),
-                "top_p": kwargs.get("top_p", 1),
-                "stream": True,
-                "uuid": str(uuid.uuid4()),
+                'messages'          : messages,
+                'frequency_penalty' : kwargs.get('frequency_penalty', 0),
+                'max_tokens'        : kwargs.get('max_tokens', 4000),
+                'model'             : 'gpt-3.5-turbo',
+                'presence_penalty'  : kwargs.get('presence_penalty', 0),
+                'temperature'       : kwargs.get('temperature', 1),
+                'top_p'             : kwargs.get('top_p', 1),
+                'stream'            : True,
+                'uuid'              : str(uuid.uuid4())
            }
        )

-        res = requests.post(
-            "https://chat.getgpt.world/api/chat/stream",
-            headers=headers,
-            json={"signature": _encrypt(data)},
-            stream=True,
-        )
+        res = requests.post('https://chat.getgpt.world/api/chat/stream',
+            headers=headers, json={'signature': _encrypt(data)}, stream=True)

        res.raise_for_status()
        for line in res.iter_lines():
-            if b"content" in line:
-                line_json = json.loads(line.decode("utf-8").split("data: ")[1])
-                yield (line_json["choices"][0]["delta"]["content"])
+            if b'content' in line:
+                line_json = json.loads(line.decode('utf-8').split('data: ')[1])
+                yield (line_json['choices'][0]['delta']['content'])

    @classmethod
    @property
    def params(cls):
        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("presence_penalty", "int"),
-            ("frequency_penalty", "int"),
-            ("top_p", "int"),
-            ("max_tokens", "int"),
+            ('model', 'str'),
+            ('messages', 'list[dict[str, str]]'),
+            ('stream', 'bool'),
+            ('temperature', 'float'),
+            ('presence_penalty', 'int'),
+            ('frequency_penalty', 'int'),
+            ('top_p', 'int'),
+            ('max_tokens', 'int'),
        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"
+        param = ', '.join([': '.join(p) for p in params])
+        return f'g4f.provider.{cls.__name__} supports: ({param})'


 def _encrypt(e: str):
-    t = os.urandom(8).hex().encode("utf-8")
-    n = os.urandom(8).hex().encode("utf-8")
-    r = e.encode("utf-8")
+    t = os.urandom(8).hex().encode('utf-8')
+    n = os.urandom(8).hex().encode('utf-8')
+    r = e.encode('utf-8')
+    
    cipher     = AES.new(t, AES.MODE_CBC, n)
    ciphertext = cipher.encrypt(_pad_data(r))
-    return ciphertext.hex() + t.decode("utf-8") + n.decode("utf-8")
+    
+    return ciphertext.hex() + t.decode('utf-8') + n.decode('utf-8')


 def _pad_data(data: bytes) -> bytes:
    block_size   = AES.block_size
    padding_size = block_size - len(data) % block_size
    padding      = bytes([padding_size] * padding_size)
+    
    return data + padding
--- a/g4f/Provider/H2o.py
+++ b/g4f/Provider/H2o.py
@@ -1,7 +1,4 @@
-import json
-import uuid
-
-import requests
+import json, uuid, requests

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider
@@ -17,9 +14,8 @@ class H2o(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        conversation = ""
        for message in messages:
            conversation += "%s: %s\n" % (message["role"], message["content"])
@@ -35,20 +31,16 @@ class H2o(BaseProvider):
            "activeModel"                       : model,
            "searchEnabled"                     : "true",
        }
-        session.post(
-            "https://gpt-gm.h2o.ai/settings",
-            headers=headers,
-            data=data,
-        )
+        
+        session.post("https://gpt-gm.h2o.ai/settings",
+                     headers=headers, data=data)

        headers = {"Referer": "https://gpt-gm.h2o.ai/"}
        data    = {"model": model}

-        response = session.post(
-            "https://gpt-gm.h2o.ai/conversation",
-            headers=headers,
-            json=data,
-        ).json()
+        response = session.post("https://gpt-gm.h2o.ai/conversation",
+                                headers=headers, json=data).json()
+        
        if "conversationId" not in response:
            return

@@ -72,11 +64,9 @@ class H2o(BaseProvider):
            },
        }

-        response = session.post(
-            f"https://gpt-gm.h2o.ai/conversation/{response['conversationId']}",
-            headers=headers,
-            json=data,
-        )
+        response = session.post(f"https://gpt-gm.h2o.ai/conversation/{response['conversationId']}",
+            headers=headers, json=data)
+        
        response.raise_for_status()
        response.encoding = "utf-8"
        generated_text    = response.text.replace("\n", "").split("data:")
--- a/g4f/Provider/Hugchat.py
+++ b/g4f/Provider/Hugchat.py
@@ -20,12 +20,10 @@ class Hugchat(BaseProvider):
        messages: list[dict[str, str]],
        stream: bool = False,
        proxy: str = None,
-        cookies: str = get_cookies(".huggingface.co"),
-        **kwargs
-    ) -> CreateResult:
+        cookies: str = get_cookies(".huggingface.co"), **kwargs) -> CreateResult:
+        
        bot = ChatBot(
-            cookies=cookies
-        )
+            cookies=cookies)
        
        if proxy and "://" not in proxy:
            proxy = f"http://{proxy}"
--- a/g4f/Provider/Liaobots.py
+++ b/g4f/Provider/Liaobots.py
@@ -1,13 +1,11 @@
-import uuid
-
-import requests
+import uuid, requests

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider


 class Liaobots(BaseProvider):
-    url = "https://liaobots.com"
+    url: str                = "https://liaobots.com"
    supports_stream         = True
    needs_auth              = True
    supports_gpt_35_turbo   = True
@@ -17,9 +15,8 @@ class Liaobots(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        headers = {
            "authority"     : "liaobots.com",
            "content-type"  : "application/json",
@@ -28,6 +25,7 @@ class Liaobots(BaseProvider):
            "user-agent"    : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36",
            "x-auth-code"   : str(kwargs.get("auth")),
        }
+        
        models = {
            "gpt-4": {
                "id": "gpt-4",
@@ -50,12 +48,9 @@ class Liaobots(BaseProvider):
            "prompt"        : "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
        }

-        response = requests.post(
-            "https://liaobots.com/api/chat",
-            headers=headers,
-            json=json_data,
-            stream=True,
-        )
+        response = requests.post("https://liaobots.com/api/chat",
+            headers=headers, json=json_data, stream=True)
+        
        response.raise_for_status()
        for token in response.iter_content(chunk_size=2046):
            yield token.decode("utf-8")
--- a/g4f/Provider/Lockchat.py
+++ b/g4f/Provider/Lockchat.py
@@ -1,13 +1,11 @@
-import json
-
-import requests
+import json, requests

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider


 class Lockchat(BaseProvider):
-    url = "http://supertest.lockchat.app"
+    url: str              = "http://supertest.lockchat.app"
    supports_stream       = True
    supports_gpt_35_turbo = True
    supports_gpt_4        = True
@@ -16,9 +14,8 @@ class Lockchat(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+
        temperature = float(kwargs.get("temperature", 0.7))
        payload = {
            "temperature": temperature,
@@ -30,12 +27,9 @@ class Lockchat(BaseProvider):
        headers = {
            "user-agent": "ChatX/39 CFNetwork/1408.0.4 Darwin/22.5.0",
        }
-        response = requests.post(
-            "http://supertest.lockchat.app/v1/chat/completions",
-            json=payload,
-            headers=headers,
-            stream=True,
-        )
+        response = requests.post("http://supertest.lockchat.app/v1/chat/completions",
+                                 json=payload, headers=headers, stream=True)
+        
        response.raise_for_status()
        for token in response.iter_lines():
            if b"The model: `gpt-4` does not exist" in token:
@@ -45,8 +39,8 @@ class Lockchat(BaseProvider):
                    messages    = messages,
                    stream      = stream,
                    temperature = temperature,
-                    **kwargs,
-                )
+                    **kwargs)
+            
            if b"content" in token:
                token = json.loads(token.decode("utf-8").split("data: ")[1])
                token = token["choices"][0]["delta"].get("content")
--- a/g4f/Provider/Opchatgpts.py
+++ b/g4f/Provider/Opchatgpts.py
@@ -13,25 +13,22 @@ class Opchatgpts(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        temperature   = kwargs.get("temperature", 0.8)
        max_tokens    = kwargs.get("max_tokens", 1024)
        system_prompt = kwargs.get(
            "system_prompt",
-            "Converse as if you were an AI assistant. Be friendly, creative.",
-        )
+            "Converse as if you were an AI assistant. Be friendly, creative.")
+        
        payload = _create_payload(
            messages        = messages,
            temperature     = temperature,
            max_tokens      = max_tokens,
-            system_prompt=system_prompt,
-        )
+            system_prompt   = system_prompt)
+
+        response = requests.post("https://opchatgpts.net/wp-json/ai-chatbot/v1/chat", json=payload)
        
-        response = requests.post(
-            "https://opchatgpts.net/wp-json/ai-chatbot/v1/chat", json=payload
-        )
        response.raise_for_status()
        yield response.json()["reply"]

@@ -39,9 +36,8 @@ class Opchatgpts(BaseProvider):
 def _create_payload(
    messages: list[dict[str, str]],
    temperature: float,
-    max_tokens: int,
-    system_prompt: str,
-):
+    max_tokens: int, system_prompt: str) -> dict:
+    
    return {
        "env"             : "chatbot",
        "session"         : "N/A",
--- a/g4f/Provider/OpenaiChat.py
+++ b/g4f/Provider/OpenaiChat.py
@@ -3,6 +3,7 @@ try:
    from revChatGPT.V1 import AsyncChatbot
 except ImportError:
    has_module = False
+
 from .base_provider import AsyncGeneratorProvider, get_cookies
 from ..typing       import AsyncGenerator

--- a/g4f/Provider/Raycast.py
+++ b/g4f/Provider/Raycast.py
@@ -1,12 +1,11 @@
-import json
-import requests
+import json, requests
+
 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider


 class Raycast(BaseProvider):
    url                     = "https://raycast.com"
-    # model = ['gpt-3.5-turbo', 'gpt-4']
    supports_gpt_35_turbo   = True
    supports_gpt_4          = True
    supports_stream         = True
--- a/g4f/Provider/Theb.py
+++ b/g4f/Provider/Theb.py
@@ -1,5 +1,5 @@
 import json, random, requests
-# from curl_cffi import requests
+
 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider

@@ -15,20 +15,21 @@ class Theb(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        conversation = ''
        for message in messages:
            conversation += '%s: %s\n' % (message['role'], message['content'])
-        
        conversation += 'assistant: '
+        
        auth = kwargs.get("auth", {
            "bearer_token":"free",
            "org_id":"theb",
        })
+        
        bearer_token = auth["bearer_token"]
        org_id       = auth["org_id"]
+        
        headers = {
            'authority'         : 'beta.theb.ai',
            'accept'            : 'text/event-stream',
@@ -46,8 +47,7 @@ class Theb(BaseProvider):
            'user-agent'        : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36',
            'x-ai-model'        : 'ee8d4f29cb7047f78cbe84313ed6ace8',
        }
-        # generate 10 random number
-        # 0.1 - 0.9
+        
        req_rand = random.randint(100000000, 9999999999)

        json_data: dict[str, Any] = {
@@ -63,12 +63,10 @@ class Theb(BaseProvider):
                "long_term_memory"  : "auto"
            }
        }
-        response = requests.post(
-            "https://beta.theb.ai/api/conversation?org_id="+org_id+"&req_rand="+str(req_rand),
-            headers=headers,
-            json=json_data,
-            stream=True,
-        )
+        
+        response = requests.post(f"https://beta.theb.ai/api/conversation?org_id={org_id}&req_rand={req_rand}",
+                                 headers=headers, json=json_data, stream=True)
+        
        response.raise_for_status()
        content = ""
        next_content = ""
--- a/g4f/Provider/V50.py
+++ b/g4f/Provider/V50.py
@@ -1,8 +1,8 @@
 import uuid, requests
+
 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider

-
 class V50(BaseProvider):
    url                     = 'https://p5.v50.ltd'
    supports_gpt_35_turbo   = True
@@ -14,9 +14,8 @@ class V50(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        conversation = ''
        for message in messages:
            conversation += '%s: %s\n' % (message['role'], message['content'])
@@ -31,6 +30,7 @@ class V50(BaseProvider):
            "model"         : model,
            "user"          : str(uuid.uuid4())
        }
+        
        headers = {
            'authority'         : 'p5.v50.ltd',
            'accept'            : 'application/json, text/plain, */*',
@@ -46,6 +46,7 @@ class V50(BaseProvider):
        }
        response = requests.post("https://p5.v50.ltd/api/chat-process", 
                                json=payload, headers=headers, proxies=kwargs['proxy'] if 'proxy' in kwargs else {})
+        
        if "https://fk1.v50.ltd" not in response.text:
            yield response.text

--- a/g4f/Provider/Vercel.py
+++ b/g4f/Provider/Vercel.py
@@ -1,10 +1,6 @@
-import base64
-import json
-import uuid
+import base64, json, uuid, quickjs

-import quickjs
 from curl_cffi      import requests
-
 from ..typing       import Any, CreateResult, TypedDict
 from .base_provider import BaseProvider

@@ -18,9 +14,8 @@ class Vercel(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        if model in ["gpt-3.5-turbo", "gpt-4"]:
            model = "openai:" + model
        yield _chat(model_id=model, messages=messages)
@@ -44,15 +39,13 @@ def _create_payload(model_id: str, messages: list[dict[str, str]]) -> dict[str,
        "messages": messages,
        "playgroundId": str(uuid.uuid4()),
        "chatIndex": 0,
-        "model": model_id,
-    } | default_params
+        "model": model_id} | default_params


 def _create_header(session: requests.Session):
    custom_encoding = _get_custom_encoding(session)
    return {"custom-encoding": custom_encoding}

-
 # based on https://github.com/ading2210/vercel-llm-api
 def _get_custom_encoding(session: requests.Session):
    url = "https://sdk.vercel.ai/openai.jpeg"
--- a/g4f/Provider/Wewordle.py
+++ b/g4f/Provider/Wewordle.py
@@ -1,9 +1,4 @@
-import json
-import random
-import string
-import time
-
-import requests
+import json, random, string, time, requests

 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider
@@ -19,16 +14,15 @@ class Wewordle(BaseProvider):
        cls,
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        # randomize user id and app id
        _user_id = "".join(
-            random.choices(f"{string.ascii_lowercase}{string.digits}", k=16)
-        )
+            random.choices(f"{string.ascii_lowercase}{string.digits}", k=16))
+        
        _app_id = "".join(
-            random.choices(f"{string.ascii_lowercase}{string.digits}", k=31)
-        )
+            random.choices(f"{string.ascii_lowercase}{string.digits}", k=31))
+        
        # make current date with format utc
        _request_date = time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime())
        headers = {
@@ -39,6 +33,7 @@ class Wewordle(BaseProvider):
            # user agent android client
            # 'User-Agent': 'Dalvik/2.1.0 (Linux; U; Android 10; SM-G975F Build/QP1A.190711.020)',
        }
+        
        data: dict[str, Any] = {
            "user"      : _user_id,
            "messages"  : messages,
@@ -60,10 +55,12 @@ class Wewordle(BaseProvider):
                "allPurchasedProductIdentifiers": [],
                "firstSeen"                     : _request_date,
                "activeSubscriptions"           : [],
-            },
+            }
        }

-        response = requests.post(f"{cls.url}gptapi/v1/android/turbo", headers=headers, data=json.dumps(data))
+        response = requests.post(f"{cls.url}gptapi/v1/android/turbo", 
+                                 headers=headers, data=json.dumps(data))
+        
        response.raise_for_status()
        _json = response.json()
        if "message" in _json:
--- a/g4f/Provider/You.py
+++ b/g4f/Provider/You.py
@@ -1,9 +1,6 @@
-import re
-import urllib.parse
-import json
+import urllib.parse, json

 from curl_cffi      import requests
-
 from ..typing       import Any, CreateResult
 from .base_provider import BaseProvider

@@ -17,17 +14,14 @@ class You(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        url_param = _create_url_param(messages, kwargs.get("history", []))
        headers   = _create_header()
-        url = f"https://you.com/api/streamingSearch?{url_param}"
-        response = requests.get(
-            url,
-            headers=headers,
-            impersonate="chrome107",
-        )
+        
+        response = requests.get(f"https://you.com/api/streamingSearch?{url_param}",
+            headers=headers, impersonate="chrome107")
+        
        response.raise_for_status()
        
        start = 'data: {"youChatToken": '
--- a/g4f/Provider/Yqcloud.py
+++ b/g4f/Provider/Yqcloud.py
@@ -13,14 +13,14 @@ class Yqcloud(BaseProvider):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        headers = _create_header()
        payload = _create_payload(messages)

-        url = "https://api.aichatos.cloud/api/generateStream"
-        response = requests.post(url=url, headers=headers, json=payload)
+        response = requests.post("https://api.aichatos.cloud/api/generateStream", 
+                                 headers=headers, json=payload)
+        
        response.raise_for_status()
        response.encoding = 'utf-8'
        yield response.text
@@ -39,6 +39,7 @@ def _create_payload(messages: list[dict[str, str]]):
    for message in messages:
        prompt += "%s: %s\n" % (message["role"], message["content"])
    prompt += "assistant:"
+    
    return {
        "prompt"        : prompt,
        "network"       : True,
--- a/g4f/Provider/init.py
+++ b/g4f/Provider/init.py
@@ -4,7 +4,6 @@ from .Ails import Ails
 from .AiService     import AiService
 from .AItianhu      import AItianhu
 from .Bard          import Bard
-from .base_provider import BaseProvider
 from .Bing          import Bing
 from .ChatgptAi     import ChatgptAi
 from .ChatgptLogin  import ChatgptLogin
@@ -30,36 +29,38 @@ from .FastGpt import FastGpt
 from .V50           import V50
 from .Wuguokai      import Wuguokai

+from .base_provider import BaseProvider
+
 __all__ = [
-    "BaseProvider",
-    "Acytoo",
-    "Aichat",
-    "Ails",
-    "AiService",
-    "AItianhu",
-    "Bard",
-    "Bing",
-    "ChatgptAi",
-    "ChatgptLogin",
-    "DeepAi",
-    "DfeHub",
-    "EasyChat",
-    "Forefront",
-    "GetGpt",
-    "H2o",
-    "Hugchat",
-    "Liaobots",
-    "Lockchat",
-    "Opchatgpts",
-    "Raycast",
-    "OpenaiChat",
-    "Theb",
-    "Vercel",
-    "Wewordle",
-    "You",
-    "Yqcloud",
-    "Equing",
-    "FastGpt",
-    "Wuguokai"
-    "V50"
+    'BaseProvider',
+    'Acytoo',
+    'Aichat',
+    'Ails',
+    'AiService',
+    'AItianhu',
+    'Bard',
+    'Bing',
+    'ChatgptAi',
+    'ChatgptLogin',
+    'DeepAi',
+    'DfeHub',
+    'EasyChat',
+    'Forefront',
+    'GetGpt',
+    'H2o',
+    'Hugchat',
+    'Liaobots',
+    'Lockchat',
+    'Opchatgpts',
+    'Raycast',
+    'OpenaiChat',
+    'Theb',
+    'Vercel',
+    'Wewordle',
+    'You',
+    'Yqcloud',
+    'Equing',
+    'FastGpt',
+    'Wuguokai',
+    'V50'
 ]
--- a/g4f/Provider/base_provider.py
+++ b/g4f/Provider/base_provider.py
@@ -20,9 +20,8 @@ class BaseProvider(ABC):
    def create_completion(
        model: str,
        messages: list[dict[str, str]],
-        stream: bool,
-        **kwargs: Any,
-    ) -> CreateResult:
+        stream: bool, **kwargs: Any) -> CreateResult:
+        
        raise NotImplementedError()

    @classmethod
@@ -42,8 +41,10 @@ _cookies = {}
 def get_cookies(cookie_domain: str) -> dict:
    if cookie_domain not in _cookies:
        _cookies[cookie_domain] = {}
+        
        for cookie in browser_cookie3.load(cookie_domain):
            _cookies[cookie_domain][cookie.name] = cookie.value
+    
    return _cookies[cookie_domain]


@@ -53,18 +54,15 @@ class AsyncProvider(BaseProvider):
        cls,
        model: str,
        messages: list[dict[str, str]],
-        stream: bool = False,
-        **kwargs: Any
-    ) -> CreateResult:
+        stream: bool = False, **kwargs: Any) -> CreateResult:
+        
        yield asyncio.run(cls.create_async(model, messages, **kwargs))

    @staticmethod
    @abstractmethod
    async def create_async(
        model: str,
-        messages: list[dict[str, str]],
-        **kwargs: Any,
-    ) -> str:
+        messages: list[dict[str, str]], **kwargs: Any) -> str:
        raise NotImplementedError()


@@ -74,9 +72,8 @@ class AsyncGeneratorProvider(AsyncProvider):
        cls,
        model: str,
        messages: list[dict[str, str]],
-        stream: bool = True,
-        **kwargs: Any
-    ) -> CreateResult:
+        stream: bool = True, **kwargs: Any) -> CreateResult:
+        
        if stream:
            yield from run_generator(cls.create_async_generator(model, messages, **kwargs))
        else:
@@ -86,9 +83,8 @@ class AsyncGeneratorProvider(AsyncProvider):
    async def create_async(
        cls,
        model: str,
-        messages: list[dict[str, str]],
-        **kwargs: Any,
-    ) -> str:
+        messages: list[dict[str, str]], **kwargs: Any) -> str:
+        
        chunks = [chunk async for chunk in cls.create_async_generator(model, messages, **kwargs)]
        if chunks:
            return "".join(chunks)
@@ -97,8 +93,8 @@ class AsyncGeneratorProvider(AsyncProvider):
    @abstractmethod
    def create_async_generator(
            model: str,
-            messages: list[dict[str, str]],
-        ) -> AsyncGenerator:
+            messages: list[dict[str, str]]) -> AsyncGenerator:
+        
        raise NotImplementedError()


--- a/g4f/init.py
+++ b/g4f/init.py
@@ -4,7 +4,6 @@ from .typing import Any, CreateResult, Union

 logging = False

-
 class ChatCompletion:
    @staticmethod
    def create(
@@ -12,34 +11,32 @@ class ChatCompletion:
        messages : list[dict[str, str]],
        provider : Union[type[BaseProvider], None] = None,
        stream   : bool                            = False,
-        auth: Union[str, None] = None,
-        **kwargs: Any,
-    ) -> Union[CreateResult, str]:
+        auth     : Union[str, None]                = None, **kwargs: Any) -> Union[CreateResult, str]:
+        
        if isinstance(model, str):
            try:
                model = models.ModelUtils.convert[model]
            except KeyError:
-                raise Exception(f"The model: {model} does not exist")
+                raise Exception(f'The model: {model} does not exist')

        provider = model.best_provider if provider == None else provider

        if not provider.working:
-            raise Exception(f"{provider.__name__} is not working")
+            raise Exception(f'{provider.__name__} is not working')

        if provider.needs_auth and not auth:
            raise Exception(
-                f'ValueError: {provider.__name__} requires authentication (use auth="cookie or token or jwt ..." param)'
-            )
+                f'ValueError: {provider.__name__} requires authentication (use auth=\'cookie or token or jwt ...\' param)')
+            
        if provider.needs_auth:
-            kwargs["auth"] = auth
+            kwargs['auth'] = auth

        if not provider.supports_stream and stream:
            raise Exception(
-                f"ValueError: {provider.__name__} does not support 'stream' argument"
-            )
+                f'ValueError: {provider.__name__} does not support "stream" argument')

        if logging:
-            print(f"Using {provider.__name__} provider")
+            print(f'Using {provider.__name__} provider')

        result = provider.create_completion(model.name, messages, stream, **kwargs)
-        return result if stream else "".join(result)
+        return result if stream else ''.join(result)
--- a/g4f/models.py
+++ b/g4f/models.py
@@ -1,8 +1,6 @@
 from dataclasses import dataclass
-
 from .Provider import Bard, BaseProvider, GetGpt, H2o, Liaobots, Vercel, Equing

-
@dataclass
 class Model:
    name: str
@@ -12,214 +10,190 @@ class Model:

 # GPT-3.5 / GPT-4
 gpt_35_turbo = Model(
-    name="gpt-3.5-turbo",
-    base_provider="openai",
-    best_provider=GetGpt,
-)
+    name          = 'gpt-3.5-turbo',
+    base_provider = 'openai',
+    best_provider = GetGpt)

 gpt_4 = Model(
-    name="gpt-4",
-    base_provider="openai",
-    best_provider=Liaobots,
-)
+    name          = 'gpt-4',
+    base_provider = 'openai',
+    best_provider = Liaobots)

 # Bard
 palm = Model(
-    name="palm",
-    base_provider="google",
-    best_provider=Bard,
-)
+    name          = 'palm',
+    base_provider = 'google',
+    best_provider = Bard)

 # H2o
 falcon_7b = Model(
-    name="h2oai/h2ogpt-gm-oasst1-en-2048-falcon-7b-v3",
-    base_provider="huggingface",
-    best_provider=H2o,
-)
+    name          = 'h2oai/h2ogpt-gm-oasst1-en-2048-falcon-7b-v3',
+    base_provider = 'huggingface',
+    best_provider = H2o)

 falcon_40b = Model(
-    name="h2oai/h2ogpt-gm-oasst1-en-2048-falcon-40b-v1",
-    base_provider="huggingface",
-    best_provider=H2o,
-)
+    name          = 'h2oai/h2ogpt-gm-oasst1-en-2048-falcon-40b-v1',
+    base_provider = 'huggingface',
+    best_provider = H2o)

 llama_13b = Model(
-    name="h2oai/h2ogpt-gm-oasst1-en-2048-open-llama-13b",
-    base_provider="huggingface",
-    best_provider=H2o,
-)
+    name          = 'h2oai/h2ogpt-gm-oasst1-en-2048-open-llama-13b',
+    base_provider = 'huggingface',
+    best_provider = H2o)

 # Vercel
 claude_instant_v1 = Model(
-    name="anthropic:claude-instant-v1",
-    base_provider="anthropic",
-    best_provider=Vercel,
-)
+    name          = 'anthropic:claude-instant-v1',
+    base_provider = 'anthropic',
+    best_provider = Vercel)

 claude_v1 = Model(
-    name="anthropic:claude-v1",
-    base_provider="anthropic",
-    best_provider=Vercel,
-)
+    name          = 'anthropic:claude-v1',
+    base_provider = 'anthropic',
+    best_provider = Vercel)

 claude_v2 = Model(
-    name="anthropic:claude-v2",
-    base_provider="anthropic",
-    best_provider=Vercel,
-)
+    name          = 'anthropic:claude-v2',
+    base_provider = 'anthropic',
+    best_provider = Vercel)

 command_light_nightly = Model(
-    name="cohere:command-light-nightly",
-    base_provider="cohere",
-    best_provider=Vercel,
-)
+    name          = 'cohere:command-light-nightly',
+    base_provider = 'cohere',
+    best_provider = Vercel)

 command_nightly = Model(
-    name="cohere:command-nightly",
-    base_provider="cohere",
-    best_provider=Vercel,
-)
+    name          = 'cohere:command-nightly',
+    base_provider = 'cohere',
+    best_provider = Vercel)

 gpt_neox_20b = Model(
-    name="huggingface:EleutherAI/gpt-neox-20b",
-    base_provider="huggingface",
-    best_provider=Vercel,
-)
+    name          = 'huggingface:EleutherAI/gpt-neox-20b',
+    base_provider = 'huggingface',
+    best_provider = Vercel)

 oasst_sft_1_pythia_12b = Model(
-    name="huggingface:OpenAssistant/oasst-sft-1-pythia-12b",
-    base_provider="huggingface",
-    best_provider=Vercel,
-)
+    name          = 'huggingface:OpenAssistant/oasst-sft-1-pythia-12b',
+    base_provider = 'huggingface',
+    best_provider = Vercel)

 oasst_sft_4_pythia_12b_epoch_35 = Model(
-    name="huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
-    base_provider="huggingface",
-    best_provider=Vercel,
-)
+    name          = 'huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5',
+    base_provider = 'huggingface',
+    best_provider = Vercel)

 santacoder = Model(
-    name="huggingface:bigcode/santacoder",
-    base_provider="huggingface",
-    best_provider=Vercel,
-)
+    name          = 'huggingface:bigcode/santacoder',
+    base_provider = 'huggingface',
+    best_provider = Vercel)

 bloom = Model(
-    name="huggingface:bigscience/bloom",
-    base_provider="huggingface",
-    best_provider=Vercel,
-)
+    name          = 'huggingface:bigscience/bloom',
+    base_provider = 'huggingface',
+    best_provider = Vercel)

 flan_t5_xxl = Model(
-    name="huggingface:google/flan-t5-xxl",
-    base_provider="huggingface",
-    best_provider=Vercel,
-)
+    name          = 'huggingface:google/flan-t5-xxl',
+    base_provider = 'huggingface',
+    best_provider = Vercel)

 code_davinci_002 = Model(
-    name="openai:code-davinci-002",
-    base_provider="openai",
-    best_provider=Vercel,
-)
+    name          = 'openai:code-davinci-002',
+    base_provider = 'openai',
+    best_provider = Vercel)

 gpt_35_turbo_16k = Model(
-    name="openai:gpt-3.5-turbo-16k",
-    base_provider="openai",
-    best_provider=Vercel,
-)
+    name          = 'openai:gpt-3.5-turbo-16k',
+    base_provider = 'openai',
+    best_provider = Vercel)

 gpt_35_turbo_16k_0613 = Model(
-    name="openai:gpt-3.5-turbo-16k-0613",
-    base_provider="openai",
-    best_provider=Equing,
-)
+    name          = 'openai:gpt-3.5-turbo-16k-0613',
+    base_provider = 'openai',
+    best_provider = Equing)

 gpt_4_0613 = Model(
-    name="openai:gpt-4-0613",
-    base_provider="openai",
-    best_provider=Vercel,
-)
+    name          = 'openai:gpt-4-0613',
+    base_provider = 'openai',
+    best_provider = Vercel)

 text_ada_001 = Model(
-    name="openai:text-ada-001",
-    base_provider="openai",
-    best_provider=Vercel,
-)
+    name          = 'openai:text-ada-001',
+    base_provider = 'openai',
+    best_provider = Vercel)

 text_babbage_001 = Model(
-    name="openai:text-babbage-001",
-    base_provider="openai",
-    best_provider=Vercel,
-)
+    name          = 'openai:text-babbage-001',
+    base_provider = 'openai',
+    best_provider = Vercel)

 text_curie_001 = Model(
-    name="openai:text-curie-001",
-    base_provider="openai",
-    best_provider=Vercel,
-)
+    name          = 'openai:text-curie-001',
+    base_provider = 'openai',
+    best_provider = Vercel)

 text_davinci_002 = Model(
-    name="openai:text-davinci-002",
-    base_provider="openai",
-    best_provider=Vercel,
-)
+    name          = 'openai:text-davinci-002',
+    base_provider = 'openai',
+    best_provider = Vercel)

 text_davinci_003 = Model(
-    name="openai:text-davinci-003",
-    base_provider="openai",
-    best_provider=Vercel,
-)
+    name          = 'openai:text-davinci-003',
+    base_provider = 'openai',
+    best_provider = Vercel)

 llama13b_v2_chat = Model(
-    name="replicate:a16z-infra/llama13b-v2-chat",
-    base_provider="replicate",
-    best_provider=Vercel,
-)
+    name          = 'replicate:a16z-infra/llama13b-v2-chat',
+    base_provider = 'replicate',
+    best_provider = Vercel)

 llama7b_v2_chat = Model(
-    name="replicate:a16z-infra/llama7b-v2-chat",
-    base_provider="replicate",
-    best_provider=Vercel,
-)
+    name          = 'replicate:a16z-infra/llama7b-v2-chat',
+    base_provider = 'replicate',
+    best_provider = Vercel)


 class ModelUtils:
    convert: dict[str, Model] = {
        # GPT-3.5 / GPT-4
-        "gpt-3.5-turbo": gpt_35_turbo,
-        "gpt-4": gpt_4,
+        'gpt-3.5-turbo' : gpt_35_turbo,
+        'gpt-4'         : gpt_4,
+        
        # Bard
-        "palm2": palm,
-        "palm": palm,
-        "google": palm,
-        "google-bard": palm,
-        "google-palm": palm,
-        "bard": palm,
+        'palm2'       : palm,
+        'palm'        : palm,
+        'google'      : palm,
+        'google-bard' : palm,
+        'google-palm' : palm,
+        'bard'        : palm,
+        
        # H2o
-        "falcon-40b": falcon_40b,
-        "falcon-7b": falcon_7b,
-        "llama-13b": llama_13b,
+        'falcon-40b' : falcon_40b,
+        'falcon-7b'  : falcon_7b,
+        'llama-13b'  : llama_13b,
+        
        # Vercel
-        "claude-instant-v1": claude_instant_v1,
-        "claude-v1": claude_v1,
-        "claude-v2": claude_v2,
-        "command-light-nightly": command_light_nightly,
-        "command-nightly": command_nightly,
-        "gpt-neox-20b": gpt_neox_20b,
-        "oasst-sft-1-pythia-12b": oasst_sft_1_pythia_12b,
-        "oasst-sft-4-pythia-12b-epoch-3.5": oasst_sft_4_pythia_12b_epoch_35,
-        "santacoder": santacoder,
-        "bloom": bloom,
-        "flan-t5-xxl": flan_t5_xxl,
-        "code-davinci-002": code_davinci_002,
-        "gpt-3.5-turbo-16k": gpt_35_turbo_16k,
-        "gpt-3.5-turbo-16k-0613": gpt_35_turbo_16k_0613,
-        "gpt-4-0613": gpt_4_0613,
-        "text-ada-001": text_ada_001,
-        "text-babbage-001": text_babbage_001,
-        "text-curie-001": text_curie_001,
-        "text-davinci-002": text_davinci_002,
-        "text-davinci-003": text_davinci_003,
-        "llama13b-v2-chat": llama13b_v2_chat,
-        "llama7b-v2-chat": llama7b_v2_chat,
+        'claude-instant-v1' : claude_instant_v1,
+        'claude-v1'         : claude_v1,
+        'claude-v2'         : claude_v2,
+        'command-nightly'   : command_nightly,
+        'gpt-neox-20b'      : gpt_neox_20b,
+        'santacoder'        : santacoder,
+        'bloom'             : bloom,
+        'flan-t5-xxl'       : flan_t5_xxl,
+        'code-davinci-002'  : code_davinci_002,
+        'gpt-3.5-turbo-16k' : gpt_35_turbo_16k,
+        'gpt-4-0613'        : gpt_4_0613,
+        'text-ada-001'      : text_ada_001,
+        'text-babbage-001'  : text_babbage_001,
+        'text-curie-001'    : text_curie_001,
+        'text-davinci-002'  : text_davinci_002,
+        'text-davinci-003'  : text_davinci_003,
+        'llama13b-v2-chat'  : llama13b_v2_chat,
+        'llama7b-v2-chat'   : llama7b_v2_chat,
+        
+        'oasst-sft-1-pythia-12b'           : oasst_sft_1_pythia_12b,
+        'oasst-sft-4-pythia-12b-epoch-3.5' : oasst_sft_4_pythia_12b_epoch_35,
+        'command-light-nightly'            : command_light_nightly,
+        'gpt-3.5-turbo-16k-0613'           : gpt_35_turbo_16k_0613,
    }
--- a/g4f/typing.py
+++ b/g4f/typing.py
@@ -1,15 +1,14 @@
 from typing import Any, AsyncGenerator, Generator, NewType, Tuple, TypedDict, Union

-SHA256 = NewType("sha_256_hash", str)
+SHA256 = NewType('sha_256_hash', str)
 CreateResult = Generator[str, None, None]

-
 __all__ = [
-    "Any",
-    "AsyncGenerator",
-    "Generator",
-    "Tuple",
-    "TypedDict",
-    "SHA256",
-    "CreateResult",
+    'Any',
+    'AsyncGenerator',
+    'Generator',
+    'Tuple',
+    'TypedDict',
+    'SHA256',
+    'CreateResult',
 ]