gpt4free

公开

关注 0 Fork 0 Star 1

返回提交历史

XFEstudio/gpt4free

Fix HuggingChat and PerplexityLabs and add HuggingFace provider Add more models and image generation in You provider Use You as second default image provider

ec51e9c7

Heiner Lohaus <hlohaus@users.noreply.github.com>

提交于 2024-03-11 02:41

父提交 74a33f1

代码差异

12 个文件 +234 -76

Modified g4f/Provider/BingCreateImages.py +2 -2

@@ -2,7 +2,7 @@ from __future__ import annotations

2 2

3 3 import asyncio

4 4 import os

5 from typing import Generator

5 from typing import Iterator, Union

6 6

7 7 from ..cookies import get_cookies

8 8 from ..image import ImageResponse

@@ -16,7 +16,7 @@ class BingCreateImages:

16 16 self.cookies = cookies

17 17 self.proxy = proxy

18 18

19 def create(self, prompt: str) -> Generator[ImageResponse, None, None]:

19 def create(self, prompt: str) -> Iterator[Union[ImageResponse, str]]:

20 20 """

21 21 Generator for creating imagecompletion based on a prompt.

22 22

Modified g4f/Provider/HuggingChat.py +21 -14

@@ -1,12 +1,12 @@

1 1 from __future__ import annotations

2 2

3 import json, uuid

3 import json

4 4

5 5 from aiohttp import ClientSession, BaseConnector

6 6

7 7 from ..typing import AsyncResult, Messages

8 8 from .base_provider import AsyncGeneratorProvider, ProviderModelMixin

9 from .helper import format_prompt, get_cookies, get_connector

9 from .helper import format_prompt, get_connector

10 10

11 11

12 12 class HuggingChat(AsyncGeneratorProvider, ProviderModelMixin):

@@ -24,7 +24,6 @@ class HuggingChat(AsyncGeneratorProvider, ProviderModelMixin):

24 24 ]

25 25 model_aliases = {

26 26 "openchat/openchat_3.5": "openchat/openchat-3.5-1210",

27 "mistralai/Mixtral-8x7B-Instruct-v0.1": "mistralai/Mistral-7B-Instruct-v0.2"

28 27 }

29 28

30 29 @classmethod

@@ -39,9 +38,11 @@ class HuggingChat(AsyncGeneratorProvider, ProviderModelMixin):

39 38 cookies: dict = None,

40 39 **kwargs

41 40 ) -> AsyncResult:

42 if not cookies:

43 cookies = get_cookies(".huggingface.co", False)

41 options = {"model": cls.get_model(model)}

42 system_prompt = "\n".join([message["content"] for message in messages if message["role"] == "system"])

43 if system_prompt:

44 options["preprompt"] = system_prompt

45 messages = [message for message in messages if message["role"] != "system"]

45 46 headers = {

46 47

            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',

47 48 }

@@ -50,20 +51,27 @@ class HuggingChat(AsyncGeneratorProvider, ProviderModelMixin):

50 51 headers=headers,

51 52 connector=get_connector(connector, proxy)

52 53 ) as session:

            async with session.post(f"{cls.url}/conversation", json={"model": cls.get_model(model)}, proxy=proxy) as response:

54 async with session.post(f"{cls.url}/conversation", json=options, proxy=proxy) as response:

55 response.raise_for_status()

54 56 conversation_id = (await response.json())["conversationId"]

56 send = {

57 "id": str(uuid.uuid4()),

57 async with session.get(f"{cls.url}/conversation/{conversation_id}/__data.json") as response:

58 response.raise_for_status()

59 data: list = (await response.json())["nodes"][1]["data"]

60 keys: list[int] = data[data[0]["messages"]]

61 message_keys: dict = data[keys[0]]

62 message_id: str = data[message_keys["id"]]

63 options = {

64 "id": message_id,

58 65 "inputs": format_prompt(messages),

66 "is_continue": False,

59 67 "is_retry": False,

60 "response_id": str(uuid.uuid4()),

61 68 "web_search": web_search

62 69 }

63 async with session.post(f"{cls.url}/conversation/{conversation_id}", json=send, proxy=proxy) as response:

70 async with session.post(f"{cls.url}/conversation/{conversation_id}", json=options) as response:

64 71 first_token = True

65 72 async for line in response.content:

66 line = json.loads(line[:-1])

73 response.raise_for_status()

74 line = json.loads(line)

67 75 if "type" not in line:

68 76 raise RuntimeError(f"Response: {line}")

69 77 elif line["type"] == "stream":

@@ -74,6 +82,5 @@ class HuggingChat(AsyncGeneratorProvider, ProviderModelMixin):

74 82 yield token

75 83 elif line["type"] == "finalAnswer":

76 84 break

78 85 async with session.delete(f"{cls.url}/conversation/{conversation_id}", proxy=proxy) as response:

79 86 response.raise_for_status()

Added g4f/Provider/HuggingFace.py +75 -0

@@ -0,0 +1,75 @@

1 from __future__ import annotations

3 import json

4 from aiohttp import ClientSession, BaseConnector

6 from ..typing import AsyncResult, Messages

7 from .base_provider import AsyncGeneratorProvider, ProviderModelMixin

8 from .helper import get_connector

9 from ..errors import RateLimitError, ModelNotFoundError

11 class HuggingFace(AsyncGeneratorProvider, ProviderModelMixin):

12 url = "https://huggingface.co/chat"

13 working = True

14 supports_message_history = True

15 default_model = "mistralai/Mixtral-8x7B-Instruct-v0.1"

17 @classmethod

18 async def create_async_generator(

19 cls,

20 model: str,

21 messages: Messages,

22 stream: bool = True,

23 proxy: str = None,

24 connector: BaseConnector = None,

25 api_base: str = "https://api-inference.huggingface.co",

26 api_key: str = None,

27 max_new_tokens: int = 1024,

28 temperature: float = 0.7,

29 **kwargs

30 ) -> AsyncResult:

31 model = cls.get_model(model)

32 headers = {}

33 if api_key is not None:

34 headers["Authorization"] = f"Bearer {api_key}"

35 params = {

36 "return_full_text": False,

37 "max_new_tokens": max_new_tokens,

38 "temperature": temperature,

39 **kwargs

40 }

41 payload = {"inputs": format_prompt(messages), "parameters": params, "stream": stream}

42 async with ClientSession(

43 headers=headers,

44 connector=get_connector(connector, proxy)

45 ) as session:

46 async with session.post(f"{api_base.rstrip('/')}/models/{model}", json=payload) as response:

47 if response.status == 429:

48 raise RateLimitError("Rate limit reached. Set a api_key")

49 elif response.status == 404:

50 raise ModelNotFoundError(f"Model is not supported: {model}")

51 elif response.status != 200:

52 raise RuntimeError(f"Response {response.status}: {await response.text()}")

53 if stream:

54 first = True

55 async for line in response.content:

56 if line.startswith(b"data:"):

57 data = json.loads(line[5:])

58 if not data["token"]["special"]:

59 chunk = data["token"]["text"]

60 if first:

61 first = False

62 chunk = chunk.lstrip()

63 yield chunk

64 else:

65 yield (await response.json())[0]["generated_text"].strip()

67 def format_prompt(messages: Messages) -> str:

68 system_messages = [message["content"] for message in messages if message["role"] == "system"]

69 question = " ".join([messages[-1]["content"], *system_messages])

70 history = "".join([

71 f"<s>[INST]{messages[idx-1]['content']} [/INST] {message}</s>"

72 for idx, message in enumerate(messages)

73 if message["role"] == "assistant"

74 ])

75 return f"{history}<s>[INST] {question} [/INST]"

Modified g4f/Provider/Llama2.py +12 -4

@@ -28,6 +28,10 @@ class Llama2(AsyncGeneratorProvider, ProviderModelMixin):

28 28 model: str,

29 29 messages: Messages,

30 30 proxy: str = None,

31 system_message: str = "You are a helpful assistant.",

32 temperature: float = 0.75,

33 top_p: float = 0.9,

34 max_tokens: int = 8000,

31 35 **kwargs

32 36 ) -> AsyncResult:

33 37 headers = {

@@ -47,14 +51,18 @@ class Llama2(AsyncGeneratorProvider, ProviderModelMixin):

47 51 "TE": "trailers"

48 52 }

49 53 async with ClientSession(headers=headers) as session:

54 system_messages = [message["content"] for message in messages if message["role"] == "system"]

55 if system_messages:

56 system_message = "\n".join(system_messages)

57 messages = [message for message in messages if message["role"] != "system"]

50 58 prompt = format_prompt(messages)

51 59 data = {

52 60 "prompt": prompt,

53 61 "model": cls.get_model(model),

54 "systemPrompt": kwargs.get("system_message", "You are a helpful assistant."),

55 "temperature": kwargs.get("temperature", 0.75),

56 "topP": kwargs.get("top_p", 0.9),

57 "maxTokens": kwargs.get("max_tokens", 8000),

62 "systemPrompt": system_message,

63 "temperature": temperature,

64 "topP": top_p,

65 "maxTokens": max_tokens,

58 66 "image": None

59 67 }

60 68 started = False

Modified g4f/Provider/PerplexityLabs.py +25 -22

@@ -14,17 +14,18 @@ WS_URL = "wss://labs-api.perplexity.ai/socket.io/"

14 14 class PerplexityLabs(AsyncGeneratorProvider, ProviderModelMixin):

15 15 url = "https://labs.perplexity.ai"

16 16 working = True

17 default_model = 'pplx-70b-online'

17 default_model = "sonar-medium-online"

18 18 models = [

19 'pplx-7b-online', 'pplx-70b-online', 'pplx-7b-chat', 'pplx-70b-chat', 'mistral-7b-instruct',

20 'codellama-34b-instruct', 'llama-2-70b-chat', 'llava-7b-chat', 'mixtral-8x7b-instruct',

21 'mistral-medium', 'related'

19 "sonar-small-online", "sonar-medium-online", "sonar-small-chat", "sonar-medium-chat", "mistral-7b-instruct",

20 "codellama-70b-instruct", "llava-v1.5-7b-wrapper", "llava-v1.6-34b", "mixtral-8x7b-instruct",

21 "gemma-2b-it", "gemma-7b-it"

22 "mistral-medium", "related"

22 23 ]

23 24 model_aliases = {

24 25 "mistralai/Mistral-7B-Instruct-v0.1": "mistral-7b-instruct",

25 "meta-llama/Llama-2-70b-chat-hf": "llama-2-70b-chat",

26 26 "mistralai/Mixtral-8x7B-Instruct-v0.1": "mixtral-8x7b-instruct",

27 "codellama/CodeLlama-34b-Instruct-hf": "codellama-34b-instruct"

27 "codellama/CodeLlama-70b-Instruct-hf": "codellama-70b-instruct",

28 "llava-v1.5-7b": "llava-v1.5-7b-wrapper"

28 29 }

29 30

30 31 @classmethod

@@ -50,38 +51,40 @@ class PerplexityLabs(AsyncGeneratorProvider, ProviderModelMixin):

50 51 "TE": "trailers",

51 52 }

52 53 async with ClientSession(headers=headers, connector=get_connector(connector, proxy)) as session:

53 t = format(random.getrandbits(32), '08x')

54 t = format(random.getrandbits(32), "08x")

54 55 async with session.get(

55 56 f"{API_URL}?EIO=4&transport=polling&t={t}"

56 57 ) as response:

57 58 text = await response.text()

58 59

59 sid = json.loads(text[1:])['sid']

60 sid = json.loads(text[1:])["sid"]

60 61 post_data = '40{"jwt":"anonymous-ask-user"}'

61 62 async with session.post(

62 f'{API_URL}?EIO=4&transport=polling&t={t}&sid={sid}',

63 f"{API_URL}?EIO=4&transport=polling&t={t}&sid={sid}",

63 64 data=post_data

64 65 ) as response:

65 assert await response.text() == 'OK'

66 assert await response.text() == "OK"

66 67

67 async with session.ws_connect(f'{WS_URL}?EIO=4&transport=websocket&sid={sid}', autoping=False) as ws:

68 await ws.send_str('2probe')

69 assert(await ws.receive_str() == '3probe')

70 await ws.send_str('5')

68 async with session.ws_connect(f"{WS_URL}?EIO=4&transport=websocket&sid={sid}", autoping=False) as ws:

69 await ws.send_str("2probe")

70 assert(await ws.receive_str() == "3probe")

71 await ws.send_str("5")

71 72 assert(await ws.receive_str())

72 assert(await ws.receive_str() == '6')

73 assert(await ws.receive_str() == "6")

73 74 message_data = {

74 'version': '2.2',

75 'source': 'default',

76 'model': cls.get_model(model),

77 'messages': messages

75 "version": "2.5",

76 "source": "default",

77 "model": cls.get_model(model),

78 "messages": messages

78 79 }

79 await ws.send_str('42' + json.dumps(['perplexity_labs', message_data]))

80 await ws.send_str("42" + json.dumps(["perplexity_labs", message_data]))

80 81 last_message = 0

81 82 while True:

82 83 message = await ws.receive_str()

83 if message == '2':

84 await ws.send_str('3')

84 if message == "2":

85 if last_message == 0:

86 raise RuntimeError("Unknown error")

87 await ws.send_str("3")

85 88 continue

86 89 try:

87 90 data = json.loads(message[2:])[1]

Modified g4f/Provider/You.py +34 -7

@@ -1,21 +1,37 @@

1 1 from __future__ import annotations

2 2

3 import re

3 4 import json

4 5 import base64

5 6 import uuid

6 7 from aiohttp import ClientSession, FormData, BaseConnector

7 8

8 9 from ..typing import AsyncResult, Messages, ImageType, Cookies

9 from .base_provider import AsyncGeneratorProvider

10 from .base_provider import AsyncGeneratorProvider, ProviderModelMixin

10 11 from ..providers.helper import get_connector, format_prompt

11 from ..image import to_bytes

12 from ..image import to_bytes, ImageResponse

12 13 from ..requests.defaults import DEFAULT_HEADERS

13 14

14 class You(AsyncGeneratorProvider):

15 class You(AsyncGeneratorProvider, ProviderModelMixin):

15 16 url = "https://you.com"

16 17 working = True

17 18 supports_gpt_35_turbo = True

18 19 supports_gpt_4 = True

20 default_model = "gpt-3.5-turbo"

21 models = [

22 "gpt-3.5-turbo",

23 "gpt-4",

24 "gpt-4-turbo",

25 "claude-instant",

26 "claude-2",

27 "claude-3-opus",

28 "claude-3-sonnet",

29 "gemini-pro",

30 "zephyr"

31 ]

32 model_aliases = {

33 "claude-v2": "claude-2"

34 }

19 35 _cookies = None

20 36 _cookies_used = 0

21 37

@@ -35,10 +51,15 @@ class You(AsyncGeneratorProvider):

35 51 connector=get_connector(connector, proxy),

36 52 headers=DEFAULT_HEADERS

37 53 ) as client:

38 if image:

54 if image is not None:

39 55 chat_mode = "agent"

40 elif model == "gpt-4":

41 chat_mode = model

56 elif not model or model == cls.default_model:

57 chat_mode = "default"

58 elif model.startswith("dall-e"):

59 chat_mode = "create"

60 else:

61 chat_mode = "custom"

62 model = cls.get_model(model)

42 63 cookies = await cls.get_cookies(client) if chat_mode != "default" else None

43 64 upload = json.dumps([await cls.upload_file(client, cookies, to_bytes(image), image_name)]) if image else ""

44 65 #questions = [message["content"] for message in messages if message["role"] == "user"]

@@ -63,6 +84,8 @@ class You(AsyncGeneratorProvider):

63 84 "userFiles": upload,

64 85 "selectedChatMode": chat_mode,

65 86 }

87 if chat_mode == "custom":

88 params["selectedAIModel"] = model.replace("-", "_")

66 89 async with (client.post if chat_mode == "default" else client.get)(

67 90 f"{cls.url}/api/streamingSearch",

68 91 data=data,

@@ -80,7 +103,11 @@ class You(AsyncGeneratorProvider):

80 103 if event == "youChatToken" and event in data:

81 104 yield data[event]

82 105 elif event == "youChatUpdate" and "t" in data:

83 yield data["t"]

106 match = re.search(r"!\[fig\]\((.+?)\)", data["t"])

107 if match:

108 yield ImageResponse(match.group(1), messages[-1]["content"])

109 else:

110 yield data["t"]

84 111

85 112 @classmethod

86 113 async def upload_file(cls, client: ClientSession, cookies: Cookies, file: bytes, filename: str = None) -> dict:

Modified g4f/Provider/__init__.py +1 -0

@@ -46,6 +46,7 @@ from .GptGod import GptGod

46 46 from .GptTalkRu import GptTalkRu

47 47 from .Hashnode import Hashnode

48 48 from .HuggingChat import HuggingChat

49 from .HuggingFace import HuggingFace

49 50 from .Koala import Koala

50 51 from .Liaobots import Liaobots

51 52 from .Llama2 import Llama2

Modified g4f/Provider/bing/create_images.py +3 -1

@@ -20,7 +20,7 @@ except ImportError:

20 20 from ...providers.create_images import CreateImagesProvider

21 21 from ..helper import get_connector

22 22 from ...providers.types import ProviderType

23 from ...errors import MissingRequirementsError

23 from ...errors import MissingRequirementsError, RateLimitError

24 24 from ...webdriver import WebDriver, get_driver_cookies, get_browser

25 25

26 26 BING_URL = "https://www.bing.com"

@@ -125,6 +125,8 @@ async def create_images(session: ClientSession, prompt: str, proxy: str = None,

125 125 async with session.post(url, allow_redirects=False, data=payload, timeout=timeout) as response:

126 126 response.raise_for_status()

127 127 text = (await response.text()).lower()

128 if "0 coins available" in text:

129 raise RateLimitError("No coins left. Log in with a different account or wait a while")

128 130 for error in ERRORS:

129 131 if error in text:

130 132 raise RuntimeError(f"Create images failed: {error}")

Modified g4f/client.py +35 -19

@@ -10,10 +10,12 @@ from .stubs import ChatCompletion, ChatCompletionChunk, Image, ImagesResponse

10 10 from .typing import Union, Iterator, Messages, ImageType

11 11 from .providers.types import BaseProvider, ProviderType

12 12 from .image import ImageResponse as ImageProviderResponse

13 from .errors import NoImageResponseError, RateLimitError, MissingAuthError

14 from . import get_model_and_provider, get_last_provider

13 16 from .Provider.BingCreateImages import BingCreateImages

14 17 from .Provider.needs_auth import Gemini, OpenaiChat

15 from .errors import NoImageResponseError

16 from . import get_model_and_provider, get_last_provider

18 from .Provider.You import You

17 19

18 20 ImageProvider = Union[BaseProvider, object]

19 21 Proxies = Union[dict, str]

@@ -163,6 +165,7 @@ class Chat():

163 165 class ImageModels():

164 166 gemini = Gemini

165 167 openai = OpenaiChat

168 you = You

166 169

167 170 def __init__(self, client: Client) -> None:

168 171 self.client = client

@@ -171,31 +174,44 @@ class ImageModels():

171 174 def get(self, name: str, default: ImageProvider = None) -> ImageProvider:

172 175 return getattr(self, name) if hasattr(self, name) else default or self.default

173 176

177 def iter_image_response(response: Iterator) -> Union[ImagesResponse, None]:

178 for chunk in list(response):

179 if isinstance(chunk, ImageProviderResponse):

180 return ImagesResponse([Image(image) for image in chunk.get_list()])

181

182 def create_image(client: Client, provider: ProviderType, prompt: str, model: str = "", **kwargs) -> Iterator:

183 prompt = f"create a image with: {prompt}"

184 return provider.create_completion(

185 model,

186 [{"role": "user", "content": prompt}],

187 True,

188 proxy=client.get_proxy(),

189 **kwargs

190 )

191

174 192 class Images():

175 193 def __init__(self, client: Client, provider: ImageProvider = None):

176 194 self.client: Client = client

177 195 self.provider: ImageProvider = provider

178 196 self.models: ImageModels = ImageModels(client)

179 197

180 def generate(self, prompt, model: str = None, **kwargs):

198 def generate(self, prompt, model: str = None, **kwargs) -> ImagesResponse:

181 199 provider = self.models.get(model, self.provider)

182 if isinstance(provider, BaseProvider) or isinstance(provider, type) and issubclass(provider, BaseProvider):

183 prompt = f"create a image: {prompt}"

184 response = provider.create_completion(

185 "",

186 [{"role": "user", "content": prompt}],

187 True,

188 proxy=self.client.get_proxy(),

189 **kwargs

190 )

200 if isinstance(provider, type) and issubclass(provider, BaseProvider):

201 response = create_image(self.client, provider, prompt, **kwargs)

191 202 else:

192 response = provider.create(prompt)

193

194 for chunk in response:

195 if isinstance(chunk, ImageProviderResponse):

196 images = [chunk.images] if isinstance(chunk.images, str) else chunk.images

197 return ImagesResponse([Image(image) for image in images])

198 raise NoImageResponseError()

203 try:

204 response = list(provider.create(prompt))

205 except (RateLimitError, MissingAuthError) as e:

206 # Fallback for default provider

207 if self.provider is None:

208 response = create_image(self.client, self.models.you, prompt, model or "dall-e", **kwargs)

209 else:

210 raise e

211 image = iter_image_response(response)

212 if image is None:

213 raise NoImageResponseError()

214 return image

199 215

200 216 def create_variation(self, image: ImageType, model: str = None, **kwargs):

201 217 provider = self.models.get(model, self.provider)

Modified g4f/image.py +4 -0

@@ -172,6 +172,7 @@ def process_image(image: Image, new_width: int, new_height: int) -> Image:

172 172 white = new_image('RGB', image.size, (255, 255, 255))

173 173 white.paste(image, mask=image.split()[-1])

174 174 return white

175 # Convert to RGB for jpg format

175 176 elif image.mode != "RGB":

176 177 image = image.convert("RGB")

177 178 return image

@@ -255,6 +256,9 @@ class ImageResponse:

255 256 def get(self, key: str):

256 257 return self.options.get(key)

257 258

259 def get_list(self) -> list[str]:

260 return [self.images] if isinstance(self.images, str) else self.images

261

258 262 class ImageRequest:

259 263 def __init__(

260 264 self,

Modified g4f/models.py +21 -6

@@ -10,6 +10,7 @@ from .Provider import (

10 10 GeminiProChat,

11 11 ChatgptNext,

12 12 HuggingChat,

13 HuggingFace,

13 14 ChatgptDemo,

14 15 FreeChatgpt,

15 16 GptForLove,

@@ -112,32 +113,32 @@ llama2_13b = Model(

112 113 llama2_70b = Model(

113 114 name = "meta-llama/Llama-2-70b-chat-hf",

114 115 base_provider = "meta",

115 best_provider = RetryProvider([Llama2, DeepInfra, HuggingChat, PerplexityLabs])

116 best_provider = RetryProvider([Llama2, DeepInfra, HuggingChat])

116 117 )

117 118

118 119 codellama_34b_instruct = Model(

119 120 name = "codellama/CodeLlama-34b-Instruct-hf",

120 121 base_provider = "meta",

121 best_provider = RetryProvider([HuggingChat, PerplexityLabs, DeepInfra])

122 best_provider = RetryProvider([HuggingChat, DeepInfra])

122 123 )

123 124

124 125 codellama_70b_instruct = Model(

125 126 name = "codellama/CodeLlama-70b-Instruct-hf",

126 127 base_provider = "meta",

127 best_provider = DeepInfra

128 best_provider = RetryProvider([DeepInfra, PerplexityLabs])

128 129 )

129 130

130 131 # Mistral

131 132 mixtral_8x7b = Model(

132 133 name = "mistralai/Mixtral-8x7B-Instruct-v0.1",

133 134 base_provider = "huggingface",

134 best_provider = RetryProvider([DeepInfra, HuggingChat, PerplexityLabs])

135 best_provider = RetryProvider([DeepInfra, HuggingChat, HuggingFace, PerplexityLabs])

135 136 )

136 137

137 138 mistral_7b = Model(

138 139 name = "mistralai/Mistral-7B-Instruct-v0.1",

139 140 base_provider = "huggingface",

140 best_provider = RetryProvider([DeepInfra, HuggingChat, PerplexityLabs])

141 best_provider = RetryProvider([DeepInfra, HuggingChat, HuggingFace, PerplexityLabs])

141 142 )

142 143

143 144 # Misc models

@@ -184,6 +185,18 @@ claude_v2 = Model(

184 185 best_provider = RetryProvider([FreeChatgpt, Vercel])

185 186 )

186 187

188 claude_3_opus = Model(

189 name = 'claude-3-opus',

190 base_provider = 'anthropic',

191 best_provider = You

192 )

193

194 claude_3_sonnet = Model(

195 name = 'claude-3-sonnet',

196 base_provider = 'anthropic',

197 best_provider = You

198 )

199

187 200 gpt_35_turbo_16k = Model(

188 201 name = 'gpt-3.5-turbo-16k',

189 202 base_provider = 'openai',

@@ -223,7 +236,7 @@ gpt_4_32k_0613 = Model(

223 236 gemini_pro = Model(

224 237 name = 'gemini-pro',

225 238 base_provider = 'google',

226 best_provider = RetryProvider([FreeChatgpt, GeminiProChat])

239 best_provider = RetryProvider([FreeChatgpt, GeminiProChat, You])

227 240 )

228 241

229 242 pi = Model(

@@ -272,6 +285,8 @@ class ModelUtils:

272 285 'gemini': gemini,

273 286 'gemini-pro': gemini_pro,

274 287 'claude-v2': claude_v2,

288 'claude-3-opus': claude_3_opus,

289 'claude-3-sonnet': claude_3_sonnet,

275 290 'pi': pi

276 291 }

277 292

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

@@ -274,7 +274,7 @@ class ProviderModelMixin:

274 274 model = cls.default_model

275 275 elif model in cls.model_aliases:

276 276 model = cls.model_aliases[model]

277 elif model not in cls.get_models():

277 elif model not in cls.get_models() and cls.models:

278 278 raise ModelNotSupportedError(f"Model is not supported: {model} in: {cls.__name__}")

279 279 debug.last_model = model

280 280 return model