diff options
Diffstat (limited to 'g4f')
39 files changed, 2973 insertions, 0 deletions
diff --git a/g4f/Provider/__init__.py b/g4f/Provider/__init__.py index 087c9c8a..515f5912 100644 --- a/g4f/Provider/__init__.py +++ b/g4f/Provider/__init__.py @@ -5,6 +5,7 @@ from ..providers.retry_provider import RetryProvider, IterListProvider from ..providers.base_provider import AsyncProvider, AsyncGeneratorProvider from ..providers.create_images import CreateImagesProvider +from .deprecated import * from .selenium import * from .needs_auth import * diff --git a/g4f/Provider/deprecated/Acytoo.py b/g4f/Provider/deprecated/Acytoo.py new file mode 100644 index 00000000..f75821ce --- /dev/null +++ b/g4f/Provider/deprecated/Acytoo.py @@ -0,0 +1,51 @@ +from __future__ import annotations + +from aiohttp import ClientSession + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider + + +class Acytoo(AsyncGeneratorProvider): + url = 'https://chat.acytoo.com' + working = False + supports_message_history = True + supports_gpt_35_turbo = True + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + async with ClientSession( + headers=_create_header() + ) as session: + async with session.post( + f'{cls.url}/api/completions', + proxy=proxy, + json=_create_payload(messages, **kwargs) + ) as response: + response.raise_for_status() + async for stream in response.content.iter_any(): + if stream: + yield stream.decode() + + +def _create_header(): + return { + 'accept': '*/*', + 'content-type': 'application/json', + } + + +def _create_payload(messages: Messages, temperature: float = 0.5, **kwargs): + return { + 'key' : '', + 'model' : 'gpt-3.5-turbo', + 'messages' : messages, + 'temperature' : temperature, + 'password' : '' + }
\ No newline at end of file diff --git a/g4f/Provider/deprecated/AiAsk.py b/g4f/Provider/deprecated/AiAsk.py new file mode 100644 index 00000000..6ea5f3e0 --- /dev/null +++ b/g4f/Provider/deprecated/AiAsk.py @@ -0,0 +1,46 @@ +from __future__ import annotations + +from aiohttp import ClientSession +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider + +class AiAsk(AsyncGeneratorProvider): + url = "https://e.aiask.me" + supports_message_history = True + supports_gpt_35_turbo = True + working = False + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + headers = { + "accept": "application/json, text/plain, */*", + "origin": cls.url, + "referer": f"{cls.url}/chat", + } + async with ClientSession(headers=headers) as session: + data = { + "continuous": True, + "id": "fRMSQtuHl91A4De9cCvKD", + "list": messages, + "models": "0", + "prompt": "", + "temperature": kwargs.get("temperature", 0.5), + "title": "", + } + buffer = "" + rate_limit = "您的免费额度不够使用这个模型啦，请点击右上角登录继续使用！" + async with session.post(f"{cls.url}/v1/chat/gpt/", json=data, proxy=proxy) as response: + response.raise_for_status() + async for chunk in response.content.iter_any(): + buffer += chunk.decode() + if not rate_limit.startswith(buffer): + yield buffer + buffer = "" + elif buffer == rate_limit: + raise RuntimeError("Rate limit reached")
\ No newline at end of file diff --git a/g4f/Provider/deprecated/AiService.py b/g4f/Provider/deprecated/AiService.py new file mode 100644 index 00000000..acd7f5ea --- /dev/null +++ b/g4f/Provider/deprecated/AiService.py @@ -0,0 +1,39 @@ +from __future__ import annotations + +import requests + +from ...typing import Any, CreateResult, Messages +from ..base_provider import AbstractProvider + + +class AiService(AbstractProvider): + url = "https://aiservice.vercel.app/" + working = False + supports_gpt_35_turbo = True + + @staticmethod + def create_completion( + model: str, + messages: Messages, + stream: bool, + **kwargs: Any, + ) -> CreateResult: + base = ( + "\n".join( + f"{message['role']}: {message['content']}" for message in messages + ) + + "\nassistant: " + ) + headers = { + "accept": "*/*", + "content-type": "text/plain;charset=UTF-8", + "sec-fetch-dest": "empty", + "sec-fetch-mode": "cors", + "sec-fetch-site": "same-origin", + "Referer": "https://aiservice.vercel.app/chat", + } + data = {"input": base} + url = "https://aiservice.vercel.app/api/chat/answer" + response = requests.post(url, headers=headers, json=data) + response.raise_for_status() + yield response.json()["data"] diff --git a/g4f/Provider/deprecated/Aibn.py b/g4f/Provider/deprecated/Aibn.py new file mode 100644 index 00000000..0bbfb436 --- /dev/null +++ b/g4f/Provider/deprecated/Aibn.py @@ -0,0 +1,46 @@ +from __future__ import annotations + +import time +import hashlib + +from ...typing import AsyncResult, Messages +from ...requests import StreamSession +from ..base_provider import AsyncGeneratorProvider + + +class Aibn(AsyncGeneratorProvider): + url = "https://aibn.cc" + working = False + supports_message_history = True + supports_gpt_35_turbo = True + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + timeout: int = 120, + **kwargs + ) -> AsyncResult: + async with StreamSession( + impersonate="chrome107", + proxies={"https": proxy}, + timeout=timeout + ) as session: + timestamp = int(time.time()) + data = { + "messages": messages, + "pass": None, + "sign": generate_signature(timestamp, messages[-1]["content"]), + "time": timestamp + } + async with session.post(f"{cls.url}/api/generate", json=data) as response: + response.raise_for_status() + async for chunk in response.iter_content(): + yield chunk.decode() + + +def generate_signature(timestamp: int, message: str, secret: str = "undefined"): + data = f"{timestamp}:{message}:{secret}" + return hashlib.sha256(data.encode()).hexdigest()
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Aichat.py b/g4f/Provider/deprecated/Aichat.py new file mode 100644 index 00000000..68c9c546 --- /dev/null +++ b/g4f/Provider/deprecated/Aichat.py @@ -0,0 +1,64 @@ +from __future__ import annotations + +from ...typing import Messages +from ..base_provider import AsyncProvider, format_prompt +from ..helper import get_cookies +from ...requests import StreamSession + +class Aichat(AsyncProvider): + url = "https://chat-gpt.org/chat" + working = False + supports_gpt_35_turbo = True + + @staticmethod + async def create_async( + model: str, + messages: Messages, + proxy: str = None, **kwargs) -> str: + + cookies = get_cookies('chat-gpt.org') if not kwargs.get('cookies') else kwargs.get('cookies') + if not cookies: + raise RuntimeError( + "g4f.provider.Aichat requires cookies, [refresh https://chat-gpt.org on chrome]" + ) + + headers = { + 'authority': 'chat-gpt.org', + 'accept': '*/*', + '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', + 'content-type': 'application/json', + 'origin': 'https://chat-gpt.org', + 'referer': 'https://chat-gpt.org/chat', + 'sec-ch-ua': '"Chromium";v="118", "Google Chrome";v="118", "Not=A?Brand";v="99"', + 'sec-ch-ua-mobile': '?0', + 'sec-ch-ua-platform': '"macOS"', + 'sec-fetch-dest': 'empty', + 'sec-fetch-mode': 'cors', + '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/118.0.0.0 Safari/537.36', + } + + async with StreamSession(headers=headers, + cookies=cookies, + timeout=6, + proxies={"https": proxy} if proxy else None, + impersonate="chrome110", verify=False) as session: + + json_data = { + "message": format_prompt(messages), + "temperature": kwargs.get('temperature', 0.5), + "presence_penalty": 0, + "top_p": kwargs.get('top_p', 1), + "frequency_penalty": 0, + } + + async with session.post("https://chat-gpt.org/api/text", + json=json_data) as response: + + response.raise_for_status() + result = await response.json() + + if not result['response']: + raise Exception(f"Error Response: {result}") + + return result["message"] diff --git a/g4f/Provider/deprecated/Ails.py b/g4f/Provider/deprecated/Ails.py new file mode 100644 index 00000000..e87ceb32 --- /dev/null +++ b/g4f/Provider/deprecated/Ails.py @@ -0,0 +1,90 @@ +from __future__ import annotations + +import hashlib +import time +import uuid +import json +from datetime import datetime +from aiohttp import ClientSession + +from ...typing import SHA256, AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider + + +class Ails(AsyncGeneratorProvider): + url = "https://ai.ls" + working = False + supports_message_history = True + supports_gpt_35_turbo = True + + @staticmethod + async def create_async_generator( + model: str, + messages: Messages, + stream: bool, + proxy: str = None, + **kwargs + ) -> AsyncResult: + headers = { + "authority": "api.caipacity.com", + "accept": "*/*", + "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", + "authorization": "Bearer free", + "client-id": str(uuid.uuid4()), + "client-v": "0.1.278", + "content-type": "application/json", + "origin": "https://ai.ls", + "referer": "https://ai.ls/", + "sec-ch-ua": '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"', + "sec-ch-ua-mobile": "?0", + "sec-ch-ua-platform": '"Windows"', + "sec-fetch-dest": "empty", + "sec-fetch-mode": "cors", + "sec-fetch-site": "cross-site", + "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", + "from-url": "https://ai.ls/?chat=1" + } + async with ClientSession( + headers=headers + ) as session: + timestamp = _format_timestamp(int(time.time() * 1000)) + json_data = { + "model": "gpt-3.5-turbo", + "temperature": kwargs.get("temperature", 0.6), + "stream": True, + "messages": messages, + "d": datetime.now().strftime("%Y-%m-%d"), + "t": timestamp, + "s": _hash({"t": timestamp, "m": messages[-1]["content"]}), + } + async with session.post( + "https://api.caipacity.com/v1/chat/completions", + proxy=proxy, + json=json_data + ) as response: + response.raise_for_status() + start = "data: " + async for line in response.content: + line = line.decode('utf-8') + if line.startswith(start) and line != "data: [DONE]": + line = line[len(start):-1] + line = json.loads(line) + token = line["choices"][0]["delta"].get("content") + + if token: + if "ai.ls" in token or "ai.ci" in token: + raise Exception(f"Response Error: {token}") + yield token + + +def _hash(json_data: dict[str, str]) -> SHA256: + base_string: str = f'{json_data["t"]}:{json_data["m"]}:WI,2rU#_r:r~aF4aJ36[.Z(/8Rv93Rf:{len(json_data["m"])}' + + return SHA256(hashlib.sha256(base_string.encode()).hexdigest()) + + +def _format_timestamp(timestamp: int) -> str: + e = timestamp + n = e % 10 + r = n + 1 if n % 2 == 0 else n + return str(e - n + r)
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Aivvm.py b/g4f/Provider/deprecated/Aivvm.py new file mode 100644 index 00000000..c973adf8 --- /dev/null +++ b/g4f/Provider/deprecated/Aivvm.py @@ -0,0 +1,73 @@ +from __future__ import annotations + +import requests +import json + +from ..base_provider import AbstractProvider +from ...typing import CreateResult, Messages + +# to recreate this easily, send a post request to https://chat.aivvm.com/api/models +models = { + 'gpt-3.5-turbo': {'id': 'gpt-3.5-turbo', 'name': 'GPT-3.5'}, + 'gpt-3.5-turbo-0613': {'id': 'gpt-3.5-turbo-0613', 'name': 'GPT-3.5-0613'}, + 'gpt-3.5-turbo-16k': {'id': 'gpt-3.5-turbo-16k', 'name': 'GPT-3.5-16K'}, + 'gpt-3.5-turbo-16k-0613': {'id': 'gpt-3.5-turbo-16k-0613', 'name': 'GPT-3.5-16K-0613'}, + 'gpt-4': {'id': 'gpt-4', 'name': 'GPT-4'}, + 'gpt-4-0613': {'id': 'gpt-4-0613', 'name': 'GPT-4-0613'}, + 'gpt-4-32k': {'id': 'gpt-4-32k', 'name': 'GPT-4-32K'}, + 'gpt-4-32k-0613': {'id': 'gpt-4-32k-0613', 'name': 'GPT-4-32K-0613'}, +} + +class Aivvm(AbstractProvider): + url = 'https://chat.aivvm.com' + supports_stream = True + working = False + supports_gpt_35_turbo = True + supports_gpt_4 = True + + @classmethod + def create_completion(cls, + model: str, + messages: Messages, + stream: bool, + **kwargs + ) -> CreateResult: + if not model: + model = "gpt-3.5-turbo" + elif model not in models: + raise ValueError(f"Model is not supported: {model}") + + json_data = { + "model" : models[model], + "messages" : messages, + "key" : "", + "prompt" : kwargs.get("system_message", "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown."), + "temperature" : kwargs.get("temperature", 0.7) + } + + data = json.dumps(json_data) + + headers = { + "accept" : "text/event-stream", + "accept-language" : "en-US,en;q=0.9", + "content-type" : "application/json", + "content-length" : str(len(data)), + "sec-ch-ua" : "\"Chrome\";v=\"117\", \"Not;A=Brand\";v=\"8\", \"Chromium\";v=\"117\"", + "sec-ch-ua-mobile" : "?0", + "sec-ch-ua-platform": "\"Windows\"", + "sec-fetch-dest" : "empty", + "sec-fetch-mode" : "cors", + "sec-fetch-site" : "same-origin", + "sec-gpc" : "1", + "referrer" : "https://chat.aivvm.com/", + "user-agent" : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36" + } + + response = requests.post("https://chat.aivvm.com/api/chat", headers=headers, data=data, stream=True) + response.raise_for_status() + + for chunk in response.iter_content(chunk_size=4096): + try: + yield chunk.decode("utf-8") + except UnicodeDecodeError: + yield chunk.decode("unicode-escape")
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Berlin.py b/g4f/Provider/deprecated/Berlin.py new file mode 100644 index 00000000..5e81705a --- /dev/null +++ b/g4f/Provider/deprecated/Berlin.py @@ -0,0 +1,78 @@ +from __future__ import annotations + +import secrets +import uuid +import json +from aiohttp import ClientSession + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider +from ..helper import format_prompt + + +class Berlin(AsyncGeneratorProvider): + url = "https://ai.berlin4h.top" + working = False + supports_gpt_35_turbo = True + _token = None + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + if not model: + model = "gpt-3.5-turbo" + headers = { + "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0", + "Accept": "*/*", + "Accept-Language": "de,en-US;q=0.7,en;q=0.3", + "Accept-Encoding": "gzip, deflate, br", + "Referer": f"{cls.url}/", + "Content-Type": "application/json", + "Origin": cls.url, + "Alt-Used": "ai.berlin4h.top", + "Connection": "keep-alive", + "Sec-Fetch-Dest": "empty", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Site": "same-origin", + "Pragma": "no-cache", + "Cache-Control": "no-cache", + "TE": "trailers", + } + async with ClientSession(headers=headers) as session: + if not cls._token: + data = { + "account": '免费使用GPT3.5模型@163.com', + "password": '659e945c2d004686bad1a75b708c962f' + } + async with session.post(f"{cls.url}/api/login", json=data, proxy=proxy) as response: + response.raise_for_status() + cls._token = (await response.json())["data"]["token"] + headers = { + "token": cls._token + } + prompt = format_prompt(messages) + data = { + "prompt": prompt, + "parentMessageId": str(uuid.uuid4()), + "options": { + "model": model, + "temperature": 0, + "presence_penalty": 0, + "frequency_penalty": 0, + "max_tokens": 1888, + **kwargs + }, + } + async with session.post(f"{cls.url}/api/chat/completions", json=data, proxy=proxy, headers=headers) as response: + response.raise_for_status() + async for chunk in response.content: + if chunk.strip(): + try: + yield json.loads(chunk)["content"] + except: + raise RuntimeError(f"Response: {chunk.decode()}") diff --git a/g4f/Provider/deprecated/ChatAnywhere.py b/g4f/Provider/deprecated/ChatAnywhere.py new file mode 100644 index 00000000..d035eaf0 --- /dev/null +++ b/g4f/Provider/deprecated/ChatAnywhere.py @@ -0,0 +1,54 @@ +from __future__ import annotations + +from aiohttp import ClientSession, ClientTimeout + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider + + +class ChatAnywhere(AsyncGeneratorProvider): + url = "https://chatanywhere.cn" + supports_gpt_35_turbo = True + supports_message_history = True + working = False + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + timeout: int = 120, + temperature: float = 0.5, + **kwargs + ) -> AsyncResult: + headers = { + "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0", + "Accept": "application/json, text/plain, */*", + "Accept-Language": "de,en-US;q=0.7,en;q=0.3", + "Accept-Encoding": "gzip, deflate, br", + "Content-Type": "application/json", + "Referer": f"{cls.url}/", + "Origin": cls.url, + "Sec-Fetch-Dest": "empty", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Site": "same-origin", + "Authorization": "", + "Connection": "keep-alive", + "TE": "trailers" + } + async with ClientSession(headers=headers, timeout=ClientTimeout(timeout)) as session: + data = { + "list": messages, + "id": "s1_qYuOLXjI3rEpc7WHfQ", + "title": messages[-1]["content"], + "prompt": "", + "temperature": temperature, + "models": "61490748", + "continuous": True + } + async with session.post(f"{cls.url}/v1/chat/gpt/", json=data, proxy=proxy) as response: + response.raise_for_status() + async for chunk in response.content.iter_any(): + if chunk: + yield chunk.decode()
\ No newline at end of file diff --git a/g4f/Provider/deprecated/ChatgptDuo.py b/g4f/Provider/deprecated/ChatgptDuo.py new file mode 100644 index 00000000..bd9e195d --- /dev/null +++ b/g4f/Provider/deprecated/ChatgptDuo.py @@ -0,0 +1,47 @@ +from __future__ import annotations + +from ...typing import Messages +from ...requests import StreamSession +from ..base_provider import AsyncProvider, format_prompt + + +class ChatgptDuo(AsyncProvider): + url = "https://chatgptduo.com" + supports_gpt_35_turbo = True + working = False + + @classmethod + async def create_async( + cls, + model: str, + messages: Messages, + proxy: str = None, + timeout: int = 120, + **kwargs + ) -> str: + async with StreamSession( + impersonate="chrome107", + proxies={"https": proxy}, + timeout=timeout + ) as session: + prompt = format_prompt(messages), + data = { + "prompt": prompt, + "search": prompt, + "purpose": "ask", + } + response = await session.post(f"{cls.url}/", data=data) + response.raise_for_status() + data = response.json() + + cls._sources = [{ + "title": source["title"], + "url": source["link"], + "snippet": source["snippet"] + } for source in data["results"]] + + return data["answer"] + + @classmethod + def get_sources(cls): + return cls._sources
\ No newline at end of file diff --git a/g4f/Provider/deprecated/CodeLinkAva.py b/g4f/Provider/deprecated/CodeLinkAva.py new file mode 100644 index 00000000..22f4468a --- /dev/null +++ b/g4f/Provider/deprecated/CodeLinkAva.py @@ -0,0 +1,52 @@ +from __future__ import annotations + +from aiohttp import ClientSession +import json + +from ...typing import AsyncGenerator +from ..base_provider import AsyncGeneratorProvider + + +class CodeLinkAva(AsyncGeneratorProvider): + url = "https://ava-ai-ef611.web.app" + supports_gpt_35_turbo = True + working = False + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: list[dict[str, str]], + **kwargs + ) -> AsyncGenerator: + headers = { + "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", + "Accept": "*/*", + "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", + "Origin": cls.url, + "Referer": f"{cls.url}/", + "Sec-Fetch-Dest": "empty", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Site": "same-origin", + } + async with ClientSession( + headers=headers + ) as session: + data = { + "messages": messages, + "temperature": 0.6, + "stream": True, + **kwargs + } + async with session.post("https://ava-alpha-api.codelink.io/api/chat", json=data) as response: + response.raise_for_status() + async for line in response.content: + line = line.decode() + if line.startswith("data: "): + if line.startswith("data: [DONE]"): + break + line = json.loads(line[6:-1]) + + content = line["choices"][0]["delta"].get("content") + if content: + yield content
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Cromicle.py b/g4f/Provider/deprecated/Cromicle.py new file mode 100644 index 00000000..9f986cb5 --- /dev/null +++ b/g4f/Provider/deprecated/Cromicle.py @@ -0,0 +1,50 @@ +from __future__ import annotations + +from aiohttp import ClientSession +from hashlib import sha256 +from ...typing import AsyncResult, Messages, Dict + +from ..base_provider import AsyncGeneratorProvider +from ..helper import format_prompt + + +class Cromicle(AsyncGeneratorProvider): + url: str = 'https://cromicle.top' + working: bool = False + supports_gpt_35_turbo: bool = True + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + async with ClientSession( + headers=_create_header() + ) as session: + async with session.post( + f'{cls.url}/chat', + proxy=proxy, + json=_create_payload(format_prompt(messages)) + ) as response: + response.raise_for_status() + async for stream in response.content.iter_any(): + if stream: + yield stream.decode() + + +def _create_header() -> Dict[str, str]: + return { + 'accept': '*/*', + 'content-type': 'application/json', + } + + +def _create_payload(message: str) -> Dict[str, str]: + return { + 'message': message, + 'token': 'abc', + 'hash': sha256('abc'.encode() + message.encode()).hexdigest() + }
\ No newline at end of file diff --git a/g4f/Provider/deprecated/DfeHub.py b/g4f/Provider/deprecated/DfeHub.py new file mode 100644 index 00000000..e6d13444 --- /dev/null +++ b/g4f/Provider/deprecated/DfeHub.py @@ -0,0 +1,62 @@ +from __future__ import annotations + +import json +import re +import time + +import requests + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider + + +class DfeHub(AbstractProvider): + url = "https://chat.dfehub.com/" + supports_stream = True + supports_gpt_35_turbo = True + + @staticmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + stream: bool, **kwargs: Any) -> CreateResult: + + headers = { + "authority" : "chat.dfehub.com", + "accept" : "*/*", + "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", + "content-type" : "application/json", + "origin" : "https://chat.dfehub.com", + "referer" : "https://chat.dfehub.com/", + "sec-ch-ua" : '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"', + "sec-ch-ua-mobile" : "?0", + "sec-ch-ua-platform": '"macOS"', + "sec-fetch-dest" : "empty", + "sec-fetch-mode" : "cors", + "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/114.0.0.0 Safari/537.36", + "x-requested-with" : "XMLHttpRequest", + } + + json_data = { + "messages" : messages, + "model" : "gpt-3.5-turbo", + "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), + "stream" : True + } + + 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: + delay = re.findall(r"\d+\.\d+", chunk.decode()) + delay = float(delay[-1]) + time.sleep(delay) + yield from DfeHub.create_completion(model, messages, stream, **kwargs) + if b"content" in chunk: + data = json.loads(chunk.decode().split("data: ")[1]) + yield (data["choices"][0]["delta"]["content"]) diff --git a/g4f/Provider/deprecated/EasyChat.py b/g4f/Provider/deprecated/EasyChat.py new file mode 100644 index 00000000..7a00f523 --- /dev/null +++ b/g4f/Provider/deprecated/EasyChat.py @@ -0,0 +1,89 @@ +from __future__ import annotations + +import json +import random +import requests + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider + + +class EasyChat(AbstractProvider): + url: str = "https://free.easychat.work" + supports_stream = True + supports_gpt_35_turbo = True + working = False + + @staticmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + stream: bool, **kwargs: Any) -> CreateResult: + + active_servers = [ + "https://chat10.fastgpt.me", + "https://chat9.fastgpt.me", + "https://chat1.fastgpt.me", + "https://chat2.fastgpt.me", + "https://chat3.fastgpt.me", + "https://chat4.fastgpt.me", + "https://gxos1h1ddt.fastgpt.me" + ] + + server = active_servers[kwargs.get("active_server", random.randint(0, 5))] + headers = { + "authority" : f"{server}".replace("https://", ""), + "accept" : "text/event-stream", + "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,fa=0.2", + "content-type" : "application/json", + "origin" : f"{server}", + "referer" : f"{server}/", + "x-requested-with" : "XMLHttpRequest", + 'plugins' : '0', + 'sec-ch-ua' : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"', + 'sec-ch-ua-mobile' : '?0', + 'sec-ch-ua-platform': '"Windows"', + 'sec-fetch-dest' : 'empty', + 'sec-fetch-mode' : 'cors', + 'sec-fetch-site' : 'same-origin', + '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', + 'usesearch' : 'false', + 'x-requested-with' : 'XMLHttpRequest' + } + + json_data = { + "messages" : messages, + "stream" : stream, + "model" : model, + "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) + } + + 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) + + if response.status_code != 200: + raise Exception(f"Error {response.status_code} from server : {response.reason}") + if not stream: + 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"]
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Equing.py b/g4f/Provider/deprecated/Equing.py new file mode 100644 index 00000000..5fd9797b --- /dev/null +++ b/g4f/Provider/deprecated/Equing.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +import json +from abc import ABC, abstractmethod + +import requests + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider + + +class Equing(AbstractProvider): + url: str = 'https://next.eqing.tech/' + working = False + supports_stream = True + supports_gpt_35_turbo = True + supports_gpt_4 = False + + @staticmethod + @abstractmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + stream: bool, **kwargs: Any) -> CreateResult: + + headers = { + 'authority' : 'next.eqing.tech', + 'accept' : 'text/event-stream', + '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', + 'origin' : 'https://next.eqing.tech', + 'plugins' : '0', + 'pragma' : 'no-cache', + 'referer' : 'https://next.eqing.tech/', + 'sec-ch-ua' : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"', + 'sec-ch-ua-mobile' : '?0', + 'sec-ch-ua-platform': '"macOS"', + 'sec-fetch-dest' : 'empty', + 'sec-fetch-mode' : 'cors', + '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' + } + + json_data = { + 'messages' : messages, + 'stream' : stream, + 'model' : model, + '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), + } + + 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 + + for line in response.iter_content(chunk_size=1024): + if line: + if b'content' in line: + line_json = json.loads(line.decode('utf-8').split('data: ')[1]) + + token = line_json['choices'][0]['delta'].get('content') + if token: + yield token
\ No newline at end of file diff --git a/g4f/Provider/deprecated/FakeGpt.py b/g4f/Provider/deprecated/FakeGpt.py new file mode 100644 index 00000000..99b6bb1a --- /dev/null +++ b/g4f/Provider/deprecated/FakeGpt.py @@ -0,0 +1,91 @@ +from __future__ import annotations + +import uuid, time, random, json +from aiohttp import ClientSession + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider +from ..helper import format_prompt, get_random_string + + +class FakeGpt(AsyncGeneratorProvider): + url = "https://chat-shared2.zhile.io" + supports_gpt_35_turbo = True + working = False + _access_token = None + _cookie_jar = None + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + headers = { + "Accept-Language": "en-US", + "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36", + "Referer": "https://chat-shared2.zhile.io/?v=2", + "sec-ch-ua": '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"', + "sec-ch-ua-platform": '"Linux"', + "sec-ch-ua-mobile": "?0", + } + async with ClientSession(headers=headers, cookie_jar=cls._cookie_jar) as session: + if not cls._access_token: + async with session.get(f"{cls.url}/api/loads", params={"t": int(time.time())}, proxy=proxy) as response: + response.raise_for_status() + list = (await response.json())["loads"] + token_ids = [t["token_id"] for t in list] + data = { + "token_key": random.choice(token_ids), + "session_password": get_random_string() + } + async with session.post(f"{cls.url}/auth/login", data=data, proxy=proxy) as response: + response.raise_for_status() + async with session.get(f"{cls.url}/api/auth/session", proxy=proxy) as response: + response.raise_for_status() + cls._access_token = (await response.json())["accessToken"] + cls._cookie_jar = session.cookie_jar + headers = { + "Content-Type": "application/json", + "Accept": "text/event-stream", + "X-Authorization": f"Bearer {cls._access_token}", + } + prompt = format_prompt(messages) + data = { + "action": "next", + "messages": [ + { + "id": str(uuid.uuid4()), + "author": {"role": "user"}, + "content": {"content_type": "text", "parts": [prompt]}, + "metadata": {}, + } + ], + "parent_message_id": str(uuid.uuid4()), + "model": "text-davinci-002-render-sha", + "plugin_ids": [], + "timezone_offset_min": -120, + "suggestions": [], + "history_and_training_disabled": True, + "arkose_token": "", + "force_paragen": False, + } + last_message = "" + async with session.post(f"{cls.url}/api/conversation", json=data, headers=headers, proxy=proxy) as response: + async for line in response.content: + if line.startswith(b"data: "): + line = line[6:] + if line == b"[DONE]": + break + try: + line = json.loads(line) + if line["message"]["metadata"]["message_type"] == "next": + new_message = line["message"]["content"]["parts"][0] + yield new_message[len(last_message):] + last_message = new_message + except: + continue + if not last_message: + raise RuntimeError("No valid response")
\ No newline at end of file diff --git a/g4f/Provider/deprecated/FastGpt.py b/g4f/Provider/deprecated/FastGpt.py new file mode 100644 index 00000000..6a79d9aa --- /dev/null +++ b/g4f/Provider/deprecated/FastGpt.py @@ -0,0 +1,76 @@ +from __future__ import annotations + +import json +import random +import requests + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider + + +class FastGpt(AbstractProvider): + url: str = 'https://chat9.fastgpt.me/' + working = False + needs_auth = False + supports_stream = True + supports_gpt_35_turbo = True + supports_gpt_4 = False + + @staticmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + stream: bool, **kwargs: Any) -> CreateResult: + + headers = { + 'authority' : 'chat9.fastgpt.me', + 'accept' : 'text/event-stream', + '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', + 'origin' : 'https://chat9.fastgpt.me', + 'plugins' : '0', + 'pragma' : 'no-cache', + 'referer' : 'https://chat9.fastgpt.me/', + 'sec-ch-ua' : '"Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"', + 'sec-ch-ua-mobile' : '?0', + 'sec-ch-ua-platform': '"macOS"', + 'sec-fetch-dest' : 'empty', + 'sec-fetch-mode' : 'cors', + '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', + } + + json_data = { + 'messages' : messages, + 'stream' : stream, + 'model' : model, + '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), + } + + subdomain = random.choice([ + 'jdaen979ew', + 'chat9' + ]) + + response = requests.post(f'https://{subdomain}.fastgpt.me/api/openai/v1/chat/completions', + headers=headers, json=json_data, stream=stream) + + for line in response.iter_lines(): + if line: + try: + if b'content' in line: + line_json = json.loads(line.decode('utf-8').split('data: ')[1]) + token = line_json['choices'][0]['delta'].get( + 'content' + ) + + if token: + yield token + except: + continue
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Forefront.py b/g4f/Provider/deprecated/Forefront.py new file mode 100644 index 00000000..39654b2c --- /dev/null +++ b/g4f/Provider/deprecated/Forefront.py @@ -0,0 +1,40 @@ +from __future__ import annotations + +import json + +import requests + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider + + +class Forefront(AbstractProvider): + url = "https://forefront.com" + supports_stream = True + supports_gpt_35_turbo = True + + @staticmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + stream: bool, **kwargs: Any) -> CreateResult: + + json_data = { + "text" : messages[-1]["content"], + "action" : "noauth", + "id" : "", + "parentId" : "", + "workspaceId" : "", + "messagePersona": "607e41fe-95be-497e-8e97-010a59b2e2c0", + "model" : "gpt-4", + "messages" : messages[:-1] if len(messages) > 1 else [], + "internetMode" : "auto", + } + + 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: + yield json.loads(token.decode().split("data: ")[1])["delta"] diff --git a/g4f/Provider/deprecated/GPTalk.py b/g4f/Provider/deprecated/GPTalk.py new file mode 100644 index 00000000..5b36d37b --- /dev/null +++ b/g4f/Provider/deprecated/GPTalk.py @@ -0,0 +1,87 @@ +from __future__ import annotations + +import secrets, time, json +from aiohttp import ClientSession + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider +from ..helper import format_prompt + + +class GPTalk(AsyncGeneratorProvider): + url = "https://gptalk.net" + working = False + supports_gpt_35_turbo = True + _auth = None + used_times = 0 + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + if not model: + model = "gpt-3.5-turbo" + timestamp = int(time.time()) + headers = { + 'authority': 'gptalk.net', + 'accept': '*/*', + 'accept-language': 'de-DE,de;q=0.9,en-DE;q=0.8,en;q=0.7,en-US;q=0.6,nl;q=0.5,zh-CN;q=0.4,zh-TW;q=0.3,zh;q=0.2', + 'content-type': 'application/json', + 'origin': 'https://gptalk.net', + 'sec-ch-ua': '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"', + 'sec-ch-ua-mobile': '?0', + 'sec-ch-ua-platform': '"Linux"', + 'sec-fetch-dest': 'empty', + 'sec-fetch-mode': 'cors', + 'sec-fetch-site': 'same-origin', + 'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36', + 'x-auth-appid': '2229', + 'x-auth-openid': '', + 'x-auth-platform': '', + 'x-auth-timestamp': f"{timestamp}", + } + async with ClientSession(headers=headers) as session: + if not cls._auth or cls._auth["expires_at"] < timestamp or cls.used_times == 5: + data = { + "fingerprint": secrets.token_hex(16).zfill(32), + "platform": "fingerprint" + } + async with session.post(f"{cls.url}/api/chatgpt/user/login", json=data, proxy=proxy) as response: + response.raise_for_status() + cls._auth = (await response.json())["data"] + cls.used_times = 0 + data = { + "content": format_prompt(messages), + "accept": "stream", + "from": 1, + "model": model, + "is_mobile": 0, + "user_agent": headers["user-agent"], + "is_open_ctx": 0, + "prompt": "", + "roid": 111, + "temperature": 0, + "ctx_msg_count": 3, + "created_at": timestamp + } + headers = { + 'authorization': f'Bearer {cls._auth["token"]}', + } + async with session.post(f"{cls.url}/api/chatgpt/chatapi/text", json=data, headers=headers, proxy=proxy) as response: + response.raise_for_status() + token = (await response.json())["data"]["token"] + cls.used_times += 1 + last_message = "" + async with session.get(f"{cls.url}/api/chatgpt/chatapi/stream", params={"token": token}, proxy=proxy) as response: + response.raise_for_status() + async for line in response.content: + if line.startswith(b"data: "): + if line.startswith(b"data: [DONE]"): + break + message = json.loads(line[6:-1])["content"] + yield message[len(last_message):] + last_message = message diff --git a/g4f/Provider/deprecated/GeekGpt.py b/g4f/Provider/deprecated/GeekGpt.py new file mode 100644 index 00000000..7a460083 --- /dev/null +++ b/g4f/Provider/deprecated/GeekGpt.py @@ -0,0 +1,73 @@ +from __future__ import annotations +import requests, json + +from ..base_provider import AbstractProvider +from ...typing import CreateResult, Messages +from json import dumps + + +class GeekGpt(AbstractProvider): + url = 'https://chat.geekgpt.org' + working = False + supports_message_history = True + supports_stream = True + supports_gpt_35_turbo = True + supports_gpt_4 = True + + @classmethod + def create_completion( + cls, + model: str, + messages: Messages, + stream: bool, + **kwargs + ) -> CreateResult: + if not model: + model = "gpt-3.5-turbo" + json_data = { + 'messages': messages, + 'model': model, + 'temperature': kwargs.get('temperature', 0.9), + 'presence_penalty': kwargs.get('presence_penalty', 0), + 'top_p': kwargs.get('top_p', 1), + 'frequency_penalty': kwargs.get('frequency_penalty', 0), + 'stream': True + } + + data = dumps(json_data, separators=(',', ':')) + + headers = { + 'authority': 'ai.fakeopen.com', + 'accept': '*/*', + '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', + 'authorization': 'Bearer pk-this-is-a-real-free-pool-token-for-everyone', + 'content-type': 'application/json', + 'origin': 'https://chat.geekgpt.org', + 'referer': 'https://chat.geekgpt.org/', + 'sec-ch-ua': '"Chromium";v="118", "Google Chrome";v="118", "Not=A?Brand";v="99"', + 'sec-ch-ua-mobile': '?0', + 'sec-ch-ua-platform': '"macOS"', + 'sec-fetch-dest': 'empty', + 'sec-fetch-mode': 'cors', + 'sec-fetch-site': 'cross-site', + 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36', + } + + response = requests.post("https://ai.fakeopen.com/v1/chat/completions", + headers=headers, data=data, stream=True) + response.raise_for_status() + + for chunk in response.iter_lines(): + if b'content' in chunk: + json_data = chunk.decode().replace("data: ", "") + + if json_data == "[DONE]": + break + + try: + content = json.loads(json_data)["choices"][0]["delta"].get("content") + except Exception as e: + raise RuntimeError(f'error | {e} :', json_data) + + if content: + yield content
\ No newline at end of file diff --git a/g4f/Provider/deprecated/GetGpt.py b/g4f/Provider/deprecated/GetGpt.py new file mode 100644 index 00000000..dd586569 --- /dev/null +++ b/g4f/Provider/deprecated/GetGpt.py @@ -0,0 +1,77 @@ +from __future__ import annotations + +import json +import os +import uuid + +import requests +# try: +# from Crypto.Cipher import AES +# except ImportError: +# from Cryptodome.Cipher import AES + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider + + +class GetGpt(AbstractProvider): + url = 'https://chat.getgpt.world/' + supports_stream = True + working = False + supports_gpt_35_turbo = True + + @staticmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + 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', + } + + 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()) + } + ) + + 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']) + + +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') + + # 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 + + +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 + return
\ No newline at end of file diff --git a/g4f/Provider/deprecated/H2o.py b/g4f/Provider/deprecated/H2o.py new file mode 100644 index 00000000..ba4ca507 --- /dev/null +++ b/g4f/Provider/deprecated/H2o.py @@ -0,0 +1,89 @@ +from __future__ import annotations + +import json +import uuid + +from aiohttp import ClientSession + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider, format_prompt + + +class H2o(AsyncGeneratorProvider): + url = "https://gpt-gm.h2o.ai" + model = "h2oai/h2ogpt-gm-oasst1-en-2048-falcon-40b-v1" + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + model = model if model else cls.model + headers = {"Referer": f"{cls.url}/"} + + async with ClientSession( + headers=headers + ) as session: + data = { + "ethicsModalAccepted": "true", + "shareConversationsWithModelAuthors": "true", + "ethicsModalAcceptedAt": "", + "activeModel": model, + "searchEnabled": "true", + } + async with session.post( + f"{cls.url}/settings", + proxy=proxy, + data=data + ) as response: + response.raise_for_status() + + async with session.post( + f"{cls.url}/conversation", + proxy=proxy, + json={"model": model}, + ) as response: + response.raise_for_status() + conversationId = (await response.json())["conversationId"] + + data = { + "inputs": format_prompt(messages), + "parameters": { + "temperature": 0.4, + "truncate": 2048, + "max_new_tokens": 1024, + "do_sample": True, + "repetition_penalty": 1.2, + "return_full_text": False, + **kwargs + }, + "stream": True, + "options": { + "id": str(uuid.uuid4()), + "response_id": str(uuid.uuid4()), + "is_retry": False, + "use_cache": False, + "web_search_id": "", + }, + } + async with session.post( + f"{cls.url}/conversation/{conversationId}", + proxy=proxy, + json=data + ) as response: + start = "data:" + async for line in response.content: + line = line.decode("utf-8") + if line and line.startswith(start): + line = json.loads(line[len(start):-1]) + if not line["token"]["special"]: + yield line["token"]["text"] + + async with session.delete( + f"{cls.url}/conversation/{conversationId}", + proxy=proxy, + ) as response: + response.raise_for_status()
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Hashnode.py b/g4f/Provider/deprecated/Hashnode.py new file mode 100644 index 00000000..c2c0ffb7 --- /dev/null +++ b/g4f/Provider/deprecated/Hashnode.py @@ -0,0 +1,80 @@ +from __future__ import annotations + +from aiohttp import ClientSession + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider +from ..helper import get_random_hex + +class SearchTypes(): + quick = "quick" + code = "code" + websearch = "websearch" + +class Hashnode(AsyncGeneratorProvider): + url = "https://hashnode.com" + working = False + supports_message_history = True + supports_gpt_35_turbo = True + _sources = [] + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + search_type: str = SearchTypes.websearch, + proxy: str = None, + **kwargs + ) -> AsyncResult: + headers = { + "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/118.0", + "Accept": "*/*", + "Accept-Language": "de,en-US;q=0.7,en;q=0.3", + "Accept-Encoding": "gzip, deflate, br", + "Referer": f"{cls.url}/rix", + "Content-Type": "application/json", + "Origin": cls.url, + "Connection": "keep-alive", + "Sec-Fetch-Dest": "empty", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Site": "same-origin", + "Pragma": "no-cache", + "Cache-Control": "no-cache", + "TE": "trailers", + } + async with ClientSession(headers=headers) as session: + prompt = messages[-1]["content"] + cls._sources = [] + if search_type == "websearch": + async with session.post( + f"{cls.url}/api/ai/rix/search", + json={"prompt": prompt}, + proxy=proxy, + ) as response: + response.raise_for_status() + cls._sources = (await response.json())["result"] + data = { + "chatId": get_random_hex(), + "history": messages, + "prompt": prompt, + "searchType": search_type, + "urlToScan": None, + "searchResults": cls._sources, + } + async with session.post( + f"{cls.url}/api/ai/rix/completion", + json=data, + proxy=proxy, + ) as response: + response.raise_for_status() + async for chunk in response.content.iter_any(): + if chunk: + yield chunk.decode() + + @classmethod + def get_sources(cls) -> list: + return [{ + "title": source["name"], + "url": source["url"] + } for source in cls._sources]
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Lockchat.py b/g4f/Provider/deprecated/Lockchat.py new file mode 100644 index 00000000..edab0bd4 --- /dev/null +++ b/g4f/Provider/deprecated/Lockchat.py @@ -0,0 +1,54 @@ +from __future__ import annotations + +import json + +import requests + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider + + +class Lockchat(AbstractProvider): + url: str = "http://supertest.lockchat.app" + supports_stream = True + supports_gpt_35_turbo = True + supports_gpt_4 = True + + @staticmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + stream: bool, **kwargs: Any) -> CreateResult: + + temperature = float(kwargs.get("temperature", 0.7)) + payload = { + "temperature": temperature, + "messages" : messages, + "model" : model, + "stream" : True, + } + + 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.raise_for_status() + for token in response.iter_lines(): + if b"The model: `gpt-4` does not exist" in token: + print("error, retrying...") + + Lockchat.create_completion( + model = model, + messages = messages, + stream = stream, + temperature = temperature, + **kwargs) + + if b"content" in token: + token = json.loads(token.decode("utf-8").split("data: ")[1]) + token = token["choices"][0]["delta"].get("content") + + if token: + yield (token)
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Myshell.py b/g4f/Provider/deprecated/Myshell.py new file mode 100644 index 00000000..2487440d --- /dev/null +++ b/g4f/Provider/deprecated/Myshell.py @@ -0,0 +1,165 @@ +# not using WS anymore + +from __future__ import annotations + +import json, uuid, hashlib, time, random + +from aiohttp import ClientSession +from aiohttp.http import WSMsgType +import asyncio + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider, format_prompt + + +models = { + "samantha": "1e3be7fe89e94a809408b1154a2ee3e1", + "gpt-3.5-turbo": "8077335db7cd47e29f7de486612cc7fd", + "gpt-4": "01c8de4fbfc548df903712b0922a4e01", +} + + +class Myshell(AsyncGeneratorProvider): + url = "https://app.myshell.ai/chat" + working = False + supports_gpt_35_turbo = True + supports_gpt_4 = True + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + timeout: int = 90, + **kwargs + ) -> AsyncResult: + if not model: + bot_id = models["samantha"] + elif model in models: + bot_id = models[model] + else: + raise ValueError(f"Model are not supported: {model}") + + 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' + visitor_id = generate_visitor_id(user_agent) + + async with ClientSession( + headers={'User-Agent': user_agent} + ) as session: + async with session.ws_connect( + "wss://api.myshell.ai/ws/?EIO=4&transport=websocket", + autoping=False, + timeout=timeout, + proxy=proxy + ) as wss: + # Send and receive hello message + await wss.receive_str() + message = json.dumps({"token": None, "visitorId": visitor_id}) + await wss.send_str(f"40/chat,{message}") + await wss.receive_str() + + # Fix "need_verify_captcha" issue + await asyncio.sleep(5) + + # Create chat message + text = format_prompt(messages) + chat_data = json.dumps(["text_chat",{ + "reqId": str(uuid.uuid4()), + "botUid": bot_id, + "sourceFrom": "myshellWebsite", + "text": text, + **generate_signature(text) + }]) + + # Send chat message + chat_start = "42/chat," + chat_message = f"{chat_start}{chat_data}" + await wss.send_str(chat_message) + + # Receive messages + async for message in wss: + if message.type != WSMsgType.TEXT: + continue + # Ping back + if message.data == "2": + await wss.send_str("3") + continue + # Is not chat message + if not message.data.startswith(chat_start): + continue + data_type, data = json.loads(message.data[len(chat_start):]) + if data_type == "text_stream": + if data["data"]["text"]: + yield data["data"]["text"] + elif data["data"]["isFinal"]: + break + elif data_type in ("message_replied", "need_verify_captcha"): + raise RuntimeError(f"Received unexpected message: {data_type}") + + +def generate_timestamp() -> str: + return str( + int( + str(int(time.time() * 1000))[:-1] + + str( + sum( + 2 * int(digit) + if idx % 2 == 0 + else 3 * int(digit) + for idx, digit in enumerate(str(int(time.time() * 1000))[:-1]) + ) + % 10 + ) + ) + ) + +def generate_signature(text: str): + timestamp = generate_timestamp() + version = 'v1.0.0' + secret = '8@VXGK3kKHr!u2gA' + data = f"{version}#{text}#{timestamp}#{secret}" + signature = hashlib.md5(data.encode()).hexdigest() + signature = signature[::-1] + return { + "signature": signature, + "timestamp": timestamp, + "version": version + } + +def xor_hash(B: str): + r = [] + i = 0 + + def o(e, t): + o_val = 0 + for i in range(len(t)): + o_val |= r[i] << (8 * i) + return e ^ o_val + + for e in range(len(B)): + t = ord(B[e]) + r.insert(0, 255 & t) + + if len(r) >= 4: + i = o(i, r) + r = [] + + if len(r) > 0: + i = o(i, r) + + return hex(i)[2:] + +def performance() -> str: + t = int(time.time() * 1000) + e = 0 + while t == int(time.time() * 1000): + e += 1 + return hex(t)[2:] + hex(e)[2:] + +def generate_visitor_id(user_agent: str) -> str: + f = performance() + r = hex(int(random.random() * (16**16)))[2:-2] + d = xor_hash(user_agent) + e = hex(1080 * 1920)[2:] + return f"{f}-{r}-{d}-{e}-{f}"
\ No newline at end of file diff --git a/g4f/Provider/deprecated/NoowAi.py b/g4f/Provider/deprecated/NoowAi.py new file mode 100644 index 00000000..dba87273 --- /dev/null +++ b/g4f/Provider/deprecated/NoowAi.py @@ -0,0 +1,66 @@ +from __future__ import annotations + +import json +from aiohttp import ClientSession + +from ..typing import AsyncResult, Messages +from .base_provider import AsyncGeneratorProvider +from .helper import get_random_string + +class NoowAi(AsyncGeneratorProvider): + url = "https://noowai.com" + supports_message_history = True + supports_gpt_35_turbo = True + working = False + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + headers = { + "User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/118.0", + "Accept": "*/*", + "Accept-Language": "de,en-US;q=0.7,en;q=0.3", + "Accept-Encoding": "gzip, deflate, br", + "Referer": f"{cls.url}/", + "Content-Type": "application/json", + "Origin": cls.url, + "Alt-Used": "noowai.com", + "Connection": "keep-alive", + "Sec-Fetch-Dest": "empty", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Site": "same-origin", + "Pragma": "no-cache", + "Cache-Control": "no-cache", + "TE": "trailers" + } + async with ClientSession(headers=headers) as session: + data = { + "botId": "default", + "customId": "d49bc3670c3d858458576d75c8ea0f5d", + "session": "N/A", + "chatId": get_random_string(), + "contextId": 25, + "messages": messages, + "newMessage": messages[-1]["content"], + "stream": True + } + async with session.post(f"{cls.url}/wp-json/mwai-ui/v1/chats/submit", json=data, proxy=proxy) as response: + response.raise_for_status() + async for line in response.content: + if line.startswith(b"data: "): + try: + line = json.loads(line[6:]) + assert "type" in line + except: + raise RuntimeError(f"Broken line: {line.decode()}") + if line["type"] == "live": + yield line["data"] + elif line["type"] == "end": + break + elif line["type"] == "error": + raise RuntimeError(line["data"])
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Opchatgpts.py b/g4f/Provider/deprecated/Opchatgpts.py new file mode 100644 index 00000000..94b1d099 --- /dev/null +++ b/g4f/Provider/deprecated/Opchatgpts.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +import random, string, json +from aiohttp import ClientSession + +from ...typing import Messages, AsyncResult +from ..base_provider import AsyncGeneratorProvider +from ..helper import get_random_string + +class Opchatgpts(AsyncGeneratorProvider): + url = "https://opchatgpts.net" + working = False + supports_message_history = True + supports_gpt_35_turbo = True + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, **kwargs) -> AsyncResult: + + headers = { + "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", + "Accept" : "*/*", + "Accept-Language" : "de,en-US;q=0.7,en;q=0.3", + "Origin" : cls.url, + "Alt-Used" : "opchatgpts.net", + "Referer" : f"{cls.url}/chatgpt-free-use/", + "Sec-Fetch-Dest" : "empty", + "Sec-Fetch-Mode" : "cors", + "Sec-Fetch-Site" : "same-origin", + } + async with ClientSession( + headers=headers + ) as session: + data = { + "botId": "default", + "chatId": get_random_string(), + "contextId": 28, + "customId": None, + "messages": messages, + "newMessage": messages[-1]["content"], + "session": "N/A", + "stream": True + } + async with session.post(f"{cls.url}/wp-json/mwai-ui/v1/chats/submit", json=data, proxy=proxy) as response: + response.raise_for_status() + async for line in response.content: + if line.startswith(b"data: "): + try: + line = json.loads(line[6:]) + assert "type" in line + except: + raise RuntimeError(f"Broken line: {line.decode()}") + if line["type"] == "live": + yield line["data"] + elif line["type"] == "end": + break
\ No newline at end of file diff --git a/g4f/Provider/deprecated/OpenAssistant.py b/g4f/Provider/deprecated/OpenAssistant.py new file mode 100644 index 00000000..80cae3c2 --- /dev/null +++ b/g4f/Provider/deprecated/OpenAssistant.py @@ -0,0 +1,88 @@ +from __future__ import annotations + +import json + +from aiohttp import ClientSession + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider +from ..helper import format_prompt, get_cookies + +class OpenAssistant(AsyncGeneratorProvider): + url = "https://open-assistant.io/chat" + needs_auth = True + working = False + model = "OA_SFT_Llama_30B_6" + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + cookies: dict = None, + **kwargs + ) -> AsyncResult: + if not cookies: + cookies = get_cookies("open-assistant.io") + + headers = { + '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', + } + async with ClientSession( + cookies=cookies, + headers=headers + ) as session: + async with session.post("https://open-assistant.io/api/chat", proxy=proxy) as response: + chat_id = (await response.json())["id"] + + data = { + "chat_id": chat_id, + "content": f"<s>[INST]\n{format_prompt(messages)}\n[/INST]", + "parent_id": None + } + async with session.post("https://open-assistant.io/api/chat/prompter_message", proxy=proxy, json=data) as response: + parent_id = (await response.json())["id"] + + data = { + "chat_id": chat_id, + "parent_id": parent_id, + "model_config_name": model if model else cls.model, + "sampling_parameters":{ + "top_k": 50, + "top_p": None, + "typical_p": None, + "temperature": 0.35, + "repetition_penalty": 1.1111111111111112, + "max_new_tokens": 1024, + **kwargs + }, + "plugins":[] + } + async with session.post("https://open-assistant.io/api/chat/assistant_message", proxy=proxy, json=data) as response: + data = await response.json() + if "id" in data: + message_id = data["id"] + elif "message" in data: + raise RuntimeError(data["message"]) + else: + response.raise_for_status() + + params = { + 'chat_id': chat_id, + 'message_id': message_id, + } + async with session.post("https://open-assistant.io/api/chat/events", proxy=proxy, params=params) as response: + start = "data: " + async for line in response.content: + line = line.decode("utf-8") + if line and line.startswith(start): + line = json.loads(line[len(start):]) + if line["event_type"] == "token": + yield line["text"] + + params = { + 'chat_id': chat_id, + } + async with session.delete("https://open-assistant.io/api/chat", proxy=proxy, params=params) as response: + response.raise_for_status() diff --git a/g4f/Provider/deprecated/Phind.py b/g4f/Provider/deprecated/Phind.py new file mode 100644 index 00000000..c72bf09e --- /dev/null +++ b/g4f/Provider/deprecated/Phind.py @@ -0,0 +1,140 @@ +from __future__ import annotations + +import re +import json +from urllib import parse +from datetime import datetime + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider +from ...requests import StreamSession + +class Phind(AsyncGeneratorProvider): + url = "https://www.phind.com" + working = False + lockdown = True + supports_stream = True + supports_message_history = True + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + timeout: int = 120, + creative_mode: bool = False, + **kwargs + ) -> AsyncResult: + headers = { + "Accept": "*/*", + "Origin": cls.url, + "Referer": f"{cls.url}/search", + "Sec-Fetch-Dest": "empty", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Site": "same-origin", + } + async with StreamSession( + headers=headers, + impersonate="chrome", + proxies={"https": proxy}, + timeout=timeout + ) as session: + url = "https://www.phind.com/search?home=true" + async with session.get(url) as response: + text = await response.text() + match = re.search(r'<script id="__NEXT_DATA__" type="application/json">(?P<json>[\S\s]+?)</script>', text) + data = json.loads(match.group("json")) + challenge_seeds = data["props"]["pageProps"]["challengeSeeds"] + + prompt = messages[-1]["content"] + data = { + "question": prompt, + "question_history": [ + message["content"] for message in messages[:-1] if message["role"] == "user" + ], + "answer_history": [ + message["content"] for message in messages if message["role"] == "assistant" + ], + "webResults": [], + "options": { + "date": datetime.now().strftime("%d.%m.%Y"), + "language": "en-US", + "detailed": True, + "anonUserId": "", + "answerModel": "GPT-4" if model.startswith("gpt-4") else "Phind-34B", + "creativeMode": creative_mode, + "customLinks": [] + }, + "context": "\n".join([message["content"] for message in messages if message["role"] == "system"]), + } + data["challenge"] = generate_challenge(data, **challenge_seeds) + async with session.post(f"https://https.api.phind.com/infer/", headers=headers, json=data) as response: + new_line = False + async for line in response.iter_lines(): + if line.startswith(b"data: "): + chunk = line[6:] + if chunk.startswith(b'<PHIND_DONE/>'): + break + if chunk.startswith(b'<PHIND_BACKEND_ERROR>'): + raise RuntimeError(f"Response: {chunk.decode()}") + if chunk.startswith(b'<PHIND_WEBRESULTS>') or chunk.startswith(b'<PHIND_FOLLOWUP>'): + pass + elif chunk.startswith(b"<PHIND_METADATA>") or chunk.startswith(b"<PHIND_INDICATOR>"): + pass + elif chunk.startswith(b"<PHIND_SPAN_BEGIN>") or chunk.startswith(b"<PHIND_SPAN_END>"): + pass + elif chunk: + yield chunk.decode() + elif new_line: + yield "\n" + new_line = False + else: + new_line = True + +def deterministic_stringify(obj): + def handle_value(value): + if isinstance(value, (dict, list)): + if isinstance(value, list): + return '[' + ','.join(sorted(map(handle_value, value))) + ']' + else: # It's a dict + return '{' + deterministic_stringify(value) + '}' + elif isinstance(value, bool): + return 'true' if value else 'false' + elif isinstance(value, (int, float)): + return format(value, '.8f').rstrip('0').rstrip('.') + elif isinstance(value, str): + return f'"{value}"' + else: + return 'null' + + items = sorted(obj.items(), key=lambda x: x[0]) + return ','.join([f'{k}:{handle_value(v)}' for k, v in items if handle_value(v) is not None]) + +def prng_general(seed, multiplier, addend, modulus): + a = seed * multiplier + addend + if a < 0: + return ((a%modulus)-modulus)/modulus + else: + return a%modulus/modulus + +def generate_challenge_seed(l): + I = deterministic_stringify(l) + d = parse.quote(I, safe='') + return simple_hash(d) + +def simple_hash(s): + d = 0 + for char in s: + if len(char) > 1 or ord(char) >= 256: + continue + d = ((d << 5) - d + ord(char[0])) & 0xFFFFFFFF + if d > 0x7FFFFFFF: # 2147483647 + d -= 0x100000000 # Subtract 2**32 + return d + +def generate_challenge(obj, **kwargs): + return prng_general( + seed=generate_challenge_seed(obj), + **kwargs + )
\ No newline at end of file diff --git a/g4f/Provider/deprecated/V50.py b/g4f/Provider/deprecated/V50.py new file mode 100644 index 00000000..456445f7 --- /dev/null +++ b/g4f/Provider/deprecated/V50.py @@ -0,0 +1,61 @@ +from __future__ import annotations + +import uuid + +import requests + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider + + +class V50(AbstractProvider): + url = 'https://p5.v50.ltd' + supports_gpt_35_turbo = True + supports_stream = False + needs_auth = False + working = False + + @staticmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + stream: bool, **kwargs: Any) -> CreateResult: + + conversation = ( + "\n".join( + f"{message['role']}: {message['content']}" for message in messages + ) + + "\nassistant: " + ) + payload = { + "prompt" : conversation, + "options" : {}, + "systemMessage" : ".", + "temperature" : kwargs.get("temperature", 0.4), + "top_p" : kwargs.get("top_p", 0.4), + "model" : model, + "user" : str(uuid.uuid4()) + } + + headers = { + 'authority' : 'p5.v50.ltd', + 'accept' : 'application/json, text/plain, */*', + 'accept-language' : 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7', + 'content-type' : 'application/json', + 'origin' : 'https://p5.v50.ltd', + 'referer' : 'https://p5.v50.ltd/', + 'sec-ch-ua-platform': '"Windows"', + 'sec-fetch-dest' : 'empty', + 'sec-fetch-mode' : 'cors', + 'sec-fetch-site' : 'same-origin', + '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' + } + response = requests.post( + "https://p5.v50.ltd/api/chat-process", + json=payload, + headers=headers, + proxies=kwargs.get('proxy', {}), + ) + + if "https://fk1.v50.ltd" not in response.text: + yield response.text
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Vercel.py b/g4f/Provider/deprecated/Vercel.py new file mode 100644 index 00000000..adf7b208 --- /dev/null +++ b/g4f/Provider/deprecated/Vercel.py @@ -0,0 +1,392 @@ +from __future__ import annotations + +import json, base64, requests, random, uuid + +try: + import execjs + has_requirements = True +except ImportError: + has_requirements = False + +from ...typing import Messages, TypedDict, CreateResult, Any +from ..base_provider import AbstractProvider +from ...errors import MissingRequirementsError + +class Vercel(AbstractProvider): + url = 'https://sdk.vercel.ai' + working = False + supports_message_history = True + supports_gpt_35_turbo = True + supports_stream = True + + @staticmethod + def create_completion( + model: str, + messages: Messages, + stream: bool, + proxy: str = None, + **kwargs + ) -> CreateResult: + if not has_requirements: + raise MissingRequirementsError('Install "PyExecJS" package') + + if not model: + model = "gpt-3.5-turbo" + elif model not in model_info: + raise ValueError(f"Vercel does not support {model}") + + headers = { + 'authority': 'sdk.vercel.ai', + 'accept': '*/*', + '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', + 'custom-encoding': get_anti_bot_token(), + 'origin': 'https://sdk.vercel.ai', + 'pragma': 'no-cache', + 'referer': 'https://sdk.vercel.ai/', + 'sec-ch-ua': '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"', + 'sec-ch-ua-mobile': '?0', + 'sec-ch-ua-platform': '"macOS"', + 'sec-fetch-dest': 'empty', + 'sec-fetch-mode': 'cors', + 'sec-fetch-site': 'same-origin', + 'user-agent': f'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.{random.randint(99, 999)}.{random.randint(99, 999)} Safari/537.36', + } + + json_data = { + 'model' : model_info[model]['id'], + 'messages' : messages, + 'playgroundId': str(uuid.uuid4()), + 'chatIndex' : 0, + **model_info[model]['default_params'], + **kwargs + } + + max_retries = kwargs.get('max_retries', 20) + for _ in range(max_retries): + response = requests.post('https://chat.vercel.ai/api/chat', + headers=headers, json=json_data, stream=True, proxies={"https": proxy}) + try: + response.raise_for_status() + except: + continue + for token in response.iter_content(chunk_size=None): + yield token.decode() + break + + +def get_anti_bot_token() -> str: + headers = { + 'authority': 'sdk.vercel.ai', + 'accept': '*/*', + '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', + 'pragma': 'no-cache', + 'referer': 'https://sdk.vercel.ai/', + 'sec-ch-ua': '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"', + 'sec-ch-ua-mobile': '?0', + 'sec-ch-ua-platform': '"macOS"', + 'sec-fetch-dest': 'empty', + 'sec-fetch-mode': 'cors', + 'sec-fetch-site': 'same-origin', + 'user-agent': f'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.{random.randint(99, 999)}.{random.randint(99, 999)} Safari/537.36', + } + + response = requests.get('https://sdk.vercel.ai/openai.jpeg', + headers=headers).text + + raw_data = json.loads(base64.b64decode(response, + validate=True)) + + js_script = '''const globalThis={marker:"mark"};String.prototype.fontcolor=function(){return `<font>${this}</font>`}; + return (%s)(%s)''' % (raw_data['c'], raw_data['a']) + + raw_token = json.dumps({'r': execjs.compile(js_script).call(''), 't': raw_data['t']}, + separators = (",", ":")) + + return base64.b64encode(raw_token.encode('utf-16le')).decode() + +class ModelInfo(TypedDict): + id: str + default_params: dict[str, Any] + +model_info: dict[str, ModelInfo] = { + # 'claude-instant-v1': { + # 'id': 'anthropic:claude-instant-v1', + # 'default_params': { + # 'temperature': 1, + # 'maximumLength': 1024, + # 'topP': 1, + # 'topK': 1, + # 'presencePenalty': 1, + # 'frequencyPenalty': 1, + # 'stopSequences': ['\n\nHuman:'], + # }, + # }, + # 'claude-v1': { + # 'id': 'anthropic:claude-v1', + # 'default_params': { + # 'temperature': 1, + # 'maximumLength': 1024, + # 'topP': 1, + # 'topK': 1, + # 'presencePenalty': 1, + # 'frequencyPenalty': 1, + # 'stopSequences': ['\n\nHuman:'], + # }, + # }, + # 'claude-v2': { + # 'id': 'anthropic:claude-v2', + # 'default_params': { + # 'temperature': 1, + # 'maximumLength': 1024, + # 'topP': 1, + # 'topK': 1, + # 'presencePenalty': 1, + # 'frequencyPenalty': 1, + # 'stopSequences': ['\n\nHuman:'], + # }, + # }, + 'replicate/llama70b-v2-chat': { + 'id': 'replicate:replicate/llama-2-70b-chat', + 'default_params': { + 'temperature': 0.75, + 'maximumLength': 3000, + 'topP': 1, + 'repetitionPenalty': 1, + }, + }, + 'a16z-infra/llama7b-v2-chat': { + 'id': 'replicate:a16z-infra/llama7b-v2-chat', + 'default_params': { + 'temperature': 0.75, + 'maximumLength': 3000, + 'topP': 1, + 'repetitionPenalty': 1, + }, + }, + 'a16z-infra/llama13b-v2-chat': { + 'id': 'replicate:a16z-infra/llama13b-v2-chat', + 'default_params': { + 'temperature': 0.75, + 'maximumLength': 3000, + 'topP': 1, + 'repetitionPenalty': 1, + }, + }, + 'replicate/llama-2-70b-chat': { + 'id': 'replicate:replicate/llama-2-70b-chat', + 'default_params': { + 'temperature': 0.75, + 'maximumLength': 3000, + 'topP': 1, + 'repetitionPenalty': 1, + }, + }, + 'bigscience/bloom': { + 'id': 'huggingface:bigscience/bloom', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 0.95, + 'topK': 4, + 'repetitionPenalty': 1.03, + }, + }, + 'google/flan-t5-xxl': { + 'id': 'huggingface:google/flan-t5-xxl', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 0.95, + 'topK': 4, + 'repetitionPenalty': 1.03, + }, + }, + 'EleutherAI/gpt-neox-20b': { + 'id': 'huggingface:EleutherAI/gpt-neox-20b', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 0.95, + 'topK': 4, + 'repetitionPenalty': 1.03, + 'stopSequences': [], + }, + }, + 'OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5': { + 'id': 'huggingface:OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5', + 'default_params': { + 'maximumLength': 1024, + 'typicalP': 0.2, + 'repetitionPenalty': 1, + }, + }, + 'OpenAssistant/oasst-sft-1-pythia-12b': { + 'id': 'huggingface:OpenAssistant/oasst-sft-1-pythia-12b', + 'default_params': { + 'maximumLength': 1024, + 'typicalP': 0.2, + 'repetitionPenalty': 1, + }, + }, + 'bigcode/santacoder': { + 'id': 'huggingface:bigcode/santacoder', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 0.95, + 'topK': 4, + 'repetitionPenalty': 1.03, + }, + }, + 'command-light-nightly': { + 'id': 'cohere:command-light-nightly', + 'default_params': { + 'temperature': 0.9, + 'maximumLength': 1024, + 'topP': 1, + 'topK': 0, + 'presencePenalty': 0, + 'frequencyPenalty': 0, + 'stopSequences': [], + }, + }, + 'command-nightly': { + 'id': 'cohere:command-nightly', + 'default_params': { + 'temperature': 0.9, + 'maximumLength': 1024, + 'topP': 1, + 'topK': 0, + 'presencePenalty': 0, + 'frequencyPenalty': 0, + 'stopSequences': [], + }, + }, + # 'gpt-4': { + # 'id': 'openai:gpt-4', + # 'default_params': { + # 'temperature': 0.7, + # 'maximumLength': 8192, + # 'topP': 1, + # 'presencePenalty': 0, + # 'frequencyPenalty': 0, + # 'stopSequences': [], + # }, + # }, + # 'gpt-4-0613': { + # 'id': 'openai:gpt-4-0613', + # 'default_params': { + # 'temperature': 0.7, + # 'maximumLength': 8192, + # 'topP': 1, + # 'presencePenalty': 0, + # 'frequencyPenalty': 0, + # 'stopSequences': [], + # }, + # }, + 'code-davinci-002': { + 'id': 'openai:code-davinci-002', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 1, + 'presencePenalty': 0, + 'frequencyPenalty': 0, + 'stopSequences': [], + }, + }, + 'gpt-3.5-turbo': { + 'id': 'openai:gpt-3.5-turbo', + 'default_params': { + 'temperature': 0.7, + 'maximumLength': 4096, + 'topP': 1, + 'topK': 1, + 'presencePenalty': 1, + 'frequencyPenalty': 1, + 'stopSequences': [], + }, + }, + 'gpt-3.5-turbo-16k': { + 'id': 'openai:gpt-3.5-turbo-16k', + 'default_params': { + 'temperature': 0.7, + 'maximumLength': 16280, + 'topP': 1, + 'topK': 1, + 'presencePenalty': 1, + 'frequencyPenalty': 1, + 'stopSequences': [], + }, + }, + 'gpt-3.5-turbo-16k-0613': { + 'id': 'openai:gpt-3.5-turbo-16k-0613', + 'default_params': { + 'temperature': 0.7, + 'maximumLength': 16280, + 'topP': 1, + 'topK': 1, + 'presencePenalty': 1, + 'frequencyPenalty': 1, + 'stopSequences': [], + }, + }, + 'text-ada-001': { + 'id': 'openai:text-ada-001', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 1, + 'presencePenalty': 0, + 'frequencyPenalty': 0, + 'stopSequences': [], + }, + }, + 'text-babbage-001': { + 'id': 'openai:text-babbage-001', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 1, + 'presencePenalty': 0, + 'frequencyPenalty': 0, + 'stopSequences': [], + }, + }, + 'text-curie-001': { + 'id': 'openai:text-curie-001', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 1, + 'presencePenalty': 0, + 'frequencyPenalty': 0, + 'stopSequences': [], + }, + }, + 'text-davinci-002': { + 'id': 'openai:text-davinci-002', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 1024, + 'topP': 1, + 'presencePenalty': 0, + 'frequencyPenalty': 0, + 'stopSequences': [], + }, + }, + 'text-davinci-003': { + 'id': 'openai:text-davinci-003', + 'default_params': { + 'temperature': 0.5, + 'maximumLength': 4097, + 'topP': 1, + 'presencePenalty': 0, + 'frequencyPenalty': 0, + 'stopSequences': [], + }, + }, +}
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Vitalentum.py b/g4f/Provider/deprecated/Vitalentum.py new file mode 100644 index 00000000..8f466a52 --- /dev/null +++ b/g4f/Provider/deprecated/Vitalentum.py @@ -0,0 +1,55 @@ +from __future__ import annotations + +import json +from aiohttp import ClientSession + +from ..base_provider import AsyncGeneratorProvider +from ...typing import AsyncResult, Messages + +class Vitalentum(AsyncGeneratorProvider): + url = "https://app.vitalentum.io" + supports_gpt_35_turbo = True + + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + proxy: str = None, + **kwargs + ) -> AsyncResult: + headers = { + "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", + "Accept": "text/event-stream", + "Accept-language": "de,en-US;q=0.7,en;q=0.3", + "Origin": cls.url, + "Referer": f"{cls.url}/", + "Sec-Fetch-Dest": "empty", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Site": "same-origin", + } + conversation = json.dumps({"history": [{ + "speaker": "human" if message["role"] == "user" else "bot", + "text": message["content"], + } for message in messages]}) + data = { + "conversation": conversation, + "temperature": 0.7, + **kwargs + } + async with ClientSession( + headers=headers + ) as session: + async with session.post(f"{cls.url}/api/converse-edge", json=data, proxy=proxy) as response: + response.raise_for_status() + async for line in response.content: + line = line.decode() + if line.startswith("data: "): + if line.startswith("data: [DONE]"): + break + line = json.loads(line[6:-1]) + content = line["choices"][0]["delta"].get("content") + + if content: + yield content
\ No newline at end of file diff --git a/g4f/Provider/deprecated/VoiGpt.py b/g4f/Provider/deprecated/VoiGpt.py new file mode 100644 index 00000000..9b061e63 --- /dev/null +++ b/g4f/Provider/deprecated/VoiGpt.py @@ -0,0 +1,91 @@ +from __future__ import annotations + +import json +import requests +from ..base_provider import AbstractProvider +from ...typing import Messages, CreateResult + + +class VoiGpt(AbstractProvider): + """ + VoiGpt - A provider for VoiGpt.com + + **Note** : to use this provider you have to get your csrf token/cookie from the voigpt.com website + + Args: + model: The model to use + messages: The messages to send + stream: Whether to stream the response + proxy: The proxy to use + access_token: The access token to use + **kwargs: Additional keyword arguments + + Returns: + A CreateResult object + """ + url = "https://voigpt.com" + working = False + supports_gpt_35_turbo = True + supports_message_history = True + supports_stream = False + _access_token: str = None + + @classmethod + def create_completion( + cls, + model: str, + messages: Messages, + stream: bool, + proxy: str = None, + access_token: str = None, + **kwargs + ) -> CreateResult: + + if not model: + model = "gpt-3.5-turbo" + if not access_token: + access_token = cls._access_token + if not access_token: + headers = { + "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7", + "accept-language": "de-DE,de;q=0.9,en-DE;q=0.8,en;q=0.7,en-US;q=0.6", + "sec-ch-ua": "\"Google Chrome\";v=\"119\", \"Chromium\";v=\"119\", \"Not?A_Brand\";v=\"24\"", + "sec-ch-ua-mobile": "?0", + "sec-ch-ua-platform": "\"Linux\"", + "sec-fetch-dest": "document", + "sec-fetch-mode": "navigate", + "sec-fetch-site": "none", + "sec-fetch-user": "?1", + "upgrade-insecure-requests": "1", + "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36", + } + req_response = requests.get(cls.url, headers=headers) + access_token = cls._access_token = req_response.cookies.get("csrftoken") + + headers = { + "Accept-Encoding": "gzip, deflate, br", + "Accept-Language": "de-DE,de;q=0.9,en-DE;q=0.8,en;q=0.7,en-US;q=0.6", + "Cookie": f"csrftoken={access_token};", + "Origin": "https://voigpt.com", + "Referer": "https://voigpt.com/", + "Sec-Ch-Ua": "'Google Chrome';v='119', 'Chromium';v='119', 'Not?A_Brand';v='24'", + "Sec-Ch-Ua-Mobile": "?0", + "Sec-Ch-Ua-Platform": "'Windows'", + "Sec-Fetch-Dest": "empty", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Site": "same-origin", + "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36", + "X-Csrftoken": access_token, + } + + payload = { + "messages": messages, + } + request_url = f"{cls.url}/generate_response/" + req_response = requests.post(request_url, headers=headers, json=payload) + try: + response = json.loads(req_response.text) + yield response["response"] + except: + raise RuntimeError(f"Response: {req_response.text}") + diff --git a/g4f/Provider/deprecated/Wewordle.py b/g4f/Provider/deprecated/Wewordle.py new file mode 100644 index 00000000..c30887fb --- /dev/null +++ b/g4f/Provider/deprecated/Wewordle.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +import random, string, time +from aiohttp import ClientSession + +from ..base_provider import AsyncProvider + + +class Wewordle(AsyncProvider): + url = "https://wewordle.org" + working = False + supports_gpt_35_turbo = True + + @classmethod + async def create_async( + cls, + model: str, + messages: list[dict[str, str]], + proxy: str = None, + **kwargs + ) -> str: + + headers = { + "accept" : "*/*", + "pragma" : "no-cache", + "Content-Type" : "application/json", + "Connection" : "keep-alive" + } + + _user_id = "".join(random.choices(f"{string.ascii_lowercase}{string.digits}", k=16)) + _app_id = "".join(random.choices(f"{string.ascii_lowercase}{string.digits}", k=31)) + _request_date = time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime()) + data = { + "user" : _user_id, + "messages" : messages, + "subscriber": { + "originalPurchaseDate" : None, + "originalApplicationVersion" : None, + "allPurchaseDatesMillis" : {}, + "entitlements" : {"active": {}, "all": {}}, + "allPurchaseDates" : {}, + "allExpirationDatesMillis" : {}, + "allExpirationDates" : {}, + "originalAppUserId" : f"$RCAnonymousID:{_app_id}", + "latestExpirationDate" : None, + "requestDate" : _request_date, + "latestExpirationDateMillis" : None, + "nonSubscriptionTransactions" : [], + "originalPurchaseDateMillis" : None, + "managementURL" : None, + "allPurchasedProductIdentifiers": [], + "firstSeen" : _request_date, + "activeSubscriptions" : [], + } + } + + + async with ClientSession( + headers=headers + ) as session: + async with session.post(f"{cls.url}/gptapi/v1/android/turbo", proxy=proxy, json=data) as response: + response.raise_for_status() + content = (await response.json())["message"]["content"] + if content: + return content
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Wuguokai.py b/g4f/Provider/deprecated/Wuguokai.py new file mode 100644 index 00000000..f12d1bfe --- /dev/null +++ b/g4f/Provider/deprecated/Wuguokai.py @@ -0,0 +1,57 @@ +from __future__ import annotations + +import random + +import requests + +from ...typing import Any, CreateResult +from ..base_provider import AbstractProvider, format_prompt + + +class Wuguokai(AbstractProvider): + url = 'https://chat.wuguokai.xyz' + supports_gpt_35_turbo = True + working = False + + @staticmethod + def create_completion( + model: str, + messages: list[dict[str, str]], + stream: bool, + **kwargs: Any, + ) -> CreateResult: + headers = { + 'authority': 'ai-api.wuguokai.xyz', + 'accept': 'application/json, text/plain, */*', + 'accept-language': 'id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7', + 'content-type': 'application/json', + 'origin': 'https://chat.wuguokai.xyz', + 'referer': 'https://chat.wuguokai.xyz/', + 'sec-ch-ua': '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"', + 'sec-ch-ua-mobile': '?0', + 'sec-ch-ua-platform': '"Windows"', + 'sec-fetch-dest': 'empty', + 'sec-fetch-mode': 'cors', + 'sec-fetch-site': 'same-site', + '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 ={ + "prompt": format_prompt(messages), + "options": {}, + "userId": f"#/chat/{random.randint(1,99999999)}", + "usingContext": True + } + response = requests.post( + "https://ai-api20.wuguokai.xyz/api/chat-process", + headers=headers, + timeout=3, + json=data, + proxies=kwargs.get('proxy', {}), + ) + _split = response.text.split("> 若回答失败请重试或多刷新几次界面后重试") + if response.status_code != 200: + raise Exception(f"Error: {response.status_code} {response.reason}") + if len(_split) > 1: + yield _split[1].strip() + else: + yield _split[0].strip()
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Ylokh.py b/g4f/Provider/deprecated/Ylokh.py new file mode 100644 index 00000000..dbff4602 --- /dev/null +++ b/g4f/Provider/deprecated/Ylokh.py @@ -0,0 +1,58 @@ +from __future__ import annotations + +import json + +from ...requests import StreamSession +from ..base_provider import AsyncGeneratorProvider +from ...typing import AsyncResult, Messages + +class Ylokh(AsyncGeneratorProvider): + url = "https://chat.ylokh.xyz" + working = False + supports_message_history = True + supports_gpt_35_turbo = True + + + @classmethod + async def create_async_generator( + cls, + model: str, + messages: Messages, + stream: bool = True, + proxy: str = None, + timeout: int = 120, + **kwargs + ) -> AsyncResult: + model = model if model else "gpt-3.5-turbo" + headers = {"Origin": cls.url, "Referer": f"{cls.url}/"} + data = { + "messages": messages, + "model": model, + "temperature": 1, + "presence_penalty": 0, + "top_p": 1, + "frequency_penalty": 0, + "allow_fallback": True, + "stream": stream, + **kwargs + } + async with StreamSession( + headers=headers, + proxies={"https": proxy}, + timeout=timeout + ) as session: + async with session.post("https://chatapi.ylokh.xyz/v1/chat/completions", json=data) as response: + response.raise_for_status() + if stream: + async for line in response.iter_lines(): + line = line.decode() + if line.startswith("data: "): + if line.startswith("data: [DONE]"): + break + line = json.loads(line[6:]) + content = line["choices"][0]["delta"].get("content") + if content: + yield content + else: + chat = await response.json() + yield chat["choices"][0]["message"].get("content")
\ No newline at end of file diff --git a/g4f/Provider/deprecated/Yqcloud.py b/g4f/Provider/deprecated/Yqcloud.py new file mode 100644 index 00000000..227f8995 --- /dev/null +++ b/g4f/Provider/deprecated/Yqcloud.py @@ -0,0 +1,61 @@ +from __future__ import annotations + +import random +from ...requests import StreamSession + +from ...typing import AsyncResult, Messages +from ..base_provider import AsyncGeneratorProvider, format_prompt + + +class Yqcloud(AsyncGeneratorProvider): + url = "https://chat9.yqcloud.top/" + working = False + supports_gpt_35_turbo = True + + @staticmethod + async def create_async_generator( + model: str, + messages: Messages, + proxy: str = None, + timeout: int = 120, + **kwargs, + ) -> AsyncResult: + async with StreamSession( + headers=_create_header(), proxies={"https": proxy}, timeout=timeout + ) as session: + payload = _create_payload(messages, **kwargs) + async with session.post("https://api.aichatos.cloud/api/generateStream", json=payload) as response: + response.raise_for_status() + async for chunk in response.iter_content(): + if chunk: + chunk = chunk.decode() + if "sorry, 您的ip已由于触发防滥用检测而被封禁" in chunk: + raise RuntimeError("IP address is blocked by abuse detection.") + yield chunk + + +def _create_header(): + return { + "accept" : "application/json, text/plain, */*", + "content-type" : "application/json", + "origin" : "https://chat9.yqcloud.top", + "referer" : "https://chat9.yqcloud.top/" + } + + +def _create_payload( + messages: Messages, + system_message: str = "", + user_id: int = None, + **kwargs +): + if not user_id: + user_id = random.randint(1690000544336, 2093025544336) + return { + "prompt": format_prompt(messages), + "network": True, + "system": system_message, + "withoutContext": False, + "stream": True, + "userId": f"#/chat/{user_id}" + } diff --git a/g4f/Provider/deprecated/__init__.py b/g4f/Provider/deprecated/__init__.py new file mode 100644 index 00000000..bf923f2a --- /dev/null +++ b/g4f/Provider/deprecated/__init__.py @@ -0,0 +1,35 @@ +from .AiService import AiService +from .CodeLinkAva import CodeLinkAva +from .DfeHub import DfeHub +from .EasyChat import EasyChat +from .Forefront import Forefront +from .GetGpt import GetGpt +from .Lockchat import Lockchat +from .Wewordle import Wewordle +from .Equing import Equing +from .Wuguokai import Wuguokai +from .V50 import V50 +from .FastGpt import FastGpt +from .Aivvm import Aivvm +from .Vitalentum import Vitalentum +from .H2o import H2o +from .Myshell import Myshell +from .Acytoo import Acytoo +from .Aibn import Aibn +from .Ails import Ails +from .ChatgptDuo import ChatgptDuo +from .Cromicle import Cromicle +from .Opchatgpts import Opchatgpts +from .Yqcloud import Yqcloud +from .Aichat import Aichat +from .Berlin import Berlin +from .Phind import Phind +from .AiAsk import AiAsk +from ..AiChatOnline import AiChatOnline +from .ChatAnywhere import ChatAnywhere +from .FakeGpt import FakeGpt +from .GeekGpt import GeekGpt +from .GPTalk import GPTalk +from .Hashnode import Hashnode +from .Ylokh import Ylokh +from .OpenAssistant import OpenAssistant
\ No newline at end of file |