返回提交历史
Modified
g4f/Provider/needs_auth/OpenaiChat.py
+28
-27
Modified
g4f/Provider/openai/har_file.py
+15
-15
XFEstudio/gpt4free
refactor: use dependency injection for RequestConfig
f02b2c50
代码差异
2 个文件
+43
-42
@@ -102,6 +102,7 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
102
102
vision_models = text_models
103
103
models = models
104
104
synthesize_content_type = "audio/mpeg"
105
request_config = RequestConfig()
105
106
106
107
_api_key: str = None
107
108
_headers: dict = None
@@ -114,11 +115,11 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
114
115
yield chunk
115
116
yield AuthResult(
116
117
api_key=cls._api_key,
117
cookies=cls._cookies or RequestConfig.cookies or {},
118
headers=cls._headers or RequestConfig.headers or cls.get_default_headers(),
118
cookies=cls._cookies or cls.request_config.cookies or {},
119
headers=cls._headers or cls.request_config.headers or cls.get_default_headers(),
119
120
expires=cls._expires,
120
proof_token=RequestConfig.proof_token,
121
turnstile_token=RequestConfig.turnstile_token
121
proof_token=cls.request_config.proof_token,
122
turnstile_token=cls.request_config.turnstile_token
122
123
)
123
124
124
125
@classmethod
@@ -352,7 +353,7 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
352
353
need_arkose = chat_requirements.get("arkose", {}).get("required", False)
353
354
chat_token = chat_requirements.get("token")
354
355
355
# if need_arkose and RequestConfig.arkose_token is None:
356
# if need_arkose and cls.request_config.arkose_token is None:
356
357
# await get_request_config(proxy)
357
358
# cls._create_request_args(auth_result.cookies, auth_result.headers)
358
359
# cls._set_api_key(auth_result.access_token)
@@ -409,8 +410,8 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
409
410
"content-type": "application/json",
410
411
"openai-sentinel-chat-requirements-token": chat_token,
411
412
}
412
#if RequestConfig.arkose_token:
413
# headers["openai-sentinel-arkose-token"] = RequestConfig.arkose_token
413
#if cls.request_config.arkose_token:
414
# headers["openai-sentinel-arkose-token"] = cls.request_config.arkose_token
414
415
if proofofwork is not None:
415
416
headers["openai-sentinel-proof-token"] = proofofwork
416
417
if need_turnstile and getattr(auth_result, "turnstile_token", None) is not None:
@@ -425,7 +426,7 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
425
426
cls._update_request_args(auth_result, session)
426
427
if response.status == 403:
427
428
auth_result.proof_token = None
428
RequestConfig.proof_token = None
429
cls.request_config.proof_token = None
429
430
await raise_for_status(response)
430
431
buffer = u""
431
432
async for line in response.iter_lines():
@@ -471,7 +472,7 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
471
472
yield Parameters(**{
472
473
"action": "continue" if conversation.finish_reason == "max_tokens" else "variant",
473
474
"conversation": conversation.get_dict(),
474
"proof_token": RequestConfig.proof_token,
475
"proof_token": cls.request_config.proof_token,
475
476
"cookies": cls._cookies,
476
477
"headers": cls._headers,
477
478
"web_search": web_search,
@@ -576,19 +577,19 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
576
577
if cls._headers is None or headers is not None:
577
578
cls._headers = {} if headers is None else headers
578
579
if proof_token is not None:
579
RequestConfig.proof_token = proof_token
580
cls.request_config.proof_token = proof_token
580
581
if cookies is not None:
581
RequestConfig.cookies = cookies
582
cls.request_config.cookies = cookies
582
583
if api_key is not None:
583
cls._create_request_args(RequestConfig.cookies, RequestConfig.headers)
584
cls._create_request_args(cls.request_config.cookies, cls.request_config.headers)
584
585
cls._set_api_key(api_key)
585
586
else:
586
587
try:
587
await get_request_config(proxy)
588
cls._create_request_args(RequestConfig.cookies, RequestConfig.headers)
589
if RequestConfig.access_token is not None or cls.needs_auth:
590
if not cls._set_api_key(RequestConfig.access_token):
591
raise NoValidHarFileError(f"Access token is not valid: {RequestConfig.access_token}")
588
await get_request_config(cls.request_config, proxy)
589
cls._create_request_args(cls.request_config.cookies, cls.request_config.headers)
590
if cls.request_config.access_token is not None or cls.needs_auth:
591
if not cls._set_api_key(cls.request_config.access_token):
592
raise NoValidHarFileError(f"Access token is not valid: {cls.request_config.access_token}")
592
593
except NoValidHarFileError:
593
594
if has_nodriver:
594
595
if cls._api_key is None:
@@ -600,8 +601,8 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
600
601
raise
601
602
yield Parameters(**{
602
603
"api_key": cls._api_key,
603
"proof_token": RequestConfig.proof_token,
604
"cookies": RequestConfig.cookies,
604
"proof_token": cls.request_config.proof_token,
605
"cookies": cls.request_config.cookies,
605
606
})
606
607
607
608
@classmethod
@@ -611,18 +612,18 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
611
612
page = browser.main_tab
612
613
def on_request(event: nodriver.cdp.network.RequestWillBeSent):
613
614
if event.request.url == start_url or event.request.url.startswith(conversation_url):
614
RequestConfig.headers = event.request.headers
615
cls.request_config.headers = event.request.headers
615
616
elif event.request.url in (backend_url, backend_anon_url):
616
617
if "OpenAI-Sentinel-Proof-Token" in event.request.headers:
617
RequestConfig.proof_token = json.loads(base64.b64decode(
618
cls.request_config.proof_token = json.loads(base64.b64decode(
618
619
event.request.headers["OpenAI-Sentinel-Proof-Token"].split("gAAAAAB", 1)[-1].encode()
619
620
).decode())
620
621
if "OpenAI-Sentinel-Turnstile-Token" in event.request.headers:
621
RequestConfig.turnstile_token = event.request.headers["OpenAI-Sentinel-Turnstile-Token"]
622
cls.request_config.turnstile_token = event.request.headers["OpenAI-Sentinel-Turnstile-Token"]
622
623
if "Authorization" in event.request.headers:
623
624
cls._api_key = event.request.headers["Authorization"].split()[-1]
624
625
elif event.request.url == arkose_url:
625
RequestConfig.arkose_request = arkReq(
626
cls.request_config.arkose_request = arkReq(
626
627
arkURL=event.request.url,
627
628
arkBx=None,
628
629
arkHeader=event.request.headers,
@@ -647,13 +648,13 @@ class OpenaiChat(AsyncAuthedProvider, ProviderModelMixin):
647
648
break
648
649
await asyncio.sleep(1)
649
650
while True:
650
if RequestConfig.proof_token:
651
if cls.request_config.proof_token:
651
652
break
652
653
await asyncio.sleep(1)
653
RequestConfig.data_build = await page.evaluate("document.documentElement.getAttribute('data-build')")
654
RequestConfig.cookies = await page.send(get_cookies([cls.url]))
654
cls.request_config.data_build = await page.evaluate("document.documentElement.getAttribute('data-build')")
655
cls.request_config.cookies = await page.send(get_cookies([cls.url]))
655
656
await page.close()
656
cls._create_request_args(RequestConfig.cookies, RequestConfig.headers, user_agent=user_agent)
657
cls._create_request_args(cls.request_config.cookies, cls.request_config.headers, user_agent=user_agent)
657
658
cls._set_api_key(cls._api_key)
658
659
finally:
659
660
stop_browser()
@@ -56,7 +56,7 @@ def get_har_files():
56
56
harPath.sort(key=lambda x: os.path.getmtime(x))
57
57
return harPath
58
58
59
def readHAR():
59
def readHAR(request_config: RequestConfig):
60
60
for path in get_har_files():
61
61
with open(path, 'rb') as file:
62
62
try:
@@ -67,28 +67,28 @@ def readHAR():
67
67
for v in harFile['log']['entries']:
68
68
v_headers = get_headers(v)
69
69
if arkose_url == v['request']['url']:
70
RequestConfig.arkose_request = parseHAREntry(v)
70
request_config.arkose_request = parseHAREntry(v)
71
71
elif v['request']['url'].startswith(start_url):
72
72
try:
73
73
match = re.search(r'"accessToken":"(.*?)"', v["response"]["content"]["text"])
74
74
if match:
75
RequestConfig.access_token = match.group(1)
75
request_config.access_token = match.group(1)
76
76
except KeyError:
77
77
pass
78
78
try:
79
79
if "openai-sentinel-proof-token" in v_headers:
80
RequestConfig.headers = v_headers
81
RequestConfig.proof_token = json.loads(base64.b64decode(
80
request_config.headers = v_headers
81
request_config.proof_token = json.loads(base64.b64decode(
82
82
v_headers["openai-sentinel-proof-token"].split("gAAAAAB", 1)[-1].encode()
83
83
).decode())
84
84
if "openai-sentinel-turnstile-token" in v_headers:
85
RequestConfig.turnstile_token = v_headers["openai-sentinel-turnstile-token"]
85
request_config.turnstile_token = v_headers["openai-sentinel-turnstile-token"]
86
86
if "authorization" in v_headers:
87
RequestConfig.access_token = v_headers["authorization"].split(" ")[1]
88
RequestConfig.cookies = {c['name']: c['value'] for c in v['request']['cookies']}
87
request_config.access_token = v_headers["authorization"].split(" ")[1]
88
request_config.cookies = {c['name']: c['value'] for c in v['request']['cookies']}
89
89
except Exception as e:
90
90
debug.log(f"Error on read headers: {e}")
91
if RequestConfig.proof_token is None:
91
if request_config.proof_token is None:
92
92
raise NoValidHarFileError("No proof_token found in .har files")
93
93
94
94
def get_headers(entry) -> dict:
@@ -153,9 +153,9 @@ def getN() -> str:
153
153
timestamp = str(int(time.time()))
154
154
return base64.b64encode(timestamp.encode()).decode()
155
155
156
async def get_request_config(proxy: str) -> RequestConfig:
157
if RequestConfig.proof_token is None:
158
readHAR()
159
if RequestConfig.arkose_request is not None:
160
RequestConfig.arkose_token = await sendRequest(genArkReq(RequestConfig.arkose_request), proxy)
161
return RequestConfig
156
async def get_request_config(request_config: RequestConfig, proxy: str) -> RequestConfig:
157
if request_config.proof_token is None:
158
readHAR(request_config)
159
if request_config.arkose_request is not None:
160
request_config.arkose_token = await sendRequest(genArkReq(request_config.arkose_request), proxy)
161
return request_config