From 7c51a775c63c0f19876fb75933850c33b612fac9 Mon Sep 17 00:00:00 2001 From: Dmitry Afanasyev <71835315+Balshgit@users.noreply.github.com> Date: Wed, 31 Jan 2024 20:08:49 +0300 Subject: [PATCH] remove unused providers (#85) --- bot_microservice/constants.py | 7 - .../.github/workflows/build.yaml | 9 +- chatgpt_microservice/README.md | 2 +- chatgpt_microservice/deprecated/free_gpt.cpp | 743 +++++++++++++++++ chatgpt_microservice/include/free_gpt.h | 7 - chatgpt_microservice/src/free_gpt.cpp | 761 +----------------- chatgpt_microservice/src/main.cpp | 7 - 7 files changed, 758 insertions(+), 778 deletions(-) diff --git a/bot_microservice/constants.py b/bot_microservice/constants.py index 368a3bd..0738381 100644 --- a/bot_microservice/constants.py +++ b/bot_microservice/constants.py @@ -53,20 +53,13 @@ class ChatGptModelsEnum(StrEnum): gpt_3_stream_binjie = "gpt-3-stream-binjie" gpt_3_5_turbo_stream_CodeLinkAva = "gpt-3.5-turbo-stream-CodeLinkAva" gpt_4_stream_ChatBase = "gpt-4-stream-ChatBase" - gpt_3_5_turbo_stream_GptGo = "gpt-3.5-turbo-stream-GptGo" gpt_3_5_turbo_stream_FreeGpt = "gpt-3.5-turbo-stream-FreeGpt" gpt_3_5_turbo_stream_Cromicle = "gpt-3.5-turbo-stream-Cromicle" - gpt_3_5_turbo_stream_ChatgptDemo = "gpt-3.5-turbo-stream-ChatgptDemo" Llama_2_70b_chat_hf_stream_DeepInfra = "Llama-2-70b-chat-hf-stream-DeepInfra" gpt_4_stream_aivvm = "gpt-4-stream-aivvm" - gpt_3_5_turbo_stream_AiChatOnline = "gpt-3.5-turbo-stream-AiChatOnline" - gpt_3_5_turbo_stream_FreeChatgpt = "gpt-3.5-turbo-stream-FreeChatgpt" llama2_70B = "llama2-70B" - gpt6 = "gpt6" - gpt_3_5_turbo_streamc_hatxyz = "gpt-3.5-turbo-stream-chatxyz" gpt_3_5_turbo_gptChatly = "gpt-3.5-turbo-gptChatly" gpt_3_5_turbo_stream_Berlin = "gpt-3.5-turbo-stream-Berlin" - gpt_3_5_turbo_stream_chatGptAi = "gpt-3.5-turbo-stream-chatGptAi" gpt_3_5_turbo_stream_GeekGpt = "gpt-3.5-turbo-stream-GeekGpt" gpt_3_5_turbo_stream_gptforlove = "gpt-3.5-turbo-stream-gptforlove" gpt_3_5_turbo_stream_fakeGpt = "gpt-3.5-turbo-stream-fakeGpt" diff --git a/chatgpt_microservice/.github/workflows/build.yaml b/chatgpt_microservice/.github/workflows/build.yaml index e5f597b..19d9e82 100644 --- a/chatgpt_microservice/.github/workflows/build.yaml +++ b/chatgpt_microservice/.github/workflows/build.yaml @@ -19,19 +19,20 @@ jobs: run: | sudo apt-get update sudo apt-get install -y libgl1-mesa-dev libglu1-mesa-dev p7zip gobjc g++-13 wget sudo libcurl4-openssl-dev libnss3 nss-plugin-pem ca-certificates - wget https://github.com/lwthiker/curl-impersonate/releases/download/v0.5.4/libcurl-impersonate-v0.5.4.x86_64-linux-gnu.tar.gz - sudo mv libcurl-impersonate-v0.5.4.x86_64-linux-gnu.tar.gz /usr/lib64 + wget https://github.com/lwthiker/curl-impersonate/releases/download/v0.6.0-alpha.1/libcurl-impersonate-v0.6.0-alpha.1.x86_64-linux-gnu.tar.gz + sudo mv libcurl-impersonate-v0.6.0-alpha.1.x86_64-linux-gnu.tar.gz /usr/lib64 cd /usr/lib64 sudo tar -xvf libcurl-impersonate-v0.6.0-alpha.1.x86_64-linux-gnu.tar.gz cd - - curl -kfsSL https://xmake.io/shget.text | bash -s v2.8.6 + - uses: xmake-io/github-action-setup-xmake@v1 + with: + xmake-version: v2.8.6 - name: checkout uses: actions/checkout@v3 - name: build run: | export XMAKE_ROOT="y" - source ~/.xmake/profile g++-13 -v export LD_LIBRARY_PATH=/usr/lib64:$LD_LIBRARY_PATH export LIBRARY_PATH=/usr/lib64:$LIBRARY_PATH diff --git a/chatgpt_microservice/README.md b/chatgpt_microservice/README.md index d16a904..800d6b4 100644 --- a/chatgpt_microservice/README.md +++ b/chatgpt_microservice/README.md @@ -1,6 +1,6 @@ # Cpp FreeGPT WebUI -[![](https://github.com/fantasy-peak/cpp-freegpt-webui/workflows/ubuntu-gcc13/badge.svg)](https://github.com/fantasy-peak/cpp-freegpt-webui/actions) [![](https://github.com/fantasy-peak/cpp-freegpt-webui/workflows/ubuntu-clang18/badge.svg)](https://github.com/fantasy-peak/cpp-freegpt-webui/actions) [![](https://img.shields.io/badge/language-C%2B%2B23-yellow.svg +[![](https://github.com/fantasy-peak/cpp-freegpt-webui/workflows/ubuntu-gcc13/badge.svg)](https://github.com/fantasy-peak/cpp-freegpt-webui/actions) [![](https://github.com/fantasy-peak/cpp-freegpt-webui/workflows/ubuntu-clang19/badge.svg)](https://github.com/fantasy-peak/cpp-freegpt-webui/actions) [![](https://img.shields.io/badge/language-C%2B%2B23-yellow.svg )](https://en.wikipedia.org/wiki/C%2B%2B17) [![Docker Pulls](https://img.shields.io/docker/pulls/fantasypeak/freegpt?logo=docker )](https://hub.docker.com/r/fantasypeak/freegpt/) diff --git a/chatgpt_microservice/deprecated/free_gpt.cpp b/chatgpt_microservice/deprecated/free_gpt.cpp index 6012f0e..9e19d01 100644 --- a/chatgpt_microservice/deprecated/free_gpt.cpp +++ b/chatgpt_microservice/deprecated/free_gpt.cpp @@ -2779,3 +2779,746 @@ boost::asio::awaitable FreeGpt::gptTalkru(std::shared_ptr ch, nlo } co_return; } +boost::asio::awaitable FreeGpt::freeChatGpt(std::shared_ptr ch, nlohmann::json json) { + co_await boost::asio::post(boost::asio::bind_executor(*m_thread_pool_ptr, boost::asio::use_awaitable)); + ScopeExit _exit{[=] { boost::asio::post(ch->get_executor(), [=] { ch->close(); }); }}; + + boost::system::error_code err{}; + auto prompt = json.at("meta").at("content").at("parts").at(0).at("content").get(); + std::string recv; + auto ret = Curl() + .setUrl("https://free.chatgpt.org.uk/api/openai/v1/chat/completions") + .setProxy(m_cfg.http_proxy) + .setBody([&] { + constexpr std::string_view ask_json_str = R"({ + "messages":[ + { + "role":"user", + "content":"Hello" + } + ], + "stream":true, + "model":"gpt-3.5-turbo", + "temperature":0.5, + "presence_penalty":0, + "frequency_penalty":0, + "top_p":1 + })"; + nlohmann::json ask_request = nlohmann::json::parse(ask_json_str, nullptr, false); + ask_request["messages"] = getConversationJson(json); + std::string ask_request_str = ask_request.dump(); + SPDLOG_INFO("request: [{}]", ask_request_str); + return ask_request_str; + }()) + .setRecvBodyCallback([&](std::string str) { + recv.append(str); + while (true) { + auto position = recv.find("\n"); + if (position == std::string::npos) + break; + auto msg = recv.substr(0, position + 1); + recv.erase(0, position + 1); + msg.pop_back(); + if (msg.empty() || !msg.contains("content")) + continue; + auto fields = splitString(msg, "data: "); + boost::system::error_code err{}; + nlohmann::json line_json = nlohmann::json::parse(fields.back(), nullptr, false); + if (line_json.is_discarded()) { + SPDLOG_ERROR("json parse error: [{}]", fields.back()); + boost::asio::post(ch->get_executor(), [=] { + ch->try_send(err, std::format("json parse error: [{}]", fields.back())); + }); + continue; + } + auto str = line_json["choices"][0]["delta"]["content"].get(); + if (!str.empty() && str != "[DONE]") + boost::asio::post(ch->get_executor(), [=] { ch->try_send(err, str); }); + } + return; + }) + .setHttpHeaders([&] -> auto { + std::unordered_multimap headers{ + {"Accept", "application/json, text/event-stream"}, + {"Origin", "https://free.chatgpt.org.uk"}, + {"Referer", "https://free.chatgpt.org.uk/"}, + {"Host", "free.chatgpt.org.uk"}, + }; + return headers; + }()) + .perform(); + if (ret.has_value()) { + SPDLOG_ERROR("{}", ret.value()); + co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable)); + ch->try_send(err, ret.value()); + } + co_return; +} +boost::asio::awaitable FreeGpt::chatxyz(std::shared_ptr ch, nlohmann::json json) { + co_await boost::asio::post(boost::asio::bind_executor(*m_thread_pool_ptr, boost::asio::use_awaitable)); + ScopeExit _exit{[=] { boost::asio::post(ch->get_executor(), [=] { ch->close(); }); }}; + + auto prompt = json.at("meta").at("content").at("parts").at(0).at("content").get(); + + boost::system::error_code err{}; + std::unordered_multimap headers{ + {"Accept", "text/event-stream"}, + {"content-type", "application/json"}, + {"Referer", "https://chat.3211000.xyz/"}, + {"Origin", "https://chat.3211000.xyz"}, + {"Sec-Fetch-Dest", "empty"}, + {"Sec-Fetch-Mode", "cors"}, + {"Sec-Fetch-Site", "same-origin"}, + {"TE", "trailers"}, + {"x-requested-with", "XMLHttpRequest"}, + }; + std::string recv; + auto ret = Curl() + .setUrl("https://chat.3211000.xyz/api/openai/v1/chat/completions") + .setProxy(m_cfg.http_proxy) + .setRecvHeadersCallback([](std::string) { return; }) + .setRecvBodyCallback([&](std::string chunk_str) mutable { + recv.append(chunk_str); + while (true) { + auto position = recv.find("\n"); + if (position == std::string::npos) + break; + auto msg = recv.substr(0, position + 1); + recv.erase(0, position + 1); + msg.pop_back(); + if (msg.empty() || !msg.contains("content")) + continue; + auto fields = splitString(msg, "data: "); + boost::system::error_code err{}; + nlohmann::json line_json = nlohmann::json::parse(fields.back(), nullptr, false); + if (line_json.is_discarded()) { + SPDLOG_ERROR("json parse error: [{}]", fields.back()); + ch->try_send(err, std::format("json parse error: [{}]", fields.back())); + continue; + } + if (line_json["choices"][0]["delta"]["content"].is_null()) + continue; + auto str = line_json["choices"][0]["delta"]["content"].get(); + if (!str.empty()) + ch->try_send(err, str); + } + }) + .setBody([&] { + constexpr std::string_view ask_json_str = R"({ + "messages":[ + { + "role":"system", + "content":"\nYou are ChatGPT, a large language model trained by OpenAI.\nCarefully heed the user's instructions.\nRespond using Markdown.\nKnowledge cutoff: 2021-09\nCurrent model: gpt-3.5-turbo\nCurrent time: 2023/12/26 14:12:34\nLatex inline: $x^2$ \nLatex block: $$e=mc^2$$\n\n" + }, + { + "role":"user", + "content":"hello" + } + ], + "stream":true, + "model":"gpt-3.5-turbo", + "temperature":0.5, + "presence_penalty":0, + "frequency_penalty":0, + "top_p":1 + })"; + nlohmann::json ask_request = nlohmann::json::parse(ask_json_str, nullptr, false); + ask_request["messages"][1]["content"] = prompt; + std::string ask_request_str = ask_request.dump(); + SPDLOG_INFO("request: [{}]", ask_request_str); + return ask_request_str; + }()) + .clearHeaders() + .setHttpHeaders(headers) + .perform(); + if (ret.has_value()) { + SPDLOG_ERROR("{}", ret.value()); + co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable)); + ch->try_send(err, ret.value()); + } + co_return; +} +boost::asio::awaitable FreeGpt::chatGptAi(std::shared_ptr ch, nlohmann::json json) { + ScopeExit auto_exit{[&] { ch->close(); }}; + boost::system::error_code err{}; + + constexpr std::string_view host = "chatgpt.ai"; + constexpr std::string_view port = "443"; + + constexpr std::string_view user_agent{ + R"(Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36)"}; + + boost::beast::http::request req{boost::beast::http::verb::get, "/", 11}; + req.set(boost::beast::http::field::host, "chatgpt.ai"); + req.set(boost::beast::http::field::user_agent, user_agent); + req.set("Accept", "*/*"); + + int recreate_num{0}; +create_client: + boost::asio::ssl::context ctx(boost::asio::ssl::context::tls); + ctx.set_verify_mode(boost::asio::ssl::verify_none); + auto client = co_await createHttpClient(ctx, host, port); + if (!client.has_value()) { + SPDLOG_ERROR("createHttpClient: {}", client.error()); + co_await ch->async_send(err, client.error(), use_nothrow_awaitable); + co_return; + } + auto& stream_ = client.value(); + + std::string chunk_body; + std::string cookie; + auto ret = co_await sendRequestRecvChunk( + ch, stream_, req, 200, [&ch, &chunk_body](std::string recv_str) { chunk_body.append(std::move(recv_str)); }, + [&](const boost::beast::http::parser& p) { + auto& headers = p.get(); + for (const auto& header : headers) { + if (boost::beast::http::to_string(header.name()) == "Set-Cookie") { + cookie = header.value(); + return; + } + } + }); + SPDLOG_ERROR("cookie: {}", cookie); + if (ret == Status::Close && recreate_num == 0) { + recreate_num++; + goto create_client; + } + if (ret == Status::HasError) + co_return; + + static std::string pattern{R"(data-system='(.*?)')"}; + + std::vector matches = findAll(pattern, chunk_body); + if (matches.empty()) { + SPDLOG_ERROR("parsing login failed"); + co_await ch->async_send(err, chunk_body, use_nothrow_awaitable); + co_return; + } + + auto html_unescape = [](const std::string& text) { + std::string result = text; + boost::replace_all(result, "&", "&"); + boost::replace_all(result, "<", "<"); + boost::replace_all(result, ">", ">"); + boost::replace_all(result, """, "\""); + boost::replace_all(result, "'", "'"); + return result; + }; + std::string html_json_str; + std::regex regex("'(.*?)'"); + std::smatch result; + if (std::regex_search(matches[0], result, regex)) + html_json_str = html_unescape(result[1]); + if (html_json_str.empty()) { + SPDLOG_ERROR("extract json fail"); + co_await ch->async_send(err, chunk_body, use_nothrow_awaitable); + co_return; + } + nlohmann::json j = nlohmann::json::parse(html_json_str, nullptr, false); + if (j.is_discarded()) { + SPDLOG_ERROR("json parse error"); + co_await ch->async_send(err, "json parse error", use_nothrow_awaitable); + co_return; + } + SPDLOG_INFO("json: {}", j.dump()); + + auto prompt = json.at("meta").at("content").at("parts").at(0).at("content").get(); + + boost::beast::http::request request{boost::beast::http::verb::post, + "/wp-json/mwai-ui/v1/chats/submit", 11}; + request.set(boost::beast::http::field::host, host); + request.set("authority", "chatgpt.ai"); + request.set("accept", "*/*"); + request.set("accept-language", R"(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)"); + request.set("cache-control", "no-cache"); + request.set("origin", "https://chatgpt.ai"); + request.set("pragma", "no-cache"); + request.set(boost::beast::http::field::referer, "https://chatgpt.ai/"); + request.set("sec-ch-ua", R"("Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114")"); + request.set("sec-ch-ua-mobile", "?0"); + request.set("sec-ch-ua-platform", R"("Windows")"); + request.set("sec-fetch-dest", "empty"); + request.set("sec-fetch-mode", "cors"); + request.set("sec-fetch-site", "same-origin"); + request.set("Cookie", cookie); + request.set(boost::beast::http::field::user_agent, user_agent); + request.set("Content-Type", "application/json"); + request.set("X-Wp-Nonce", j["restNonce"]); + + constexpr std::string_view json_str = R"({ + "botId":"chatbot-9vy3t5", + "customId":null, + "session":"N/A", + "chatId":"6tkwezdhivn", + "contextId":1048, + "messages":[ + { + "role":"user", + "content":"hello" + } + ], + "newMessage":"hello", + "stream":true + })"; + nlohmann::json request_json = nlohmann::json::parse(json_str, nullptr, false); + request_json["botId"] = j["botId"]; + request_json["customId"] = j["customId"]; + request_json["session"] = j["sessionId"]; + request_json["contextId"] = j["contextId"]; + request_json["chatId"] = [](int len) -> std::string { + static std::string chars{"abcdefghijklmnopqrstuvwxyz0123456789"}; + static std::string letter{"abcdefghijklmnopqrstuvwxyz"}; + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution<> dis(0, 1000000); + std::string random_string; + random_string += chars[dis(gen) % letter.length()]; + len = len - 1; + for (int i = 0; i < len; i++) + random_string += chars[dis(gen) % chars.length()]; + return random_string; + }(11); + request_json["messages"] = getConversationJson(json); + + request_json["newMessage"] = prompt; + + SPDLOG_INFO("request: {}", request_json.dump()); + request.body() = request_json.dump(); + request.prepare_payload(); + + std::string recv; + co_await sendRequestRecvChunk(ch, stream_, request, 200, [&](std::string str) { + recv.append(str); + while (true) { + auto position = recv.find("\n"); + if (position == std::string::npos) + break; + auto msg = recv.substr(0, position + 1); + recv.erase(0, position + 1); + msg.pop_back(); + if (msg.empty()) + continue; + auto fields = splitString(msg, "data: "); + boost::system::error_code err{}; + nlohmann::json line_json = nlohmann::json::parse(fields.back(), nullptr, false); + if (line_json.is_discarded()) { + SPDLOG_ERROR("json parse error: [{}]", fields.back()); + ch->try_send(err, std::format("json parse error: [{}]", fields.back())); + continue; + } + auto type = line_json["type"].get(); + if (type == "live") + ch->try_send(err, line_json["data"].get()); + } + }); + co_return; +} +boost::asio::awaitable FreeGpt::chatGptDemo(std::shared_ptr ch, nlohmann::json json) { + co_await boost::asio::post(boost::asio::bind_executor(*m_thread_pool_ptr, boost::asio::use_awaitable)); + ScopeExit _exit{[=] { boost::asio::post(ch->get_executor(), [=] { ch->close(); }); }}; + + boost::system::error_code err{}; + auto prompt = json.at("meta").at("content").at("parts").at(0).at("content").get(); + + std::unordered_multimap http_headers{ + {"authority", "chat.chatgptdemo.net"}, + {"origin", "https://chat.chatgptdemo.net"}, + {"referer", "https://chat.chatgptdemo.net/"}, + }; + + std::string recv, header_str; + Curl curl; + auto ret = curl.setUrl("https://chat.chatgptdemo.net/") + .setProxy(m_cfg.http_proxy) + .setRecvHeadersCallback([&](std::string str) { header_str.append(str); }) + .setRecvBodyCallback([&](std::string str) { recv.append(str); }) + .setHttpHeaders(http_headers) + .perform(); + if (ret) { + co_await boost::asio::post(boost::asio::bind_executor(ch->get_executor(), boost::asio::use_awaitable)); + ch->try_send(err, ret.value()); + co_return; + } + // auto response_header = Curl::parseHttpHeaders(header_str); + // for (auto& [k, v] : response_header) + // SPDLOG_INFO("{}: {}", k, v); + + auto match_ret = findAll(R"(