返回提交历史
Added
g4f/Provider/not_working/Aichatos.py
+56
-0
Added
g4f/Provider/not_working/ChatForAi.py
+66
-0
Added
g4f/Provider/not_working/ChatgptAi.py
+88
-0
Added
g4f/Provider/not_working/ChatgptNext.py
+66
-0
Added
g4f/Provider/not_working/ChatgptX.py
+106
-0
Added
g4f/Provider/not_working/Cnote.py
+58
-0
Added
g4f/Provider/not_working/Feedough.py
+78
-0
Modified
g4f/Provider/not_working/__init__.py
+8
-1
XFEstudio/gpt4free
Add files via upload
051dfc15
代码差异
8 个文件
+526
-1
@@ -0,0 +1,56 @@
1
from __future__ import annotations
2
3
from aiohttp import ClientSession
4
5
from ...typing import AsyncResult, Messages
6
from ..base_provider import AsyncGeneratorProvider
7
from ..helper import format_prompt
8
9
import random
10
11
class Aichatos(AsyncGeneratorProvider):
12
url = "https://chat10.aichatos.xyz"
13
api = "https://api.binjie.fun"
14
working = False
15
supports_gpt_35_turbo = True
16
17
@classmethod
18
async def create_async_generator(
19
cls,
20
model: str,
21
messages: Messages,
22
proxy: str = None,
23
**kwargs
24
) -> AsyncResult:
25
headers = {
26
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
27
"Accept": "application/json, text/plain, */*",
28
"Accept-Language": "en-US,en;q=0.5",
29
"Accept-Encoding": "gzip, deflate, br",
30
"Content-Type": "application/json",
31
"Origin": "https://chat10.aichatos.xyz",
32
"DNT": "1",
33
"Sec-GPC": "1",
34
"Connection": "keep-alive",
35
"Sec-Fetch-Dest": "empty",
36
"Sec-Fetch-Mode": "cors",
37
"Sec-Fetch-Site": "cross-site",
38
"TE": "trailers",
39
}
40
async with ClientSession(headers=headers) as session:
41
prompt = format_prompt(messages)
42
userId = random.randint(1000000000000, 9999999999999)
43
system_message: str = "",
44
data = {
45
"prompt": prompt,
46
"userId": "#/chat/{userId}",
47
"network": True,
48
"system": system_message,
49
"withoutContext": False,
50
"stream": True,
51
}
52
async with session.post(f"{cls.api}/api/generateStream", json=data, proxy=proxy) as response:
53
response.raise_for_status()
54
async for chunk in response.content:
55
if chunk:
56
yield chunk.decode()
@@ -0,0 +1,66 @@
1
from __future__ import annotations
2
3
import time
4
import hashlib
5
import uuid
6
7
from ...typing import AsyncResult, Messages
8
from ...requests import StreamSession, raise_for_status
9
from ...errors import RateLimitError
10
from ..base_provider import AsyncGeneratorProvider, ProviderModelMixin
11
12
class ChatForAi(AsyncGeneratorProvider, ProviderModelMixin):
13
url = "https://chatforai.store"
14
working = False
15
default_model = "gpt-3.5-turbo"
16
supports_message_history = True
17
supports_gpt_35_turbo = True
18
19
@classmethod
20
async def create_async_generator(
21
cls,
22
model: str,
23
messages: Messages,
24
proxy: str = None,
25
timeout: int = 120,
26
temperature: float = 0.7,
27
top_p: float = 1,
28
**kwargs
29
) -> AsyncResult:
30
model = cls.get_model(model)
31
headers = {
32
"Content-Type": "text/plain;charset=UTF-8",
33
"Origin": cls.url,
34
"Referer": f"{cls.url}/?r=b",
35
}
36
async with StreamSession(impersonate="chrome", headers=headers, proxies={"https": proxy}, timeout=timeout) as session:
37
timestamp = int(time.time() * 1e3)
38
conversation_id = str(uuid.uuid4())
39
data = {
40
"conversationId": conversation_id,
41
"conversationType": "chat_continuous",
42
"botId": "chat_continuous",
43
"globalSettings":{
44
"baseUrl": "https://api.openai.com",
45
"model": model,
46
"messageHistorySize": 5,
47
"temperature": temperature,
48
"top_p": top_p,
49
**kwargs
50
},
51
"prompt": "",
52
"messages": messages,
53
"timestamp": timestamp,
54
"sign": generate_signature(timestamp, "", conversation_id)
55
}
56
async with session.post(f"{cls.url}/api/handle/provider-openai", json=data) as response:
57
await raise_for_status(response)
58
async for chunk in response.iter_content():
59
if b"https://chatforai.store" in chunk:
60
raise RuntimeError(f"Response: {chunk.decode(errors='ignore')}")
61
yield chunk.decode(errors="ignore")
62
63
64
def generate_signature(timestamp: int, message: str, id: str):
65
buffer = f"{id}:{timestamp}:{message}:h496Jd6b"
66
return hashlib.sha256(buffer.encode()).hexdigest()
@@ -0,0 +1,88 @@
1
from __future__ import annotations
2
3
import re, html, json, string, random
4
from aiohttp import ClientSession
5
6
from ...typing import Messages, AsyncResult
7
from ...errors import RateLimitError
8
from ..base_provider import AsyncGeneratorProvider
9
from ..helper import get_random_string
10
11
class ChatgptAi(AsyncGeneratorProvider):
12
url = "https://chatgpt.ai"
13
working = False
14
supports_message_history = True
15
supports_system_message = True,
16
supports_gpt_4 = True,
17
_system = None
18
19
@classmethod
20
async def create_async_generator(
21
cls,
22
model: str,
23
messages: Messages,
24
proxy: str = None,
25
**kwargs
26
) -> AsyncResult:
27
headers = {
28
"authority" : "chatgpt.ai",
29
"accept" : "*/*",
30
"accept-language" : "en-US",
31
"cache-control" : "no-cache",
32
"origin" : cls.url,
33
"pragma" : "no-cache",
34
"referer" : f"{cls.url}/",
35
"sec-ch-ua" : '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
36
"sec-ch-ua-mobile" : "?0",
37
"sec-ch-ua-platform" : '"Windows"',
38
"sec-fetch-dest" : "empty",
39
"sec-fetch-mode" : "cors",
40
"sec-fetch-site" : "same-origin",
41
"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",
42
}
43
async with ClientSession(
44
headers=headers
45
) as session:
46
if not cls._system:
47
async with session.get(cls.url, proxy=proxy) as response:
48
response.raise_for_status()
49
text = await response.text()
50
result = re.search(r"data-system='(.*?)'", text)
51
if result :
52
cls._system = json.loads(html.unescape(result.group(1)))
53
if not cls._system:
54
raise RuntimeError("System args not found")
55
56
data = {
57
"botId": cls._system["botId"],
58
"customId": cls._system["customId"],
59
"session": cls._system["sessionId"],
60
"chatId": get_random_string(),
61
"contextId": cls._system["contextId"],
62
"messages": messages[:-1],
63
"newMessage": messages[-1]["content"],
64
"newFileId": None,
65
"stream":True
66
}
67
async with session.post(
68
"https://chatgate.ai/wp-json/mwai-ui/v1/chats/submit",
69
proxy=proxy,
70
json=data,
71
headers={"X-Wp-Nonce": cls._system["restNonce"]}
72
) as response:
73
response.raise_for_status()
74
async for line in response.content:
75
if line.startswith(b"data: "):
76
try:
77
line = json.loads(line[6:])
78
assert "type" in line
79
except:
80
raise RuntimeError(f"Broken line: {line.decode()}")
81
if line["type"] == "error":
82
if "https://chatgate.ai/login" in line["data"]:
83
raise RateLimitError("Rate limit reached")
84
raise RuntimeError(line["data"])
85
if line["type"] == "live":
86
yield line["data"]
87
elif line["type"] == "end":
88
break
@@ -0,0 +1,66 @@
1
from __future__ import annotations
2
3
import json
4
from aiohttp import ClientSession
5
6
from ...typing import AsyncResult, Messages
7
from ..base_provider import AsyncGeneratorProvider
8
9
class ChatgptNext(AsyncGeneratorProvider):
10
url = "https://www.chatgpt-free.cc"
11
working = False
12
supports_gpt_35_turbo = True
13
supports_message_history = True
14
supports_system_message = True
15
16
@classmethod
17
async def create_async_generator(
18
cls,
19
model: str,
20
messages: Messages,
21
proxy: str = None,
22
max_tokens: int = None,
23
temperature: float = 0.7,
24
top_p: float = 1,
25
presence_penalty: float = 0,
26
frequency_penalty: float = 0,
27
**kwargs
28
) -> AsyncResult:
29
if not model:
30
model = "gpt-3.5-turbo"
31
headers = {
32
"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:122.0) Gecko/20100101 Firefox/122.0",
33
"Accept": "text/event-stream",
34
"Accept-Language": "de,en-US;q=0.7,en;q=0.3",
35
"Accept-Encoding": "gzip, deflate, br",
36
"Content-Type": "application/json",
37
"Referer": "https://chat.fstha.com/",
38
"x-requested-with": "XMLHttpRequest",
39
"Origin": "https://chat.fstha.com",
40
"Sec-Fetch-Dest": "empty",
41
"Sec-Fetch-Mode": "cors",
42
"Sec-Fetch-Site": "same-origin",
43
"Authorization": "Bearer ak-chatgpt-nice",
44
"Connection": "keep-alive",
45
"Alt-Used": "chat.fstha.com",
46
}
47
async with ClientSession(headers=headers) as session:
48
data = {
49
"messages": messages,
50
"stream": True,
51
"model": model,
52
"temperature": temperature,
53
"presence_penalty": presence_penalty,
54
"frequency_penalty": frequency_penalty,
55
"top_p": top_p,
56
"max_tokens": max_tokens,
57
}
58
async with session.post(f"https://chat.fstha.com/api/openai/v1/chat/completions", json=data, proxy=proxy) as response:
59
response.raise_for_status()
60
async for chunk in response.content:
61
if chunk.startswith(b"data: [DONE]"):
62
break
63
if chunk.startswith(b"data: "):
64
content = json.loads(chunk[6:])["choices"][0]["delta"].get("content")
65
if content:
66
yield content
@@ -0,0 +1,106 @@
1
from __future__ import annotations
2
3
import re
4
import json
5
6
from aiohttp import ClientSession
7
from ...typing import AsyncResult, Messages
8
from ..base_provider import AsyncGeneratorProvider
9
from ..helper import format_prompt
10
from ...errors import RateLimitError
11
12
class ChatgptX(AsyncGeneratorProvider):
13
url = "https://chatgptx.de"
14
supports_gpt_35_turbo = True
15
working = False
16
17
@classmethod
18
async def create_async_generator(
19
cls,
20
model: str,
21
messages: Messages,
22
proxy: str = None,
23
**kwargs
24
) -> AsyncResult:
25
headers = {
26
'accept-language': 'de-DE,de;q=0.9,en-DE;q=0.8,en;q=0.7,en-US',
27
'sec-ch-ua': '"Google Chrome";v="117", "Not;A=Brand";v="8", "Chromium";v="117"',
28
'sec-ch-ua-mobile': '?0',
29
'sec-ch-ua-platform': 'Linux',
30
'sec-fetch-dest': 'empty',
31
'sec-fetch-mode': 'cors',
32
'sec-fetch-site': 'same-origin',
33
'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36',
34
}
35
async with ClientSession(headers=headers) as session:
36
async with session.get(f"{cls.url}/", proxy=proxy) as response:
37
response = await response.text()
38
39
result = re.search(
40
r'<meta name="csrf-token" content="(.*?)"', response
41
)
42
if result:
43
csrf_token = result.group(1)
44
45
result = re.search(r"openconversions\('(.*?)'\)", response)
46
if result:
47
chat_id = result.group(1)
48
49
result = re.search(
50
r'<input type="hidden" id="user_id" value="(.*?)"', response
51
)
52
if result:
53
user_id = result.group(1)
54
55
if not csrf_token or not chat_id or not user_id:
56
raise RuntimeError("Missing csrf_token, chat_id or user_id")
57
58
data = {
59
'_token': csrf_token,
60
'user_id': user_id,
61
'chats_id': chat_id,
62
'prompt': format_prompt(messages),
63
'current_model': "gpt3"
64
}
65
headers = {
66
'authority': 'chatgptx.de',
67
'accept': 'application/json, text/javascript, */*; q=0.01',
68
'origin': cls.url,
69
'referer': f'{cls.url}/',
70
'x-csrf-token': csrf_token,
71
'x-requested-with': 'XMLHttpRequest'
72
}
73
async with session.post(f'{cls.url}/sendchat', data=data, headers=headers, proxy=proxy) as response:
74
response.raise_for_status()
75
chat = await response.json()
76
if "messages" in chat and "Anfragelimit" in chat["messages"]:
77
raise RateLimitError("Rate limit reached")
78
if "response" not in chat or not chat["response"]:
79
raise RuntimeError(f'Response: {chat}')
80
headers = {
81
'authority': 'chatgptx.de',
82
'accept': 'text/event-stream',
83
'referer': f'{cls.url}/',
84
'x-csrf-token': csrf_token,
85
'x-requested-with': 'XMLHttpRequest'
86
}
87
data = {
88
"user_id": user_id,
89
"chats_id": chat_id,
90
"current_model": "gpt3",
91
"conversions_id": chat["conversions_id"],
92
"ass_conversions_id": chat["ass_conversions_id"],
93
}
94
async with session.get(f'{cls.url}/chats_stream', params=data, headers=headers, proxy=proxy) as response:
95
response.raise_for_status()
96
async for line in response.content:
97
if line.startswith(b"data: "):
98
row = line[6:-1]
99
if row == b"[DONE]":
100
break
101
try:
102
content = json.loads(row)["choices"][0]["delta"].get("content")
103
except:
104
raise RuntimeError(f"Broken line: {line.decode()}")
105
if content:
106
yield content
@@ -0,0 +1,58 @@
1
from __future__ import annotations
2
3
import json
4
from aiohttp import ClientSession
5
6
from ...typing import AsyncResult, Messages
7
from ..base_provider import AsyncGeneratorProvider
8
from ..helper import format_prompt
9
10
11
class Cnote(AsyncGeneratorProvider):
12
url = "https://f1.cnote.top"
13
api_url = "https://p1api.xjai.pro/freeapi/chat-process"
14
working = False
15
supports_gpt_35_turbo = True
16
17
@classmethod
18
async def create_async_generator(
19
cls,
20
model: str,
21
messages: Messages,
22
proxy: str = None,
23
**kwargs
24
) -> AsyncResult:
25
headers = {
26
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
27
"Accept": "application/json, text/plain, */*",
28
"Accept-Language": "en-US,en;q=0.5",
29
"Accept-Encoding": "gzip, deflate, br",
30
"Content-Type": "application/json",
31
"Origin": cls.url,
32
"DNT": "1",
33
"Sec-GPC": "1",
34
"Connection": "keep-alive",
35
"Sec-Fetch-Dest": "empty",
36
"Sec-Fetch-Mode": "cors",
37
"Sec-Fetch-Site": "cross-site",
38
"TE": "trailers",
39
}
40
async with ClientSession(headers=headers) as session:
41
prompt = format_prompt(messages)
42
system_message: str = "",
43
data = {
44
"prompt": prompt,
45
"systemMessage": system_message,
46
"temperature": 0.8,
47
"top_p": 1,
48
}
49
async with session.post(cls.api_url, json=data, proxy=proxy) as response:
50
response.raise_for_status()
51
async for chunk in response.content:
52
if chunk:
53
try:
54
data = json.loads(chunk.decode().split("&KFw6loC9Qvy&")[-1])
55
text = data.get("text", "")
56
yield text
57
except (json.JSONDecodeError, IndexError):
58
pass
@@ -0,0 +1,78 @@
1
from __future__ import annotations
2
3
import json
4
import asyncio
5
from aiohttp import ClientSession, TCPConnector
6
from urllib.parse import urlencode
7
8
from ..typing import AsyncResult, Messages
9
from .base_provider import AsyncGeneratorProvider, ProviderModelMixin
10
from .helper import format_prompt
11
12
13
class Feedough(AsyncGeneratorProvider, ProviderModelMixin):
14
url = "https://www.feedough.com"
15
api_endpoint = "/wp-admin/admin-ajax.php"
16
working = False
17
default_model = ''
18
19
@classmethod
20
async def create_async_generator(
21
cls,
22
model: str,
23
messages: Messages,
24
proxy: str = None,
25
**kwargs
26
) -> AsyncResult:
27
headers = {
28
"accept": "*/*",
29
"accept-language": "en-US,en;q=0.9",
30
"content-type": "application/x-www-form-urlencoded;charset=UTF-8",
31
"dnt": "1",
32
"origin": cls.url,
33
"referer": f"{cls.url}/ai-prompt-generator/",
34
"sec-ch-ua": '"Not/A)Brand";v="8", "Chromium";v="126"',
35
"sec-ch-ua-mobile": "?0",
36
"sec-ch-ua-platform": '"Linux"',
37
"sec-fetch-dest": "empty",
38
"sec-fetch-mode": "cors",
39
"sec-fetch-site": "same-origin",
40
"user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
41
}
42
43
connector = TCPConnector(ssl=False)
44
45
async with ClientSession(headers=headers, connector=connector) as session:
46
data = {
47
"action": "aixg_generate",
48
"prompt": format_prompt(messages),
49
"aixg_generate_nonce": "110c021031"
50
}
51
52
try:
53
async with session.post(
54
f"{cls.url}{cls.api_endpoint}",
55
data=urlencode(data),
56
proxy=proxy
57
) as response:
58
response.raise_for_status()
59
response_text = await response.text()
60
try:
61
response_json = json.loads(response_text)
62
if response_json.get("success") and "data" in response_json:
63
message = response_json["data"].get("message", "")
64
yield message
65
except json.JSONDecodeError:
66
yield response_text
67
except Exception as e:
68
print(f"An error occurred: {e}")
69
70
@classmethod
71
async def run(cls, *args, **kwargs):
72
async for item in cls.create_async_generator(*args, **kwargs):
73
yield item
74
75
tasks = asyncio.all_tasks()
76
for task in tasks:
77
if not task.done():
78
await task
@@ -1,14 +1,21 @@
1
1
2
2
from .AItianhu import AItianhu
3
from .Aichatos import Aichatos
3
4
from .Bestim import Bestim
4
5
from .ChatBase import ChatBase
6
from .ChatForAi import ChatForAi
7
from .ChatgptAi import ChatgptAi
5
8
from .ChatgptDemo import ChatgptDemo
6
9
from .ChatgptDemoAi import ChatgptDemoAi
7
10
from .ChatgptLogin import ChatgptLogin
11
from .ChatgptNext import ChatgptNext
12
from .ChatgptX import ChatgptX
8
13
from .Chatxyz import Chatxyz
14
from .Cnote import Cnote
15
from .Feedough import Feedough
9
16
from .Gpt6 import Gpt6
10
17
from .GptChatly import GptChatly
11
18
from .GptForLove import GptForLove
12
19
from .GptGo import GptGo
13
20
from .GptGod import GptGod
14
from .OnlineGpt import OnlineGpt
21
from .OnlineGpt import OnlineGpt