2023-09-03 04:26:26 -04:00
|
|
|
from __future__ import annotations
|
2024-01-26 01:54:13 -05:00
|
|
|
|
2024-01-14 01:45:41 -05:00
|
|
|
import asyncio
|
|
|
|
import uuid
|
|
|
|
import json
|
|
|
|
import os
|
2024-02-28 01:36:43 -05:00
|
|
|
import base64
|
2024-03-08 05:01:38 -05:00
|
|
|
import time
|
2024-02-28 01:36:43 -05:00
|
|
|
from aiohttp import ClientWebSocketResponse
|
2023-09-03 04:26:26 -04:00
|
|
|
|
2024-01-26 01:54:13 -05:00
|
|
|
try:
|
|
|
|
from py_arkose_generator.arkose import get_values_for_request
|
|
|
|
from async_property import async_cached_property
|
|
|
|
has_requirements = True
|
|
|
|
except ImportError:
|
|
|
|
async_cached_property = property
|
|
|
|
has_requirements = False
|
|
|
|
try:
|
|
|
|
from selenium.webdriver.common.by import By
|
|
|
|
from selenium.webdriver.support.ui import WebDriverWait
|
|
|
|
from selenium.webdriver.support import expected_conditions as EC
|
|
|
|
except ImportError:
|
2024-01-26 06:49:52 -05:00
|
|
|
pass
|
2023-12-31 19:51:49 -05:00
|
|
|
|
2024-01-23 13:44:48 -05:00
|
|
|
from ..base_provider import AsyncGeneratorProvider, ProviderModelMixin
|
2024-02-26 17:41:06 -05:00
|
|
|
from ..helper import get_cookies
|
|
|
|
from ...webdriver import get_browser
|
2024-02-28 01:36:43 -05:00
|
|
|
from ...typing import AsyncResult, Messages, Cookies, ImageType, Union, AsyncIterator
|
2024-02-23 05:33:38 -05:00
|
|
|
from ...requests import get_args_from_browser
|
|
|
|
from ...requests.aiohttp import StreamSession
|
2024-01-26 01:54:13 -05:00
|
|
|
from ...image import to_image, to_bytes, ImageResponse, ImageRequest
|
2024-02-08 16:02:52 -05:00
|
|
|
from ...errors import MissingRequirementsError, MissingAuthError
|
2024-02-23 05:33:38 -05:00
|
|
|
from ... import debug
|
2023-09-03 04:26:26 -04:00
|
|
|
|
2024-01-23 13:44:48 -05:00
|
|
|
class OpenaiChat(AsyncGeneratorProvider, ProviderModelMixin):
|
2024-01-14 01:45:41 -05:00
|
|
|
"""A class for creating and managing conversations with OpenAI chat service"""
|
|
|
|
|
|
|
|
url = "https://chat.openai.com"
|
|
|
|
working = True
|
|
|
|
needs_auth = True
|
2023-08-25 00:41:32 -04:00
|
|
|
supports_gpt_35_turbo = True
|
2024-01-14 01:45:41 -05:00
|
|
|
supports_gpt_4 = True
|
2024-02-26 17:41:06 -05:00
|
|
|
supports_message_history = True
|
2024-02-28 01:36:43 -05:00
|
|
|
supports_system_message = True
|
2024-01-23 13:44:48 -05:00
|
|
|
default_model = None
|
2024-01-26 01:54:13 -05:00
|
|
|
models = ["gpt-3.5-turbo", "gpt-4", "gpt-4-gizmo"]
|
2024-02-28 01:36:43 -05:00
|
|
|
model_aliases = {"text-davinci-002-render-sha": "gpt-3.5-turbo", "": "gpt-3.5-turbo"}
|
|
|
|
_api_key: str = None
|
|
|
|
_headers: dict = None
|
|
|
|
_cookies: Cookies = None
|
2024-03-08 05:01:38 -05:00
|
|
|
_expires: int = None
|
2023-11-18 23:36:04 -05:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
async def create(
|
|
|
|
cls,
|
|
|
|
prompt: str = None,
|
|
|
|
model: str = "",
|
|
|
|
messages: Messages = [],
|
|
|
|
history_disabled: bool = False,
|
|
|
|
action: str = "next",
|
|
|
|
conversation_id: str = None,
|
|
|
|
parent_id: str = None,
|
2024-01-13 09:37:36 -05:00
|
|
|
image: ImageType = None,
|
2023-11-18 23:36:04 -05:00
|
|
|
**kwargs
|
|
|
|
) -> Response:
|
2024-01-14 09:35:58 -05:00
|
|
|
"""
|
|
|
|
Create a new conversation or continue an existing one
|
2024-01-14 01:45:41 -05:00
|
|
|
|
|
|
|
Args:
|
|
|
|
prompt: The user input to start or continue the conversation
|
|
|
|
model: The name of the model to use for generating responses
|
|
|
|
messages: The list of previous messages in the conversation
|
|
|
|
history_disabled: A flag indicating if the history and training should be disabled
|
|
|
|
action: The type of action to perform, either "next", "continue", or "variant"
|
|
|
|
conversation_id: The ID of the existing conversation, if any
|
|
|
|
parent_id: The ID of the parent message, if any
|
|
|
|
image: The image to include in the user input, if any
|
|
|
|
**kwargs: Additional keyword arguments to pass to the generator
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
A Response object that contains the generator, action, messages, and options
|
|
|
|
"""
|
|
|
|
# Add the user input to the messages list
|
2023-11-18 23:36:04 -05:00
|
|
|
if prompt:
|
2023-11-20 08:00:40 -05:00
|
|
|
messages.append({
|
|
|
|
"role": "user",
|
|
|
|
"content": prompt
|
|
|
|
})
|
2023-11-18 23:36:04 -05:00
|
|
|
generator = cls.create_async_generator(
|
|
|
|
model,
|
|
|
|
messages,
|
|
|
|
history_disabled=history_disabled,
|
|
|
|
action=action,
|
|
|
|
conversation_id=conversation_id,
|
|
|
|
parent_id=parent_id,
|
2024-01-13 09:37:36 -05:00
|
|
|
image=image,
|
2023-11-18 23:36:04 -05:00
|
|
|
response_fields=True,
|
|
|
|
**kwargs
|
|
|
|
)
|
|
|
|
return Response(
|
|
|
|
generator,
|
|
|
|
action,
|
|
|
|
messages,
|
|
|
|
kwargs
|
|
|
|
)
|
2024-01-13 09:37:36 -05:00
|
|
|
|
|
|
|
@classmethod
|
2024-01-23 13:44:48 -05:00
|
|
|
async def upload_image(
|
2024-01-13 09:37:36 -05:00
|
|
|
cls,
|
|
|
|
session: StreamSession,
|
|
|
|
headers: dict,
|
2024-02-08 16:02:52 -05:00
|
|
|
image: ImageType,
|
|
|
|
image_name: str = None
|
2024-01-26 01:54:13 -05:00
|
|
|
) -> ImageRequest:
|
2024-01-14 09:35:58 -05:00
|
|
|
"""
|
|
|
|
Upload an image to the service and get the download URL
|
2024-01-14 01:45:41 -05:00
|
|
|
|
|
|
|
Args:
|
|
|
|
session: The StreamSession object to use for requests
|
|
|
|
headers: The headers to include in the requests
|
|
|
|
image: The image to upload, either a PIL Image object or a bytes object
|
|
|
|
|
|
|
|
Returns:
|
2024-01-26 01:54:13 -05:00
|
|
|
An ImageRequest object that contains the download URL, file name, and other data
|
2024-01-14 01:45:41 -05:00
|
|
|
"""
|
|
|
|
# Convert the image to a PIL Image object and get the extension
|
2024-01-13 09:37:36 -05:00
|
|
|
image = to_image(image)
|
|
|
|
extension = image.format.lower()
|
2024-01-14 01:45:41 -05:00
|
|
|
# Convert the image to a bytes object and get the size
|
2024-01-13 09:37:36 -05:00
|
|
|
data_bytes = to_bytes(image)
|
|
|
|
data = {
|
2024-02-08 16:02:52 -05:00
|
|
|
"file_name": image_name if image_name else f"{image.width}x{image.height}.{extension}",
|
2024-01-13 09:37:36 -05:00
|
|
|
"file_size": len(data_bytes),
|
|
|
|
"use_case": "multimodal"
|
|
|
|
}
|
2024-01-14 01:45:41 -05:00
|
|
|
# Post the image data to the service and get the image data
|
2024-01-13 09:37:36 -05:00
|
|
|
async with session.post(f"{cls.url}/backend-api/files", json=data, headers=headers) as response:
|
|
|
|
response.raise_for_status()
|
|
|
|
image_data = {
|
|
|
|
**data,
|
|
|
|
**await response.json(),
|
|
|
|
"mime_type": f"image/{extension}",
|
|
|
|
"extension": extension,
|
|
|
|
"height": image.height,
|
|
|
|
"width": image.width
|
|
|
|
}
|
2024-01-14 01:45:41 -05:00
|
|
|
# Put the image bytes to the upload URL and check the status
|
2024-01-13 09:37:36 -05:00
|
|
|
async with session.put(
|
|
|
|
image_data["upload_url"],
|
|
|
|
data=data_bytes,
|
|
|
|
headers={
|
|
|
|
"Content-Type": image_data["mime_type"],
|
|
|
|
"x-ms-blob-type": "BlockBlob"
|
|
|
|
}
|
|
|
|
) as response:
|
|
|
|
response.raise_for_status()
|
2024-01-14 01:45:41 -05:00
|
|
|
# Post the file ID to the service and get the download URL
|
2024-01-13 09:37:36 -05:00
|
|
|
async with session.post(
|
|
|
|
f"{cls.url}/backend-api/files/{image_data['file_id']}/uploaded",
|
|
|
|
json={},
|
|
|
|
headers=headers
|
|
|
|
) as response:
|
|
|
|
response.raise_for_status()
|
2024-01-29 12:14:46 -05:00
|
|
|
image_data["download_url"] = (await response.json())["download_url"]
|
|
|
|
return ImageRequest(image_data)
|
2024-01-13 09:37:36 -05:00
|
|
|
|
|
|
|
@classmethod
|
2024-01-23 13:44:48 -05:00
|
|
|
async def get_default_model(cls, session: StreamSession, headers: dict):
|
2024-01-14 09:35:58 -05:00
|
|
|
"""
|
|
|
|
Get the default model name from the service
|
2024-01-14 01:45:41 -05:00
|
|
|
|
|
|
|
Args:
|
|
|
|
session: The StreamSession object to use for requests
|
|
|
|
headers: The headers to include in the requests
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The default model name as a string
|
|
|
|
"""
|
2024-01-23 13:44:48 -05:00
|
|
|
if not cls.default_model:
|
|
|
|
async with session.get(f"{cls.url}/backend-api/models", headers=headers) as response:
|
2024-02-26 17:41:06 -05:00
|
|
|
cls._update_request_args(session)
|
2024-02-23 05:33:38 -05:00
|
|
|
response.raise_for_status()
|
2024-01-23 13:44:48 -05:00
|
|
|
data = await response.json()
|
|
|
|
if "categories" in data:
|
|
|
|
cls.default_model = data["categories"][-1]["default_model"]
|
2024-02-23 05:33:38 -05:00
|
|
|
return cls.default_model
|
|
|
|
raise RuntimeError(f"Response: {data}")
|
2024-01-23 13:44:48 -05:00
|
|
|
return cls.default_model
|
2024-01-13 09:37:36 -05:00
|
|
|
|
|
|
|
@classmethod
|
2024-02-26 17:41:06 -05:00
|
|
|
def create_messages(cls, messages: Messages, image_request: ImageRequest = None):
|
2024-01-14 09:35:58 -05:00
|
|
|
"""
|
|
|
|
Create a list of messages for the user input
|
2024-01-14 01:45:41 -05:00
|
|
|
|
|
|
|
Args:
|
|
|
|
prompt: The user input as a string
|
|
|
|
image_response: The image response object, if any
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
A list of messages with the user input and the image, if any
|
|
|
|
"""
|
2024-02-26 17:41:06 -05:00
|
|
|
# Create a message object with the user role and the content
|
|
|
|
messages = [{
|
|
|
|
"id": str(uuid.uuid4()),
|
|
|
|
"author": {"role": message["role"]},
|
|
|
|
"content": {"content_type": "text", "parts": [message["content"]]},
|
|
|
|
} for message in messages]
|
|
|
|
|
2024-01-14 01:45:41 -05:00
|
|
|
# Check if there is an image response
|
2024-02-26 17:41:06 -05:00
|
|
|
if image_request:
|
|
|
|
# Change content in last user message
|
|
|
|
messages[-1]["content"] = {
|
2024-01-13 09:37:36 -05:00
|
|
|
"content_type": "multimodal_text",
|
|
|
|
"parts": [{
|
2024-01-29 12:14:46 -05:00
|
|
|
"asset_pointer": f"file-service://{image_request.get('file_id')}",
|
|
|
|
"height": image_request.get("height"),
|
|
|
|
"size_bytes": image_request.get("file_size"),
|
|
|
|
"width": image_request.get("width"),
|
2024-02-26 17:41:06 -05:00
|
|
|
}, messages[-1]["content"]["parts"][0]]
|
2024-01-13 09:37:36 -05:00
|
|
|
}
|
2024-01-14 01:45:41 -05:00
|
|
|
# Add the metadata object with the attachments
|
2024-02-26 17:41:06 -05:00
|
|
|
messages[-1]["metadata"] = {
|
2024-01-13 09:37:36 -05:00
|
|
|
"attachments": [{
|
2024-01-29 12:14:46 -05:00
|
|
|
"height": image_request.get("height"),
|
|
|
|
"id": image_request.get("file_id"),
|
|
|
|
"mimeType": image_request.get("mime_type"),
|
|
|
|
"name": image_request.get("file_name"),
|
|
|
|
"size": image_request.get("file_size"),
|
|
|
|
"width": image_request.get("width"),
|
2024-01-13 09:37:36 -05:00
|
|
|
}]
|
|
|
|
}
|
|
|
|
return messages
|
2024-02-26 17:41:06 -05:00
|
|
|
|
2024-01-13 09:37:36 -05:00
|
|
|
@classmethod
|
2024-01-23 13:44:48 -05:00
|
|
|
async def get_generated_image(cls, session: StreamSession, headers: dict, line: dict) -> ImageResponse:
|
2024-01-14 01:45:41 -05:00
|
|
|
"""
|
|
|
|
Retrieves the image response based on the message content.
|
|
|
|
|
2024-01-14 09:35:58 -05:00
|
|
|
This method processes the message content to extract image information and retrieves the
|
|
|
|
corresponding image from the backend API. It then returns an ImageResponse object containing
|
|
|
|
the image URL and the prompt used to generate the image.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
session (StreamSession): The StreamSession object used for making HTTP requests.
|
|
|
|
headers (dict): HTTP headers to be used for the request.
|
|
|
|
line (dict): A dictionary representing the line of response that contains image information.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
ImageResponse: An object containing the image URL and the prompt, or None if no image is found.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
RuntimeError: If there'san error in downloading the image, including issues with the HTTP request or response.
|
2024-01-14 01:45:41 -05:00
|
|
|
"""
|
|
|
|
if "parts" not in line["message"]["content"]:
|
|
|
|
return
|
|
|
|
first_part = line["message"]["content"]["parts"][0]
|
|
|
|
if "asset_pointer" not in first_part or "metadata" not in first_part:
|
|
|
|
return
|
2024-02-23 05:33:38 -05:00
|
|
|
if first_part["metadata"] is None:
|
|
|
|
return
|
2024-01-14 01:45:41 -05:00
|
|
|
prompt = first_part["metadata"]["dalle"]["prompt"]
|
2024-02-23 05:33:38 -05:00
|
|
|
file_id = first_part["asset_pointer"].split("file-service://", 1)[1]
|
2024-01-14 01:45:41 -05:00
|
|
|
try:
|
|
|
|
async with session.get(f"{cls.url}/backend-api/files/{file_id}/download", headers=headers) as response:
|
|
|
|
response.raise_for_status()
|
|
|
|
download_url = (await response.json())["download_url"]
|
|
|
|
return ImageResponse(download_url, prompt)
|
|
|
|
except Exception as e:
|
|
|
|
raise RuntimeError(f"Error in downloading image: {e}")
|
|
|
|
|
|
|
|
@classmethod
|
2024-01-23 13:44:48 -05:00
|
|
|
async def delete_conversation(cls, session: StreamSession, headers: dict, conversation_id: str):
|
2024-01-14 09:35:58 -05:00
|
|
|
"""
|
|
|
|
Deletes a conversation by setting its visibility to False.
|
|
|
|
|
|
|
|
This method sends an HTTP PATCH request to update the visibility of a conversation.
|
|
|
|
It's used to effectively delete a conversation from being accessed or displayed in the future.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
session (StreamSession): The StreamSession object used for making HTTP requests.
|
|
|
|
headers (dict): HTTP headers to be used for the request.
|
|
|
|
conversation_id (str): The unique identifier of the conversation to be deleted.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
HTTPError: If the HTTP request fails or returns an unsuccessful status code.
|
|
|
|
"""
|
2024-01-14 01:45:41 -05:00
|
|
|
async with session.patch(
|
|
|
|
f"{cls.url}/backend-api/conversation/{conversation_id}",
|
|
|
|
json={"is_visible": False},
|
|
|
|
headers=headers
|
|
|
|
) as response:
|
2024-02-28 03:59:31 -05:00
|
|
|
...
|
2023-08-25 00:41:32 -04:00
|
|
|
|
|
|
|
@classmethod
|
2023-10-03 16:12:56 -04:00
|
|
|
async def create_async_generator(
|
2023-08-25 00:41:32 -04:00
|
|
|
cls,
|
|
|
|
model: str,
|
2023-10-09 07:33:20 -04:00
|
|
|
messages: Messages,
|
2023-08-25 00:41:32 -04:00
|
|
|
proxy: str = None,
|
2023-10-09 07:33:20 -04:00
|
|
|
timeout: int = 120,
|
2024-02-23 05:33:38 -05:00
|
|
|
api_key: str = None,
|
2024-01-26 01:54:13 -05:00
|
|
|
cookies: Cookies = None,
|
2023-11-12 04:12:05 -05:00
|
|
|
auto_continue: bool = False,
|
2023-11-18 23:36:04 -05:00
|
|
|
history_disabled: bool = True,
|
|
|
|
action: str = "next",
|
|
|
|
conversation_id: str = None,
|
|
|
|
parent_id: str = None,
|
2024-01-13 09:37:36 -05:00
|
|
|
image: ImageType = None,
|
2024-02-28 01:36:43 -05:00
|
|
|
image_name: str = None,
|
2023-11-18 23:36:04 -05:00
|
|
|
response_fields: bool = False,
|
2023-10-09 07:33:20 -04:00
|
|
|
**kwargs
|
|
|
|
) -> AsyncResult:
|
2024-01-14 01:45:41 -05:00
|
|
|
"""
|
|
|
|
Create an asynchronous generator for the conversation.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
model (str): The model name.
|
|
|
|
messages (Messages): The list of previous messages.
|
|
|
|
proxy (str): Proxy to use for requests.
|
|
|
|
timeout (int): Timeout for requests.
|
2024-02-23 05:33:38 -05:00
|
|
|
api_key (str): Access token for authentication.
|
2024-01-14 01:45:41 -05:00
|
|
|
cookies (dict): Cookies to use for authentication.
|
|
|
|
auto_continue (bool): Flag to automatically continue the conversation.
|
|
|
|
history_disabled (bool): Flag to disable history and training.
|
|
|
|
action (str): Type of action ('next', 'continue', 'variant').
|
|
|
|
conversation_id (str): ID of the conversation.
|
2024-01-14 09:35:58 -05:00
|
|
|
parent_id (str): ID of the parent message.
|
2024-01-14 01:45:41 -05:00
|
|
|
image (ImageType): Image to include in the conversation.
|
|
|
|
response_fields (bool): Flag to include response fields in the output.
|
|
|
|
**kwargs: Additional keyword arguments.
|
|
|
|
|
|
|
|
Yields:
|
|
|
|
AsyncResult: Asynchronous results from the generator.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
RuntimeError: If an error occurs during processing.
|
|
|
|
"""
|
2024-01-26 01:54:13 -05:00
|
|
|
if not has_requirements:
|
|
|
|
raise MissingRequirementsError('Install "py-arkose-generator" and "async_property" package')
|
2023-11-18 23:36:04 -05:00
|
|
|
if not parent_id:
|
|
|
|
parent_id = str(uuid.uuid4())
|
2024-02-26 17:41:06 -05:00
|
|
|
|
2024-02-28 01:36:43 -05:00
|
|
|
# Read api_key from arguments
|
2024-02-23 05:33:38 -05:00
|
|
|
api_key = kwargs["access_token"] if "access_token" in kwargs else api_key
|
2024-02-27 05:55:40 -05:00
|
|
|
|
2023-11-18 23:36:04 -05:00
|
|
|
async with StreamSession(
|
|
|
|
proxies={"https": proxy},
|
2024-02-23 05:33:38 -05:00
|
|
|
impersonate="chrome",
|
2024-02-26 17:41:06 -05:00
|
|
|
timeout=timeout
|
2023-11-18 23:36:04 -05:00
|
|
|
) as session:
|
2024-02-28 01:36:43 -05:00
|
|
|
# Read api_key and cookies from cache / browser config
|
2024-03-08 05:01:38 -05:00
|
|
|
if cls._headers is None or time.time() > cls._expires:
|
2024-02-28 01:36:43 -05:00
|
|
|
if api_key is None:
|
|
|
|
# Read api_key from cookies
|
|
|
|
cookies = get_cookies("chat.openai.com", False) if cookies is None else cookies
|
|
|
|
api_key = cookies["access_token"] if "access_token" in cookies else api_key
|
|
|
|
cls._create_request_args(cookies)
|
|
|
|
else:
|
|
|
|
api_key = cls._api_key if api_key is None else api_key
|
|
|
|
# Read api_key with session cookies
|
2024-02-26 17:41:06 -05:00
|
|
|
if api_key is None and cookies:
|
2024-02-28 01:36:43 -05:00
|
|
|
api_key = await cls.fetch_access_token(session, cls._headers)
|
2024-02-27 05:55:40 -05:00
|
|
|
# Load default model
|
2024-02-28 01:36:43 -05:00
|
|
|
if cls.default_model is None and api_key is not None:
|
2024-02-23 05:33:38 -05:00
|
|
|
try:
|
2024-02-28 01:36:43 -05:00
|
|
|
if not model:
|
|
|
|
cls._set_api_key(api_key)
|
|
|
|
cls.default_model = cls.get_model(await cls.get_default_model(session, cls._headers))
|
|
|
|
else:
|
|
|
|
cls.default_model = cls.get_model(model)
|
2024-02-23 05:33:38 -05:00
|
|
|
except Exception as e:
|
|
|
|
if debug.logging:
|
2024-02-27 05:55:40 -05:00
|
|
|
print("OpenaiChat: Load default_model failed")
|
2024-02-23 05:33:38 -05:00
|
|
|
print(f"{e.__class__.__name__}: {e}")
|
2024-02-28 01:36:43 -05:00
|
|
|
# Browse api_key and default model
|
2024-02-27 05:55:40 -05:00
|
|
|
if api_key is None or cls.default_model is None:
|
2024-02-23 05:33:38 -05:00
|
|
|
login_url = os.environ.get("G4F_LOGIN_URL")
|
|
|
|
if login_url:
|
|
|
|
yield f"Please login: [ChatGPT]({login_url})\n\n"
|
|
|
|
try:
|
2024-02-28 01:36:43 -05:00
|
|
|
cls.browse_access_token(proxy)
|
2024-02-23 05:33:38 -05:00
|
|
|
except MissingRequirementsError:
|
2024-02-27 05:55:40 -05:00
|
|
|
raise MissingAuthError(f'Missing "access_token". Add a "api_key" please')
|
2024-02-28 01:36:43 -05:00
|
|
|
cls.default_model = cls.get_model(await cls.get_default_model(session, cls._headers))
|
2024-02-27 05:55:40 -05:00
|
|
|
else:
|
2024-02-28 01:36:43 -05:00
|
|
|
cls._set_api_key(api_key)
|
2024-02-26 17:41:06 -05:00
|
|
|
|
2024-01-13 09:37:36 -05:00
|
|
|
try:
|
2024-02-28 01:36:43 -05:00
|
|
|
image_request = await cls.upload_image(session, cls._headers, image, image_name) if image else None
|
2024-01-13 09:37:36 -05:00
|
|
|
except Exception as e:
|
2024-02-28 01:36:43 -05:00
|
|
|
if debug.logging:
|
|
|
|
print("OpenaiChat: Upload image failed")
|
|
|
|
print(f"{e.__class__.__name__}: {e}")
|
2024-02-26 17:41:06 -05:00
|
|
|
|
2024-02-28 01:36:43 -05:00
|
|
|
model = cls.get_model(model).replace("gpt-3.5-turbo", "text-davinci-002-render-sha")
|
|
|
|
fields = ResponseFields()
|
|
|
|
while fields.finish_reason is None:
|
2024-02-09 00:36:28 -05:00
|
|
|
arkose_token = await cls.get_arkose_token(session)
|
2024-02-28 01:36:43 -05:00
|
|
|
conversation_id = conversation_id if fields.conversation_id is None else fields.conversation_id
|
|
|
|
parent_id = parent_id if fields.message_id is None else fields.message_id
|
2023-11-20 08:00:40 -05:00
|
|
|
data = {
|
|
|
|
"action": action,
|
2024-02-09 00:36:28 -05:00
|
|
|
"arkose_token": arkose_token,
|
|
|
|
"conversation_mode": {"kind": "primary_assistant"},
|
|
|
|
"force_paragen": False,
|
|
|
|
"force_rate_limit": False,
|
2023-11-20 08:00:40 -05:00
|
|
|
"conversation_id": conversation_id,
|
|
|
|
"parent_message_id": parent_id,
|
2024-01-26 01:54:13 -05:00
|
|
|
"model": model,
|
2023-11-20 08:00:40 -05:00
|
|
|
"history_and_training_disabled": history_disabled and not auto_continue,
|
|
|
|
}
|
|
|
|
if action != "continue":
|
2024-02-28 01:36:43 -05:00
|
|
|
messages = messages if conversation_id is None else [messages[-1]]
|
|
|
|
data["messages"] = cls.create_messages(messages, image_request)
|
2024-02-23 05:33:38 -05:00
|
|
|
|
2024-01-13 09:37:36 -05:00
|
|
|
async with session.post(
|
|
|
|
f"{cls.url}/backend-api/conversation",
|
|
|
|
json=data,
|
2024-02-09 00:36:28 -05:00
|
|
|
headers={
|
|
|
|
"Accept": "text/event-stream",
|
|
|
|
"OpenAI-Sentinel-Arkose-Token": arkose_token,
|
2024-02-28 01:36:43 -05:00
|
|
|
**cls._headers
|
2024-02-09 00:36:28 -05:00
|
|
|
}
|
2024-01-13 09:37:36 -05:00
|
|
|
) as response:
|
2024-02-26 17:41:06 -05:00
|
|
|
cls._update_request_args(session)
|
2024-01-13 12:10:43 -05:00
|
|
|
if not response.ok:
|
2024-02-28 01:36:43 -05:00
|
|
|
raise RuntimeError(f"Response {response.status}: {await response.text()}")
|
|
|
|
async for chunk in cls.iter_messages_chunk(response.iter_lines(), session, fields):
|
2024-02-12 05:41:27 -05:00
|
|
|
if response_fields:
|
|
|
|
response_fields = False
|
2024-02-28 01:36:43 -05:00
|
|
|
yield fields
|
|
|
|
yield chunk
|
2023-11-20 08:00:40 -05:00
|
|
|
if not auto_continue:
|
|
|
|
break
|
|
|
|
action = "continue"
|
2023-11-12 04:12:05 -05:00
|
|
|
await asyncio.sleep(5)
|
2024-01-14 01:45:41 -05:00
|
|
|
if history_disabled and auto_continue:
|
2024-02-28 04:02:09 -05:00
|
|
|
await cls.delete_conversation(session, cls._headers, fields.conversation_id)
|
2024-02-28 01:36:43 -05:00
|
|
|
|
|
|
|
@staticmethod
|
2024-03-08 05:01:38 -05:00
|
|
|
async def iter_messages_ws(ws: ClientWebSocketResponse, conversation_id: str) -> AsyncIterator:
|
2024-02-28 01:36:43 -05:00
|
|
|
while True:
|
2024-03-08 05:01:38 -05:00
|
|
|
message = await ws.receive_json()
|
|
|
|
if message["conversation_id"] == conversation_id:
|
|
|
|
yield base64.b64decode(message["body"])
|
2024-02-28 01:36:43 -05:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
async def iter_messages_chunk(cls, messages: AsyncIterator, session: StreamSession, fields: ResponseFields) -> AsyncIterator:
|
|
|
|
last_message: int = 0
|
|
|
|
async for message in messages:
|
|
|
|
if message.startswith(b'{"wss_url":'):
|
2024-03-08 05:01:38 -05:00
|
|
|
message = json.loads(message)
|
|
|
|
async with session.ws_connect(message["wss_url"]) as ws:
|
|
|
|
async for chunk in cls.iter_messages_chunk(cls.iter_messages_ws(ws, message["conversation_id"]), session, fields):
|
2024-02-28 01:36:43 -05:00
|
|
|
yield chunk
|
|
|
|
break
|
|
|
|
async for chunk in cls.iter_messages_line(session, message, fields):
|
|
|
|
if fields.finish_reason is not None:
|
|
|
|
break
|
|
|
|
elif isinstance(chunk, str):
|
|
|
|
if len(chunk) > last_message:
|
|
|
|
yield chunk[last_message:]
|
|
|
|
last_message = len(chunk)
|
|
|
|
else:
|
|
|
|
yield chunk
|
|
|
|
if fields.finish_reason is not None:
|
|
|
|
break
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
async def iter_messages_line(cls, session: StreamSession, line: bytes, fields: ResponseFields) -> AsyncIterator:
|
|
|
|
if not line.startswith(b"data: "):
|
|
|
|
return
|
|
|
|
elif line.startswith(b"data: [DONE]"):
|
|
|
|
return
|
|
|
|
try:
|
|
|
|
line = json.loads(line[6:])
|
|
|
|
except:
|
|
|
|
return
|
|
|
|
if "message" not in line:
|
|
|
|
return
|
|
|
|
if "error" in line and line["error"]:
|
|
|
|
raise RuntimeError(line["error"])
|
|
|
|
if "message_type" not in line["message"]["metadata"]:
|
|
|
|
return
|
|
|
|
try:
|
|
|
|
image_response = await cls.get_generated_image(session, cls._headers, line)
|
|
|
|
if image_response is not None:
|
|
|
|
yield image_response
|
|
|
|
except Exception as e:
|
|
|
|
yield e
|
|
|
|
if line["message"]["author"]["role"] != "assistant":
|
|
|
|
return
|
|
|
|
if line["message"]["content"]["content_type"] != "text":
|
|
|
|
return
|
|
|
|
if line["message"]["metadata"]["message_type"] not in ("next", "continue", "variant"):
|
|
|
|
return
|
|
|
|
if fields.conversation_id is None:
|
|
|
|
fields.conversation_id = line["conversation_id"]
|
|
|
|
fields.message_id = line["message"]["id"]
|
|
|
|
if "parts" in line["message"]["content"]:
|
|
|
|
yield line["message"]["content"]["parts"][0]
|
|
|
|
if "finish_details" in line["message"]["metadata"]:
|
|
|
|
fields.finish_reason = line["message"]["metadata"]["finish_details"]["type"]
|
2023-10-03 16:12:56 -04:00
|
|
|
|
|
|
|
@classmethod
|
2024-02-28 01:36:43 -05:00
|
|
|
def browse_access_token(cls, proxy: str = None, timeout: int = 1200) -> None:
|
2024-01-14 01:45:41 -05:00
|
|
|
"""
|
|
|
|
Browse to obtain an access token.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
proxy (str): Proxy to use for browsing.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
tuple[str, dict]: A tuple containing the access token and cookies.
|
|
|
|
"""
|
2024-02-09 00:36:28 -05:00
|
|
|
driver = get_browser(proxy=proxy)
|
|
|
|
try:
|
2024-01-13 09:37:36 -05:00
|
|
|
driver.get(f"{cls.url}/")
|
2024-01-14 09:35:58 -05:00
|
|
|
WebDriverWait(driver, timeout).until(EC.presence_of_element_located((By.ID, "prompt-textarea")))
|
2024-01-14 01:45:41 -05:00
|
|
|
access_token = driver.execute_script(
|
|
|
|
"let session = await fetch('/api/auth/session');"
|
|
|
|
"let data = await session.json();"
|
|
|
|
"let accessToken = data['accessToken'];"
|
2024-02-26 17:41:06 -05:00
|
|
|
"let expires = new Date(); expires.setTime(expires.getTime() + 60 * 60 * 4 * 1000);"
|
2024-01-14 01:45:41 -05:00
|
|
|
"document.cookie = 'access_token=' + accessToken + ';expires=' + expires.toUTCString() + ';path=/';"
|
|
|
|
"return accessToken;"
|
2024-01-13 09:37:36 -05:00
|
|
|
)
|
2024-02-23 05:33:38 -05:00
|
|
|
args = get_args_from_browser(f"{cls.url}/", driver, do_bypass_cloudflare=False)
|
2024-02-28 01:36:43 -05:00
|
|
|
cls._headers = args["headers"]
|
|
|
|
cls._cookies = args["cookies"]
|
|
|
|
cls._update_cookie_header()
|
|
|
|
cls._set_api_key(access_token)
|
2024-02-09 00:36:28 -05:00
|
|
|
finally:
|
|
|
|
driver.close()
|
2024-01-13 09:37:36 -05:00
|
|
|
|
2024-01-14 01:45:41 -05:00
|
|
|
@classmethod
|
2024-01-23 13:44:48 -05:00
|
|
|
async def get_arkose_token(cls, session: StreamSession) -> str:
|
2024-01-14 01:45:41 -05:00
|
|
|
"""
|
|
|
|
Obtain an Arkose token for the session.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
session (StreamSession): The session object.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
str: The Arkose token.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
RuntimeError: If unable to retrieve the token.
|
|
|
|
"""
|
2024-01-13 09:37:36 -05:00
|
|
|
config = {
|
|
|
|
"pkey": "3D86FBBA-9D22-402A-B512-3420086BA6CC",
|
|
|
|
"surl": "https://tcr9i.chat.openai.com",
|
|
|
|
"headers": {
|
|
|
|
"User-Agent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36'
|
|
|
|
},
|
|
|
|
"site": cls.url,
|
|
|
|
}
|
|
|
|
args_for_request = get_values_for_request(config)
|
2023-11-11 04:14:39 -05:00
|
|
|
async with session.post(**args_for_request) as response:
|
|
|
|
response.raise_for_status()
|
|
|
|
decoded_json = await response.json()
|
|
|
|
if "token" in decoded_json:
|
|
|
|
return decoded_json["token"]
|
2023-11-18 23:36:04 -05:00
|
|
|
raise RuntimeError(f"Response: {decoded_json}")
|
2024-01-14 01:45:41 -05:00
|
|
|
|
2024-02-26 17:41:06 -05:00
|
|
|
@classmethod
|
|
|
|
async def fetch_access_token(cls, session: StreamSession, headers: dict):
|
|
|
|
async with session.get(
|
|
|
|
f"{cls.url}/api/auth/session",
|
|
|
|
headers=headers
|
|
|
|
) as response:
|
|
|
|
if response.ok:
|
|
|
|
data = await response.json()
|
|
|
|
if "accessToken" in data:
|
|
|
|
return data["accessToken"]
|
|
|
|
|
|
|
|
@staticmethod
|
|
|
|
def _format_cookies(cookies: Cookies):
|
|
|
|
return "; ".join(f"{k}={v}" for k, v in cookies.items() if k != "access_token")
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def _create_request_args(cls, cookies: Union[Cookies, None]):
|
2024-02-28 01:36:43 -05:00
|
|
|
cls._headers = {}
|
|
|
|
cls._cookies = {} if cookies is None else cookies
|
|
|
|
cls._update_cookie_header()
|
2024-02-26 17:41:06 -05:00
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def _update_request_args(cls, session: StreamSession):
|
|
|
|
for c in session.cookie_jar if hasattr(session, "cookie_jar") else session.cookies.jar:
|
2024-02-28 01:36:43 -05:00
|
|
|
cls._cookies[c.name if hasattr(c, "name") else c.key] = c.value
|
|
|
|
cls._update_cookie_header()
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def _set_api_key(cls, api_key: str):
|
|
|
|
cls._api_key = api_key
|
2024-03-08 05:01:38 -05:00
|
|
|
cls._expires = int(time.time()) + 60 * 60 * 4
|
2024-02-28 01:36:43 -05:00
|
|
|
cls._headers["Authorization"] = f"Bearer {api_key}"
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def _update_cookie_header(cls):
|
|
|
|
cls._headers["Cookie"] = cls._format_cookies(cls._cookies)
|
2024-02-26 17:41:06 -05:00
|
|
|
|
2024-01-14 01:45:41 -05:00
|
|
|
class EndTurn:
|
|
|
|
"""
|
|
|
|
Class to represent the end of a conversation turn.
|
|
|
|
"""
|
2023-11-18 23:36:04 -05:00
|
|
|
def __init__(self):
|
|
|
|
self.is_end = False
|
|
|
|
|
|
|
|
def end(self):
|
|
|
|
self.is_end = True
|
|
|
|
|
2024-01-14 01:45:41 -05:00
|
|
|
class ResponseFields:
|
|
|
|
"""
|
|
|
|
Class to encapsulate response fields.
|
|
|
|
"""
|
2024-02-28 01:36:43 -05:00
|
|
|
def __init__(self, conversation_id: str = None, message_id: str = None, finish_reason: str = None):
|
2023-11-18 23:36:04 -05:00
|
|
|
self.conversation_id = conversation_id
|
|
|
|
self.message_id = message_id
|
2024-02-28 01:36:43 -05:00
|
|
|
self.finish_reason = finish_reason
|
2024-01-14 09:35:58 -05:00
|
|
|
|
2023-11-18 23:36:04 -05:00
|
|
|
class Response():
|
2024-01-14 01:45:41 -05:00
|
|
|
"""
|
|
|
|
Class to encapsulate a response from the chat service.
|
|
|
|
"""
|
2023-11-18 23:36:04 -05:00
|
|
|
def __init__(
|
|
|
|
self,
|
|
|
|
generator: AsyncResult,
|
|
|
|
action: str,
|
|
|
|
messages: Messages,
|
|
|
|
options: dict
|
|
|
|
):
|
2024-01-13 09:37:36 -05:00
|
|
|
self._generator = generator
|
2024-01-14 01:45:41 -05:00
|
|
|
self.action = action
|
|
|
|
self.is_end = False
|
2024-01-13 09:37:36 -05:00
|
|
|
self._message = None
|
2023-11-18 23:36:04 -05:00
|
|
|
self._messages = messages
|
|
|
|
self._options = options
|
2024-01-13 09:37:36 -05:00
|
|
|
self._fields = None
|
2024-01-14 01:45:41 -05:00
|
|
|
|
2024-01-13 09:37:36 -05:00
|
|
|
async def generator(self):
|
|
|
|
if self._generator:
|
|
|
|
self._generator = None
|
|
|
|
chunks = []
|
|
|
|
async for chunk in self._generator:
|
|
|
|
if isinstance(chunk, ResponseFields):
|
|
|
|
self._fields = chunk
|
|
|
|
else:
|
|
|
|
yield chunk
|
|
|
|
chunks.append(str(chunk))
|
|
|
|
self._message = "".join(chunks)
|
|
|
|
if not self._fields:
|
|
|
|
raise RuntimeError("Missing response fields")
|
2024-02-28 01:36:43 -05:00
|
|
|
self.is_end = self._fields.end_turn
|
2023-11-18 23:36:04 -05:00
|
|
|
|
|
|
|
def __aiter__(self):
|
2024-01-13 09:37:36 -05:00
|
|
|
return self.generator()
|
2024-01-14 01:45:41 -05:00
|
|
|
|
2023-11-18 23:36:04 -05:00
|
|
|
@async_cached_property
|
|
|
|
async def message(self) -> str:
|
2024-01-14 01:45:41 -05:00
|
|
|
await self.generator()
|
2024-01-13 09:37:36 -05:00
|
|
|
return self._message
|
2024-01-14 01:45:41 -05:00
|
|
|
|
2024-01-13 09:37:36 -05:00
|
|
|
async def get_fields(self):
|
2024-01-14 01:45:41 -05:00
|
|
|
await self.generator()
|
|
|
|
return {"conversation_id": self._fields.conversation_id, "parent_id": self._fields.message_id}
|
|
|
|
|
2023-11-18 23:36:04 -05:00
|
|
|
async def next(self, prompt: str, **kwargs) -> Response:
|
|
|
|
return await OpenaiChat.create(
|
|
|
|
**self._options,
|
|
|
|
prompt=prompt,
|
|
|
|
messages=await self.messages,
|
|
|
|
action="next",
|
2024-01-13 09:37:36 -05:00
|
|
|
**await self.get_fields(),
|
2023-11-18 23:36:04 -05:00
|
|
|
**kwargs
|
|
|
|
)
|
2024-01-14 01:45:41 -05:00
|
|
|
|
2023-11-18 23:36:04 -05:00
|
|
|
async def do_continue(self, **kwargs) -> Response:
|
2024-01-13 09:37:36 -05:00
|
|
|
fields = await self.get_fields()
|
|
|
|
if self.is_end:
|
2023-11-18 23:36:04 -05:00
|
|
|
raise RuntimeError("Can't continue message. Message already finished.")
|
|
|
|
return await OpenaiChat.create(
|
|
|
|
**self._options,
|
|
|
|
messages=await self.messages,
|
|
|
|
action="continue",
|
2024-01-13 09:37:36 -05:00
|
|
|
**fields,
|
2023-11-18 23:36:04 -05:00
|
|
|
**kwargs
|
|
|
|
)
|
2024-01-14 01:45:41 -05:00
|
|
|
|
2023-11-18 23:36:04 -05:00
|
|
|
async def variant(self, **kwargs) -> Response:
|
|
|
|
if self.action != "next":
|
2023-11-20 08:00:40 -05:00
|
|
|
raise RuntimeError("Can't create variant from continue or variant request.")
|
2023-11-18 23:36:04 -05:00
|
|
|
return await OpenaiChat.create(
|
|
|
|
**self._options,
|
|
|
|
messages=self._messages,
|
|
|
|
action="variant",
|
2024-01-13 09:37:36 -05:00
|
|
|
**await self.get_fields(),
|
2023-11-18 23:36:04 -05:00
|
|
|
**kwargs
|
|
|
|
)
|
2024-01-14 01:45:41 -05:00
|
|
|
|
2023-11-18 23:36:04 -05:00
|
|
|
@async_cached_property
|
|
|
|
async def messages(self):
|
|
|
|
messages = self._messages
|
2024-01-14 01:45:41 -05:00
|
|
|
messages.append({"role": "assistant", "content": await self.message})
|
2024-01-13 09:37:36 -05:00
|
|
|
return messages
|