|
|
|
|
|
|
|
|
import logging |
|
|
from datetime import timedelta |
|
|
from os.path import join, abspath, dirname |
|
|
|
|
|
from flask import Flask, jsonify, make_response, request, Response, render_template |
|
|
from flask_cors import CORS |
|
|
from waitress import serve |
|
|
from werkzeug.exceptions import default_exceptions |
|
|
from werkzeug.middleware.proxy_fix import ProxyFix |
|
|
from werkzeug.serving import WSGIRequestHandler |
|
|
|
|
|
from .. import __version__ |
|
|
from ..exts.hooks import hook_logging |
|
|
from ..openai.api import API |
|
|
|
|
|
|
|
|
class ChatBot: |
|
|
__default_ip = '127.0.0.1' |
|
|
__default_port = 8008 |
|
|
|
|
|
def __init__(self, chatgpt, debug=False, sentry=False): |
|
|
self.chatgpt = chatgpt |
|
|
self.debug = debug |
|
|
self.sentry = sentry |
|
|
self.log_level = logging.DEBUG if debug else logging.WARN |
|
|
|
|
|
hook_logging(level=self.log_level, format='[%(asctime)s] %(levelname)s in %(module)s: %(message)s') |
|
|
self.logger = logging.getLogger('waitress') |
|
|
|
|
|
def run(self, bind_str, threads=8): |
|
|
host, port = self.__parse_bind(bind_str) |
|
|
|
|
|
resource_path = abspath(join(dirname(__file__), '..', 'flask')) |
|
|
app = Flask(__name__, static_url_path='', |
|
|
static_folder=join(resource_path, 'static'), |
|
|
template_folder=join(resource_path, 'templates')) |
|
|
app.wsgi_app = ProxyFix(app.wsgi_app, x_port=1) |
|
|
app.after_request(self.__after_request) |
|
|
|
|
|
CORS(app, resources={r'/api/*': {'supports_credentials': True, 'expose_headers': [ |
|
|
'Content-Type', |
|
|
'Authorization', |
|
|
'X-Requested-With', |
|
|
'Accept', |
|
|
'Origin', |
|
|
'Access-Control-Request-Method', |
|
|
'Access-Control-Request-Headers', |
|
|
'Content-Disposition', |
|
|
], 'max_age': 600}}) |
|
|
|
|
|
for ex in default_exceptions: |
|
|
app.register_error_handler(ex, self.__handle_error) |
|
|
|
|
|
app.route('/api/models')(self.list_models) |
|
|
app.route('/api/conversations')(self.list_conversations) |
|
|
app.route('/api/conversations', methods=['DELETE'])(self.clear_conversations) |
|
|
app.route('/api/conversation/<conversation_id>')(self.get_conversation) |
|
|
app.route('/api/conversation/<conversation_id>', methods=['DELETE'])(self.del_conversation) |
|
|
app.route('/api/conversation/<conversation_id>', methods=['PATCH'])(self.set_conversation_title) |
|
|
app.route('/api/conversation/gen_title/<conversation_id>', methods=['POST'])(self.gen_conversation_title) |
|
|
app.route('/api/conversation/talk', methods=['POST'])(self.talk) |
|
|
app.route('/api/conversation/regenerate', methods=['POST'])(self.regenerate) |
|
|
app.route('/api/conversation/goon', methods=['POST'])(self.goon) |
|
|
|
|
|
app.route('/api/auth/session')(self.session) |
|
|
app.route('/api/accounts/check')(self.check) |
|
|
app.route('/_next/data/olf4sv64FWIcQ_zCGl90t/chat.json')(self.chat_info) |
|
|
|
|
|
app.route('/')(self.chat) |
|
|
app.route('/chat')(self.chat) |
|
|
app.route('/chat/<conversation_id>')(self.chat) |
|
|
|
|
|
if not self.debug: |
|
|
self.logger.warning('Serving on http://{}:{}'.format(host, port)) |
|
|
|
|
|
WSGIRequestHandler.protocol_version = 'HTTP/1.1' |
|
|
serve(app, host=host, port=port, ident=None, threads=threads) |
|
|
|
|
|
@staticmethod |
|
|
def __after_request(resp): |
|
|
resp.headers['X-Server'] = 'pandora/{}'.format(__version__) |
|
|
|
|
|
return resp |
|
|
|
|
|
def __parse_bind(self, bind_str): |
|
|
sections = bind_str.split(':', 2) |
|
|
if len(sections) < 2: |
|
|
try: |
|
|
port = int(sections[0]) |
|
|
return self.__default_ip, port |
|
|
except ValueError: |
|
|
return sections[0], self.__default_port |
|
|
|
|
|
return sections[0], int(sections[1]) |
|
|
|
|
|
def __handle_error(self, e): |
|
|
self.logger.error(e) |
|
|
|
|
|
return make_response(jsonify({ |
|
|
'code': e.code, |
|
|
'message': str(e.original_exception if self.debug and hasattr(e, 'original_exception') else e.name) |
|
|
}), 500) |
|
|
|
|
|
@staticmethod |
|
|
def __set_cookie(resp, token_key, max_age): |
|
|
resp.set_cookie('token-key', token_key, max_age=max_age, path='/', domain=None, httponly=True, samesite='Lax') |
|
|
|
|
|
@staticmethod |
|
|
def __get_token_key(): |
|
|
return request.headers.get('X-Use-Token', request.cookies.get('token-key')) |
|
|
|
|
|
def chat(self, conversation_id=None): |
|
|
query = {'chatId': [conversation_id]} if conversation_id else {} |
|
|
|
|
|
token_key = request.args.get('token') |
|
|
rendered = render_template('chat.html', pandora_base=request.url_root.strip('/'), query=query) |
|
|
resp = make_response(rendered) |
|
|
|
|
|
if token_key: |
|
|
self.__set_cookie(resp, token_key, timedelta(days=30)) |
|
|
|
|
|
return resp |
|
|
|
|
|
@staticmethod |
|
|
def session(): |
|
|
ret = { |
|
|
'user': { |
|
|
'id': 'user-000000000000000000000000', |
|
|
'name': 'admin@openai.com', |
|
|
'email': 'admin@openai.com', |
|
|
'image': None, |
|
|
'picture': None, |
|
|
'groups': [] |
|
|
}, |
|
|
'expires': '2089-08-08T23:59:59.999Z', |
|
|
'accessToken': 'secret', |
|
|
} |
|
|
|
|
|
return jsonify(ret) |
|
|
|
|
|
@staticmethod |
|
|
def chat_info(): |
|
|
ret = { |
|
|
'pageProps': { |
|
|
'user': { |
|
|
'id': 'user-000000000000000000000000', |
|
|
'name': 'admin@openai.com', |
|
|
'email': 'admin@openai.com', |
|
|
'image': None, |
|
|
'picture': None, |
|
|
'groups': [] |
|
|
}, |
|
|
'serviceStatus': {}, |
|
|
'userCountry': 'US', |
|
|
'geoOk': True, |
|
|
'serviceAnnouncement': { |
|
|
'paid': {}, |
|
|
'public': {} |
|
|
}, |
|
|
'isUserInCanPayGroup': True |
|
|
}, |
|
|
'__N_SSP': True |
|
|
} |
|
|
|
|
|
return jsonify(ret) |
|
|
|
|
|
@staticmethod |
|
|
def check(): |
|
|
ret = { |
|
|
'account_plan': { |
|
|
'is_paid_subscription_active': True, |
|
|
'subscription_plan': 'chatgptplusplan', |
|
|
'account_user_role': 'account-owner', |
|
|
'was_paid_customer': True, |
|
|
'has_customer_object': True, |
|
|
'subscription_expires_at_timestamp': 3774355199 |
|
|
}, |
|
|
'user_country': 'US', |
|
|
'features': [ |
|
|
'model_switcher', |
|
|
'dfw_message_feedback', |
|
|
'dfw_inline_message_regen_comparison', |
|
|
'model_preview', |
|
|
'system_message', |
|
|
'can_continue', |
|
|
], |
|
|
} |
|
|
|
|
|
return jsonify(ret) |
|
|
|
|
|
def list_models(self): |
|
|
return self.__proxy_result(self.chatgpt.list_models(True, self.__get_token_key())) |
|
|
|
|
|
def list_conversations(self): |
|
|
offset = request.args.get('offset', '0') |
|
|
limit = request.args.get('limit', '20') |
|
|
|
|
|
return self.__proxy_result(self.chatgpt.list_conversations(offset, limit, True, self.__get_token_key())) |
|
|
|
|
|
def get_conversation(self, conversation_id): |
|
|
return self.__proxy_result(self.chatgpt.get_conversation(conversation_id, True, self.__get_token_key())) |
|
|
|
|
|
def del_conversation(self, conversation_id): |
|
|
return self.__proxy_result(self.chatgpt.del_conversation(conversation_id, True, self.__get_token_key())) |
|
|
|
|
|
def clear_conversations(self): |
|
|
return self.__proxy_result(self.chatgpt.clear_conversations(True, self.__get_token_key())) |
|
|
|
|
|
def set_conversation_title(self, conversation_id): |
|
|
title = request.json['title'] |
|
|
|
|
|
return self.__proxy_result( |
|
|
self.chatgpt.set_conversation_title(conversation_id, title, True, self.__get_token_key())) |
|
|
|
|
|
def gen_conversation_title(self, conversation_id): |
|
|
payload = request.json |
|
|
model = payload['model'] |
|
|
message_id = payload['message_id'] |
|
|
|
|
|
return self.__proxy_result( |
|
|
self.chatgpt.gen_conversation_title(conversation_id, model, message_id, True, self.__get_token_key())) |
|
|
|
|
|
def talk(self): |
|
|
payload = request.json |
|
|
prompt = payload['prompt'] |
|
|
model = payload['model'] |
|
|
message_id = payload['message_id'] |
|
|
parent_message_id = payload['parent_message_id'] |
|
|
conversation_id = payload.get('conversation_id') |
|
|
stream = payload.get('stream', True) |
|
|
|
|
|
return self.__process_stream( |
|
|
*self.chatgpt.talk(prompt, model, message_id, parent_message_id, conversation_id, stream, |
|
|
self.__get_token_key()), stream) |
|
|
|
|
|
def goon(self): |
|
|
payload = request.json |
|
|
model = payload['model'] |
|
|
parent_message_id = payload['parent_message_id'] |
|
|
conversation_id = payload.get('conversation_id') |
|
|
stream = payload.get('stream', True) |
|
|
|
|
|
return self.__process_stream( |
|
|
*self.chatgpt.goon(model, parent_message_id, conversation_id, stream, self.__get_token_key()), stream) |
|
|
|
|
|
def regenerate(self): |
|
|
payload = request.json |
|
|
|
|
|
conversation_id = payload.get('conversation_id') |
|
|
if not conversation_id: |
|
|
return self.talk() |
|
|
|
|
|
prompt = payload['prompt'] |
|
|
model = payload['model'] |
|
|
message_id = payload['message_id'] |
|
|
parent_message_id = payload['parent_message_id'] |
|
|
stream = payload.get('stream', True) |
|
|
|
|
|
return self.__process_stream( |
|
|
*self.chatgpt.regenerate_reply(prompt, model, conversation_id, message_id, parent_message_id, stream, |
|
|
self.__get_token_key()), stream) |
|
|
|
|
|
@staticmethod |
|
|
def __process_stream(status, headers, generator, stream): |
|
|
if stream: |
|
|
return Response(API.wrap_stream_out(generator, status), mimetype=headers['Content-Type'], status=status) |
|
|
|
|
|
last_json = None |
|
|
for json in generator: |
|
|
last_json = json |
|
|
|
|
|
return make_response(last_json, status) |
|
|
|
|
|
@staticmethod |
|
|
def __proxy_result(remote_resp): |
|
|
resp = make_response(remote_resp.text) |
|
|
resp.content_type = remote_resp.headers['Content-Type'] |
|
|
resp.status_code = remote_resp.status_code |
|
|
|
|
|
return resp |
|
|
|
