返回提交历史
Modified
g4f/Provider/AItianhu.py
+48
-28
Modified
g4f/Provider/Acytoo.py
+24
-23
Modified
g4f/Provider/Aichat.py
+27
-28
Modified
g4f/Provider/Ails.py
+38
-51
Modified
g4f/Provider/Bing.py
+6
-17
Modified
g4f/Provider/ChatgptAi.py
+50
-34
Modified
g4f/Provider/ChatgptLogin.py
+43
-106
Modified
g4f/Provider/DeepAi.py
+16
-15
Modified
g4f/Provider/H2o.py
+1
-2
Modified
g4f/Provider/HuggingChat.py
+24
-28
Modified
g4f/Provider/Liaobots.py
+9
-9
Modified
g4f/Provider/Opchatgpts.py
+4
-56
Modified
g4f/Provider/OpenaiChat.py
+56
-48
Modified
g4f/Provider/Vercel.py
+58
-41
Modified
g4f/Provider/Wewordle.py
+23
-32
Modified
g4f/Provider/Yqcloud.py
+9
-6
Modified
g4f/Provider/base_provider.py
+7
-4
Modified
requirements.txt
+0
-1
Added
testing/test_async.py
+37
-0
Modified
testing/test_providers.py
+14
-9
Modified
tool/readme_table.py
+3
-24
XFEstudio/gpt4free
Add to many provider async and stream support, Fix Ails, AItianhu, ChatgptAi, ChatgptLogin Provider, Add fallback cookies to Bing, Improve OpenaiChat Provider
5ca47b44
代码差异
21 个文件
+497
-562
@@ -1,43 +1,62 @@
1
1
from __future__ import annotations
2
2
3
3
import json
4
from aiohttp import ClientSession, http
4
5
5
import requests
6
from ..typing import AsyncGenerator
7
from .base_provider import AsyncGeneratorProvider, format_prompt
6
8
7
from ..typing import Any, CreateResult
8
from .base_provider import BaseProvider
9
9
10
11
class AItianhu(BaseProvider):
12
url = "https://www.aitianhu.com/"
13
working = False
10
class AItianhu(AsyncGeneratorProvider):
11
url = "https://www.aitianhu.com"
12
working = True
14
13
supports_gpt_35_turbo = True
15
14
16
@staticmethod
17
def create_completion(
15
@classmethod
16
async def create_async_generator(
17
cls,
18
18
model: str,
19
19
messages: list[dict[str, str]],
20
stream: bool, **kwargs: Any) -> CreateResult:
21
22
base = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
23
base += "\nassistant: "
24
20
proxy: str = None,
21
**kwargs
22
) -> AsyncGenerator:
25
23
headers = {
26
"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"
24
"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/116.0",
25
"Accept": "application/json, text/plain, */*",
26
"Accept-Language": "de,en-US;q=0.7,en;q=0.3",
27
"Content-Type": "application/json",
28
"Origin": cls.url,
29
"Connection": "keep-alive",
30
"Referer": cls.url + "/",
31
"Sec-Fetch-Dest": "empty",
32
"Sec-Fetch-Mode": "cors",
33
"Sec-Fetch-Site": "same-origin",
27
34
}
28
data: dict[str, Any] = {
29
"prompt": base,
30
"options": {},
31
"systemMessage": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully. Respond using markdown.",
32
"temperature": kwargs.get("temperature", 0.8),
33
"top_p": kwargs.get("top_p", 1),
34
}
35
url = "https://www.aitianhu.com/api/chat-process"
36
response = requests.post(url, headers=headers, json=data)
37
response.raise_for_status()
38
lines = response.text.strip().split("\n")
39
res = json.loads(lines[-1])
40
yield res["text"]
35
async with ClientSession(
36
headers=headers,
37
version=http.HttpVersion10
38
) as session:
39
data = {
40
"prompt": format_prompt(messages),
41
"options": {},
42
"systemMessage": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully.",
43
"temperature": 0.8,
44
"top_p": 1,
45
**kwargs
46
}
47
async with session.post(
48
cls.url + "/api/chat-process",
49
proxy=proxy,
50
json=data,
51
ssl=False,
52
) as response:
53
response.raise_for_status()
54
async for line in response.content:
55
line = json.loads(line.decode('utf-8'))
56
token = line["detail"]["choices"][0]["delta"].get("content")
57
if token:
58
yield token
59
41
60
42
61
@classmethod
43
62
@property
@@ -46,6 +65,7 @@ class AItianhu(BaseProvider):
46
65
("model", "str"),
47
66
("messages", "list[dict[str, str]]"),
48
67
("stream", "bool"),
68
("proxy", "str"),
49
69
("temperature", "float"),
50
70
("top_p", "int"),
51
71
]
@@ -1,32 +1,37 @@
1
1
from __future__ import annotations
2
2
3
import time
3
from aiohttp import ClientSession
4
4
5
import requests
5
from ..typing import AsyncGenerator
6
from .base_provider import AsyncGeneratorProvider
6
7
7
from ..typing import Any, CreateResult
8
from .base_provider import BaseProvider
9
8
10
11
class Acytoo(BaseProvider):
12
url = 'https://chat.acytoo.com/'
9
class Acytoo(AsyncGeneratorProvider):
10
url = 'https://chat.acytoo.com'
13
11
working = True
14
12
supports_gpt_35_turbo = True
15
13
16
14
@classmethod
17
def create_completion(
15
async def create_async_generator(
18
16
cls,
19
17
model: str,
20
18
messages: list[dict[str, str]],
21
stream: bool, **kwargs: Any) -> CreateResult:
22
23
response = requests.post(f'{cls.url}api/completions',
24
headers=_create_header(), json=_create_payload(messages, kwargs.get('temperature', 0.5)))
25
26
response.raise_for_status()
27
response.encoding = 'utf-8'
28
29
yield response.text
19
proxy: str = None,
20
**kwargs
21
) -> AsyncGenerator:
22
23
async with ClientSession(
24
headers=_create_header()
25
) as session:
26
async with session.post(
27
cls.url + '/api/completions',
28
proxy=proxy,
29
json=_create_payload(messages, **kwargs)
30
) as response:
31
response.raise_for_status()
32
async for stream in response.content.iter_any():
33
if stream:
34
yield stream.decode()
30
35
31
36
32
37
def _create_header():
@@ -36,15 +41,11 @@ def _create_header():
36
41
}
37
42
38
43
39
def _create_payload(messages: list[dict[str, str]], temperature):
40
payload_messages = [
41
message | {'createdAt': int(time.time()) * 1000} for message in messages
42
]
43
44
def _create_payload(messages: list[dict[str, str]], temperature: float = 0.5, **kwargs):
44
45
return {
45
46
'key' : '',
46
47
'model' : 'gpt-3.5-turbo',
47
'messages' : payload_messages,
48
'messages' : messages,
48
49
'temperature' : temperature,
49
50
'password' : ''
50
51
}
@@ -1,25 +1,22 @@
1
1
from __future__ import annotations
2
2
3
import requests
3
from aiohttp import ClientSession
4
4
5
from ..typing import Any, CreateResult
6
from .base_provider import BaseProvider
5
from .base_provider import AsyncProvider, format_prompt
7
6
8
7
9
class Aichat(BaseProvider):
8
class Aichat(AsyncProvider):
10
9
url = "https://chat-gpt.org/chat"
11
10
working = True
12
11
supports_gpt_35_turbo = True
13
12
14
13
@staticmethod
15
def create_completion(
14
async def create_async(
16
15
model: str,
17
16
messages: list[dict[str, str]],
18
stream: bool, **kwargs: Any) -> CreateResult:
19
20
chat = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
21
chat += "\nassistant: "
22
17
proxy: str = None,
18
**kwargs
19
) -> str:
23
20
headers = {
24
21
"authority": "chat-gpt.org",
25
22
"accept": "*/*",
@@ -35,21 +32,23 @@ class Aichat(BaseProvider):
35
32
"sec-fetch-site": "same-origin",
36
33
"user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36",
37
34
}
38
39
json_data = {
40
"message": base,
41
"temperature": kwargs.get('temperature', 0.5),
42
"presence_penalty": 0,
43
"top_p": kwargs.get('top_p', 1),
44
"frequency_penalty": 0,
45
}
46
47
response = requests.post(
48
"https://chat-gpt.org/api/text",
49
headers=headers,
50
json=json_data,
51
)
52
response.raise_for_status()
53
if not response.json()['response']:
54
raise Exception("Error Response: " + response.json())
55
yield response.json()["message"]
35
async with ClientSession(
36
headers=headers
37
) as session:
38
json_data = {
39
"message": format_prompt(messages),
40
"temperature": kwargs.get('temperature', 0.5),
41
"presence_penalty": 0,
42
"top_p": kwargs.get('top_p', 1),
43
"frequency_penalty": 0,
44
}
45
async with session.post(
46
"https://chat-gpt.org/api/text",
47
proxy=proxy,
48
json=json_data
49
) as response:
50
response.raise_for_status()
51
result = await response.json()
52
if not result['response']:
53
raise Exception(f"Error Response: {result}")
54
return result["message"]
@@ -1,36 +1,36 @@
1
1
from __future__ import annotations
2
2
3
3
import hashlib
4
import json
5
4
import time
6
5
import uuid
6
import json
7
7
from datetime import datetime
8
from aiohttp import ClientSession
8
9
9
import requests
10
11
from ..typing import SHA256, Any, CreateResult
12
from .base_provider import BaseProvider
10
from ..typing import SHA256, AsyncGenerator
11
from .base_provider import AsyncGeneratorProvider
13
12
14
13
15
class Ails(BaseProvider):
14
class Ails(AsyncGeneratorProvider):
16
15
url: str = "https://ai.ls"
17
16
working = True
18
supports_stream = True
19
17
supports_gpt_35_turbo = True
20
18
21
19
@staticmethod
22
def create_completion(
20
async def create_async_generator(
23
21
model: str,
24
22
messages: list[dict[str, str]],
25
stream: bool, **kwargs: Any) -> CreateResult:
26
23
stream: bool,
24
proxy: str = None,
25
**kwargs
26
) -> AsyncGenerator:
27
27
headers = {
28
28
"authority": "api.caipacity.com",
29
29
"accept": "*/*",
30
30
"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",
31
31
"authorization": "Bearer free",
32
32
"client-id": str(uuid.uuid4()),
33
"client-v": _get_client_v(),
33
"client-v": "0.1.278",
34
34
"content-type": "application/json",
35
35
"origin": "https://ai.ls",
36
36
"referer": "https://ai.ls/",
@@ -41,42 +41,39 @@ class Ails(BaseProvider):
41
41
"sec-fetch-mode": "cors",
42
42
"sec-fetch-site": "cross-site",
43
43
"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",
44
"from-url": "https://ai.ls/?chat=1"
44
45
}
45
46
timestamp = _format_timestamp(int(time.time() * 1000))
47
sig = {
48
"d": datetime.now().strftime("%Y-%m-%d"),
49
"t": timestamp,
50
"s": _hash({"t": timestamp, "m": messages[-1]["content"]}),
51
}
52
53
json_data = json.dumps(
54
separators=(",", ":"),
55
obj={
46
async with ClientSession(
47
headers=headers
48
) as session:
49
timestamp = _format_timestamp(int(time.time() * 1000))
50
json_data = {
56
51
"model": "gpt-3.5-turbo",
57
52
"temperature": kwargs.get("temperature", 0.6),
58
53
"stream": True,
59
54
"messages": messages,
55
"d": datetime.now().strftime("%Y-%m-%d"),
56
"t": timestamp,
57
"s": _hash({"t": timestamp, "m": messages[-1]["content"]}),
60
58
}
61
| sig,
62
)
63
64
response = requests.post(
65
"https://api.caipacity.com/v1/chat/completions",
66
headers=headers,
67
data=json_data,
68
stream=True,
69
)
70
response.raise_for_status()
59
async with session.post(
60
"https://api.caipacity.com/v1/chat/completions",
61
proxy=proxy,
62
json=json_data
63
) as response:
64
response.raise_for_status()
65
start = "data: "
66
async for line in response.content:
67
line = line.decode('utf-8')
68
if line.startswith(start) and line != "data: [DONE]":
69
line = line[len(start):-1]
70
line = json.loads(line)
71
token = line["choices"][0]["delta"].get("content")
72
if token:
73
if "ai.ls" in token or "ai.ci" in token:
74
raise Exception("Response Error: " + token)
75
yield token
71
76
72
for token in response.iter_lines():
73
if b"content" in token:
74
completion_chunk = json.loads(token.decode().replace("data: ", ""))
75
token = completion_chunk["choices"][0]["delta"].get("content")
76
if "ai.ls" in token.lower() or "ai.ci" in token.lower():
77
raise Exception("Response Error: " + token)
78
if token != None:
79
yield token
80
77
81
78
@classmethod
82
79
@property
@@ -106,14 +103,4 @@ def _format_timestamp(timestamp: int) -> str:
106
103
e = timestamp
107
104
n = e % 10
108
105
r = n + 1 if n % 2 == 0 else n
109
return str(e - n + r)
110
111
112
def _get_client_v():
113
response = requests.get("https://ai.ls/?chat=1")
114
response.raise_for_status()
115
js_path = response.text.split('crossorigin href="')[1].split('"')[0]
116
117
response = requests.get("https://ai.ls" + js_path)
118
response.raise_for_status()
119
return response.text.split('G4="')[1].split('"')[0]
106
return str(e - n + r)
@@ -1,23 +1,14 @@
1
1
from __future__ import annotations
2
2
3
import asyncio
4
import json
5
import os
6
import random
7
8
import aiohttp
9
from aiohttp import ClientSession
10
11
from ..typing import Any, AsyncGenerator, CreateResult, Union
3
from aiohttp import ClientSession
4
from ..typing import Any, AsyncGenerator, Union
12
5
from .base_provider import AsyncGeneratorProvider, get_cookies
13
6
14
7
15
8
class Bing(AsyncGeneratorProvider):
16
9
url = "https://bing.com/chat"
17
needs_auth = True
18
10
working = True
19
11
supports_gpt_4 = True
20
supports_stream = True
21
12
22
13
@staticmethod
23
14
def create_async_generator(
@@ -34,18 +25,16 @@ class Bing(AsyncGeneratorProvider):
34
25
prompt = messages[-1]["content"]
35
26
context = create_context(messages[:-1])
36
27
37
if cookies and "SRCHD" in cookies:
38
#TODO: Will implement proper cookie retrieval later and use a try-except mechanism in 'stream_generate' instead of defaulting the cookie value like this
39
cookies_dict = {
40
'SRCHD' : cookies["SRCHD"],
28
if not cookies or "SRCHD" not in cookies:
29
cookies = {
30
'SRCHD' : 'AF=NOFORM',
41
31
'PPLState' : '1',
42
32
'KievRPSSecAuth': '',
43
33
'SUID' : '',
44
34
'SRCHUSR' : '',
45
35
'SRCHHPGUSR' : '',
46
36
}
47
48
return stream_generate(prompt, context, cookies_dict)
37
return stream_generate(prompt, context, cookies)
49
38
50
39
def create_context(messages: list[dict[str, str]]):
51
40
context = "".join(f"[{message['role']}](#message)\n{message['content']}\n\n" for message in messages)
@@ -1,32 +1,28 @@
1
1
from __future__ import annotations
2
2
3
3
import re
4
import html
5
import json
6
from aiohttp import ClientSession
4
7
5
import requests
8
from ..typing import AsyncGenerator
9
from .base_provider import AsyncGeneratorProvider
6
10
7
from ..typing import Any, CreateResult
8
from .base_provider import BaseProvider
9
11
12
class ChatgptAi(AsyncGeneratorProvider):
13
url: str = "https://chatgpt.ai/"
14
working = True
15
supports_gpt_35_turbo = True
16
_system_data = None
10
17
11
class ChatgptAi(BaseProvider):
12
url: str = "https://chatgpt.ai/gpt-4/"
13
working = True
14
supports_gpt_4 = True
15
16
@staticmethod
17
def create_completion(
18
@classmethod
19
async def create_async_generator(
20
cls,
18
21
model: str,
19
22
messages: list[dict[str, str]],
20
stream: bool, **kwargs: Any) -> CreateResult:
21
22
chat = "\n".join(f"{message['role']}: {message['content']}" for message in messages)
23
chat += "\nassistant: "
24
25
response = requests.get("https://chatgpt.ai/")
26
nonce, post_id, _, bot_id = re.findall(
27
r'data-nonce="(.*)"\n data-post-id="(.*)"\n data-url="(.*)"\n data-bot-id="(.*)"\n data-width',
28
response.text)[0]
29
23
proxy: str = None,
24
**kwargs
25
) -> AsyncGenerator:
30
26
headers = {
31
27
"authority" : "chatgpt.ai",
32
28
"accept" : "*/*",
@@ -34,7 +30,7 @@ class ChatgptAi(BaseProvider):
34
30
"cache-control" : "no-cache",
35
31
"origin" : "https://chatgpt.ai",
36
32
"pragma" : "no-cache",
37
"referer" : "https://chatgpt.ai/gpt-4/",
33
"referer" : cls.url,
38
34
"sec-ch-ua" : '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
39
35
"sec-ch-ua-mobile" : "?0",
40
36
"sec-ch-ua-platform" : '"Windows"',
@@ -43,17 +39,37 @@ class ChatgptAi(BaseProvider):
43
39
"sec-fetch-site" : "same-origin",
44
40
"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",
45
41
}
46
data = {
47
"_wpnonce" : nonce,
48
"post_id" : post_id,
49
"url" : "https://chatgpt.ai/gpt-4",
50
"action" : "wpaicg_chat_shortcode_message",
51
"message" : chat,
52
"bot_id" : bot_id,
53
}
42
async with ClientSession(
43
headers=headers
44
) as session:
45
if not cls._system_data:
46
async with session.get(cls.url, proxy=proxy) as response:
47
response.raise_for_status()
48
match = re.findall(r"data-system='([^']+)'", await response.text())
49
if not match:
50
raise RuntimeError("No system data")
51
cls._system_data = json.loads(html.unescape(match[0]))
54
52
55
response = requests.post(
56
"https://chatgpt.ai/wp-admin/admin-ajax.php", headers=headers, data=data)
57
58
response.raise_for_status()
59
yield response.json()["data"]
53
data = {
54
"botId": cls._system_data["botId"],
55
"clientId": "",
56
"contextId": cls._system_data["contextId"],
57
"id": cls._system_data["id"],
58
"messages": messages[:-1],
59
"newMessage": messages[-1]["content"],
60
"session": cls._system_data["sessionId"],
61
"stream": True
62
}
63
async with session.post(
64
"https://chatgpt.ai/wp-json/mwai-ui/v1/chats/submit",
65
proxy=proxy,
66
json=data
67
) as response:
68
response.raise_for_status()
69
start = "data: "
70
async for line in response.content:
71
line = line.decode('utf-8')
72
if line.startswith(start):
73
line = json.loads(line[len(start):-1])
74
if line["type"] == "live":
75
yield line["data"]
@@ -1,70 +1,58 @@
1
1
from __future__ import annotations
2
2
3
import base64
4
import os
5
import re
3
import os, re
4
from aiohttp import ClientSession
6
5
7
import requests
6
from .base_provider import AsyncProvider, format_prompt
8
7
9
from ..typing import Any, CreateResult
10
from .base_provider import BaseProvider
11
8
12
13
class ChatgptLogin(BaseProvider):
9
class ChatgptLogin(AsyncProvider):
14
10
url = "https://opchatgpts.net"
15
11
supports_gpt_35_turbo = True
16
12
working = True
13
_nonce = None
17
14
18
@staticmethod
19
def create_completion(
15
@classmethod
16
async def create_async(
17
cls,
20
18
model: str,
21
19
messages: list[dict[str, str]],
22
stream: bool, **kwargs: Any) -> CreateResult:
23
20
**kwargs
21
) -> str:
24
22
headers = {
25
"authority" : "chatgptlogin.ac",
26
"accept" : "*/*",
27
"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",
28
"content-type" : "application/json",
29
"origin" : "https://opchatgpts.net",
30
"referer" : "https://opchatgpts.net/chatgpt-free-use/",
31
"sec-ch-ua" : '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
32
"sec-ch-ua-mobile" : "?0",
33
"sec-ch-ua-platform" : '"Windows"',
34
"sec-fetch-dest" : "empty",
35
"sec-fetch-mode" : "cors",
36
"sec-fetch-site" : "same-origin",
37
"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",
38
"x-wp-nonce" : _get_nonce(),
39
}
40
41
conversation = _transform(messages)
42
43
json_data = {
44
"env" : "chatbot",
45
"session" : "N/A",
46
"prompt" : "Converse as if you were an AI assistant. Be friendly, creative.",
47
"context" : "Converse as if you were an AI assistant. Be friendly, creative.",
48
"messages" : conversation,
49
"newMessage" : messages[-1]["content"],
50
"userName" : '<div class="mwai-name-text">User:</div>',
51
"aiName" : '<div class="mwai-name-text">AI:</div>',
52
"model" : "gpt-3.5-turbo",
53
"temperature" : kwargs.get("temperature", 0.8),
54
"maxTokens" : 1024,
55
"maxResults" : 1,
56
"apiKey" : "",
57
"service" : "openai",
58
"embeddingsIndex": "",
59
"stop" : "",
60
"clientId" : os.urandom(6).hex()
23
"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",
24
"Accept" : "*/*",
25
"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",
26
"Origin" : "https://opchatgpts.net",
27
"Alt-Used" : "opchatgpts.net",
28
"Referer" : "https://opchatgpts.net/chatgpt-free-use/",
29
"Sec-Fetch-Dest" : "empty",
30
"Sec-Fetch-Mode" : "cors",
31
"Sec-Fetch-Site" : "same-origin",
61
32
}
62
63
response = requests.post("https://opchatgpts.net/wp-json/ai-chatbot/v1/chat",
64
headers=headers, json=json_data)
65
66
response.raise_for_status()
67
yield response.json()["reply"]
33
async with ClientSession(
34
headers=headers
35
) as session:
36
if not cls._nonce:
37
async with session.get(
38
"https://opchatgpts.net/chatgpt-free-use/",
39
params={"id": os.urandom(6).hex()},
40
) as response:
41
result = re.search(r'data-nonce="(.*?)"', await response.text())
42
if not result:
43
raise RuntimeError("No nonce value")
44
cls._nonce = result.group(1)
45
data = {
46
"_wpnonce": cls._nonce,
47
"post_id": 28,
48
"url": "https://opchatgpts.net/chatgpt-free-use",
49
"action": "wpaicg_chat_shortcode_message",
50
"message": format_prompt(messages),
51
"bot_id": 0
52
}
53
async with session.post("https://opchatgpts.net/wp-admin/admin-ajax.php", data=data) as response:
54
response.raise_for_status()
55
return (await response.json())["data"]
68
56
69
57
@classmethod
70
58
@property
@@ -76,55 +64,4 @@ class ChatgptLogin(BaseProvider):
76
64
("temperature", "float"),
77
65
]
78
66
param = ", ".join([": ".join(p) for p in params])
79
return f"g4f.provider.{cls.__name__} supports: ({param})"
80
81
82
def _get_nonce() -> str:
83
res = requests.get("https://opchatgpts.net/chatgpt-free-use/",
84
headers = {
85
"Referer" : "https://opchatgpts.net/chatgpt-free-use/",
86
"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"})
87
88
result = re.search(
89
r'class="mwai-chat mwai-chatgpt">.*<span>Send</span></button></div></div></div> <script defer src="(.*?)">',
90
res.text)
91
92
if result is None:
93
return ""
94
95
src = result.group(1)
96
decoded_string = base64.b64decode(src.split(",")[-1]).decode("utf-8")
97
result = re.search(r"let restNonce = '(.*?)';", decoded_string)
98
99
return "" if result is None else result.group(1)
100
101
102
def _transform(messages: list[dict[str, str]]) -> list[dict[str, Any]]:
103
return [
104
{
105
"id" : os.urandom(6).hex(),
106
"role" : message["role"],
107
"content": message["content"],
108
"who" : "AI: " if message["role"] == "assistant" else "User: ",
109
"html" : _html_encode(message["content"]),
110
}
111
for message in messages
112
]
113
114
115
def _html_encode(string: str) -> str:
116
table = {
117
'"' : """,
118
"'" : "'",
119
"&" : "&",
120
">" : ">",
121
"<" : "<",
122
"\n": "<br>",
123
"\t": " ",
124
" " : " ",
125
}
126
127
for key in table:
128
string = string.replace(key, table[key])
129
130
return string
67
return f"g4f.provider.{cls.__name__} supports: ({param})"
@@ -1,25 +1,25 @@
1
1
from __future__ import annotations
2
2
3
3
import json
4
5
4
import js2py
6
import requests
5
from aiohttp import ClientSession
7
6
8
from ..typing import Any, CreateResult
9
from .base_provider import BaseProvider
7
from ..typing import AsyncGenerator
8
from .base_provider import AsyncGeneratorProvider
10
9
11
10
12
class DeepAi(BaseProvider):
11
class DeepAi(AsyncGeneratorProvider):
13
12
url: str = "https://deepai.org"
14
13
working = True
15
supports_stream = True
16
14
supports_gpt_35_turbo = True
17
15
18
16
@staticmethod
19
def create_completion(
17
async def create_async_generator(
20
18
model: str,
21
19
messages: list[dict[str, str]],
22
stream: bool, **kwargs: Any) -> CreateResult:
20
proxy: str = None,
21
**kwargs
22
) -> AsyncGenerator:
23
23
24
24
token_js = """
25
25
var agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36'
@@ -53,10 +53,11 @@ f = function () {
53
53
"api-key": api_key,
54
54
"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",
55
55
}
56
57
response = requests.post("https://api.deepai.org/make_me_a_pizza",
58
headers=headers, data=payload, stream=True)
59
60
for chunk in response.iter_content(chunk_size=None):
61
response.raise_for_status()
62
yield chunk.decode()
56
async with ClientSession(
57
headers=headers
58
) as session:
59
async with session.post("https://api.deepai.org/make_me_a_pizza", proxy=proxy, data=payload) as response:
60
response.raise_for_status()
61
async for stream in response.content.iter_any():
62
if stream:
63
yield stream.decode()
@@ -12,8 +12,7 @@ from .base_provider import AsyncGeneratorProvider, format_prompt
12
12
class H2o(AsyncGeneratorProvider):
13
13
url = "https://gpt-gm.h2o.ai"
14
14
working = True
15
supports_stream = True
16
model = "h2oai/h2ogpt-gm-oasst1-en-2048-falcon-40b-v1"
15
model = "h2oai/h2ogpt-gm-oasst1-en-2048-falcon-40b-v1"
17
16
18
17
@classmethod
19
18
async def create_async_generator(
@@ -24,9 +24,9 @@ class HuggingChat(AsyncGeneratorProvider):
24
24
cookies: dict = None,
25
25
**kwargs
26
26
) -> AsyncGenerator:
27
model = model if model else cls.model
27
28
if not cookies:
28
29
cookies = get_cookies(".huggingface.co")
29
model = model if model else cls.model
30
30
if proxy and "://" not in proxy:
31
31
proxy = f"http://{proxy}"
32
32
@@ -62,36 +62,32 @@ class HuggingChat(AsyncGeneratorProvider):
62
62
"web_search_id": ""
63
63
}
64
64
}
65
start = "data:"
66
first = True
67
65
async with session.post(f"https://huggingface.co/chat/conversation/{conversation_id}", proxy=proxy, json=send) as response:
68
async for line in response.content:
69
line = line.decode("utf-8")
70
if not line:
71
continue
72
if not stream:
73
try:
74
data = json.loads(line)
75
except json.decoder.JSONDecodeError:
76
raise RuntimeError(f"No json: {line}")
77
if "error" in data:
78
raise RuntimeError(data["error"])
79
elif isinstance(data, list):
80
yield data[0]["generated_text"]
81
else:
82
raise RuntimeError(f"Response: {line}")
83
elif line.startswith(start):
84
line = json.loads(line[len(start):-1])
66
if not stream:
67
data = await response.json()
68
if "error" in data:
69
raise RuntimeError(data["error"])
70
elif isinstance(data, list):
71
yield data[0]["generated_text"]
72
else:
73
raise RuntimeError(f"Response: {data}")
74
else:
75
start = "data:"
76
first = True
77
async for line in response.content:
78
line = line.decode("utf-8")
85
79
if not line:
86
80
continue
87
if "token" not in line:
88
raise RuntimeError(f"Response: {line}")
89
if not line["token"]["special"]:
90
if first:
91
yield line["token"]["text"].lstrip()
92
first = False
93
else:
94
yield line["token"]["text"]
81
if line.startswith(start):
82
line = json.loads(line[len(start):-1])
83
if "token" not in line:
84
raise RuntimeError(f"Response: {line}")
85
if not line["token"]["special"]:
86
if first:
87
yield line["token"]["text"].lstrip()
88
first = False
89
else:
90
yield line["token"]["text"]
95
91
96
92
async with session.delete(f"https://huggingface.co/chat/conversation/{conversation_id}", proxy=proxy) as response:
97
93
response.raise_for_status()
@@ -32,7 +32,6 @@ models = {
32
32
class Liaobots(AsyncGeneratorProvider):
33
33
url = "https://liaobots.com"
34
34
working = True
35
supports_stream = True
36
35
supports_gpt_35_turbo = True
37
36
supports_gpt_4 = True
38
37
_auth_code = None
@@ -46,24 +45,24 @@ class Liaobots(AsyncGeneratorProvider):
46
45
proxy: str = None,
47
46
**kwargs
48
47
) -> AsyncGenerator:
48
model = model if model in models else "gpt-3.5-turbo"
49
49
if proxy and "://" not in proxy:
50
50
proxy = f"http://{proxy}"
51
51
headers = {
52
52
"authority": "liaobots.com",
53
53
"content-type": "application/json",
54
"origin": "https://liaobots.com",
55
"referer": "https://liaobots.com/",
54
"origin": cls.url,
55
"referer": cls.url + "/",
56
56
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36",
57
57
}
58
58
async with ClientSession(
59
59
headers=headers
60
60
) as session:
61
model = model if model in models else "gpt-3.5-turbo"
62
61
auth_code = auth if isinstance(auth, str) else cls._auth_code
63
62
if not auth_code:
64
async with session.post("https://liaobots.com/api/user", proxy=proxy, json={"authcode": ""}) as response:
63
async with session.post(cls.url + "/api/user", proxy=proxy, json={"authcode": ""}) as response:
65
64
response.raise_for_status()
66
auth_code = cls._auth_code = json.loads((await response.text()))["authCode"]
65
auth_code = cls._auth_code = json.loads(await response.text())["authCode"]
67
66
data = {
68
67
"conversationId": str(uuid.uuid4()),
69
68
"model": models[model],
@@ -71,10 +70,11 @@ class Liaobots(AsyncGeneratorProvider):
71
70
"key": "",
72
71
"prompt": "You are ChatGPT, a large language model trained by OpenAI. Follow the user's instructions carefully.",
73
72
}
74
async with session.post("https://liaobots.com/api/chat", proxy=proxy, json=data, headers={"x-auth-code": auth_code}) as response:
73
async with session.post(cls.url + "/api/chat", proxy=proxy, json=data, headers={"x-auth-code": auth_code}) as response:
75
74
response.raise_for_status()
76
async for line in response.content:
77
yield line.decode("utf-8")
75
async for stream in response.content.iter_any():
76
if stream:
77
yield stream.decode()
78
78
79
79
80
80
@classmethod
@@ -1,60 +1,8 @@
1
1
from __future__ import annotations
2
2
3
import requests
3
from .ChatgptLogin import ChatgptLogin
4
4
5
from ..typing import Any, CreateResult
6
from .base_provider import BaseProvider
7
5
8
9
class Opchatgpts(BaseProvider):
10
url = "https://opchatgpts.net"
11
working = True
12
supports_gpt_35_turbo = True
13
14
@staticmethod
15
def create_completion(
16
model: str,
17
messages: list[dict[str, str]],
18
stream: bool, **kwargs: Any) -> CreateResult:
19
20
temperature = kwargs.get("temperature", 0.8)
21
max_tokens = kwargs.get("max_tokens", 1024)
22
system_prompt = kwargs.get(
23
"system_prompt",
24
"Converse as if you were an AI assistant. Be friendly, creative.")
25
26
payload = _create_payload(
27
messages = messages,
28
temperature = temperature,
29
max_tokens = max_tokens,
30
system_prompt = system_prompt)
31
32
response = requests.post("https://opchatgpts.net/wp-json/ai-chatbot/v1/chat", json=payload)
33
34
response.raise_for_status()
35
yield response.json()["reply"]
36
37
38
def _create_payload(
39
messages: list[dict[str, str]],
40
temperature: float,
41
max_tokens: int, system_prompt: str) -> dict:
42
43
return {
44
"env" : "chatbot",
45
"session" : "N/A",
46
"prompt" : "\n",
47
"context" : system_prompt,
48
"messages" : messages,
49
"newMessage" : messages[::-1][0]["content"],
50
"userName" : '<div class="mwai-name-text">User:</div>',
51
"aiName" : '<div class="mwai-name-text">AI:</div>',
52
"model" : "gpt-3.5-turbo",
53
"temperature" : temperature,
54
"maxTokens" : max_tokens,
55
"maxResults" : 1,
56
"apiKey" : "",
57
"service" : "openai",
58
"embeddingsIndex" : "",
59
"stop" : "",
60
}
6
class Opchatgpts(ChatgptLogin):
7
url = "https://opchatgpts.net"
8
working = True