Revision control
++ // Copyright (C) 2025 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
++
++ #include "machinetranslator.h"
++ #include "ollama.h"
++ #include "openaicompatible.h"
++ #include "translatormessage.h"
++ #include "translationsettings.h"
++ #include "simtexth.h"
++
++ #include <QtNetwork/qnetworkaccessmanager.h>
++ #include <QtNetwork/qnetworkreply.h>
++ #include <QtNetwork/qnetworkrequest.h>
++
++ using namespace Qt::Literals::StringLiterals;
++
++ QT_BEGIN_NAMESPACE
++
++ MachineTranslator::MachineTranslator()
++ : m_request(std::make_unique<QNetworkRequest>()),
++ m_manager(std::make_unique<QNetworkAccessManager>())
++ {
++ m_request->setHeader(QNetworkRequest::ContentTypeHeader, "application/json"_L1);
++ m_request->setTransferTimeout(TranslationSettings::transferTimeoutMs());
++ }
++
++ void MachineTranslator::setApiType(TranslationApiType type)
++ {
++ switch (type) {
++ case TranslationApiType::Ollama:
++ m_translator = std::make_unique<Ollama>();
++ break;
++ case TranslationApiType::OpenAICompatible:
++ m_translator = std::make_unique<OpenAICompatible>();
++ break;
++ }
++ }
++
++ MachineTranslator::~MachineTranslator() = default;
++
++ void MachineTranslator::translate(const Messages &messages, const QString &userContext)
++ {
++ QMutexLocker locker(&m_queueMutex);
++
++ m_pendingBatches.clear();
++ auto batches = m_translator->makeBatches(messages, userContext);
++
++ for (auto &b : batches)
++ m_pendingBatches.enqueue(std::move(b));
++
++ processNextBatches();
++ }
++
++ void MachineTranslator::start() noexcept
++ {
++ QMutexLocker locker(&m_queueMutex);
++ m_pendingBatches.clear();
++ m_session++;
++ m_stopped = false;
++ }
++
++ void MachineTranslator::setUrl(const QString &url)
++ {
++ m_translator->setUrl(url);
++ m_request->setUrl(m_translator->translationEndpoint());
++ }
++
++ void MachineTranslator::setApiKey(const QString &apiKey)
++ {
++ if (!apiKey.isEmpty())
++ m_request->setRawHeader("Authorization", "Bearer " + apiKey.toUtf8());
++ else
++ m_request->setRawHeader("Authorization", QByteArray());
++ }
++
++ void MachineTranslator::activateTranslationModel(const QString &modelName)
++ {
++ if (auto wakeupPayload = m_translator->stageModel(modelName)) {
++ // after several minutes of being idle, Ollama offloads the model
++ // and the rest API needs to be waken up. Trying to connect with
++ // Ollama for the first time after several minutes wakes up the
++ // server, but for some reason the server doesn't queue the
++ // connection request that was sent to it while it was not awake. As a result,
++ // the connection in QNetworkAccessManager is half broken and not working,
++ // without us knowing about it.
++ // Here we are using a new QNetworkAccessManager instance to send
++ // the first connection request and wake up the model. Then we delete the
++ // QNetworkAccessManager instance since it contains a broken connection
++ // and will try to use it for the next requests otherwise.
++
++ auto *tempManager = new QNetworkAccessManager(this);
++
++ QNetworkRequest wakeupRequest(m_translator->translationEndpoint());
++ wakeupRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json"_L1);
++ wakeupRequest.setTransferTimeout(30000);
++
++ QNetworkReply *reply = tempManager->post(wakeupRequest, *wakeupPayload);
++
++ connect(reply, &QNetworkReply::finished, this, [tempManager, reply]() {
++ reply->deleteLater();
++ tempManager->deleteLater();
++ });
++ }
++ }
++
++ void MachineTranslator::requestModels()
++ {
++ QNetworkRequest req(m_translator->discoveryEndpoint());
++ // Copy Authorization header for APIs that require authentication (e.g., OpenRouter)
++ if (m_request->hasRawHeader("Authorization"))
++ req.setRawHeader("Authorization", m_request->rawHeader("Authorization"));
++ QNetworkReply *reply = m_manager->get(req);
++ connect(reply, &QNetworkReply::finished, this, [this, reply]() {
++ reply->deleteLater();
++ QStringList models;
++ if (reply->error() == QNetworkReply::NoError) {
++ const QByteArray response = reply->readAll();
++ models = m_translator->extractModels(response);
++ }
++ emit modelsReceived(std::move(models));
++ });
++ }
++
++ void MachineTranslator::translateBatch(Batch b)
++ {
++ Q_ASSERT_X(!m_queueMutex.tryLock(), Q_FUNC_INFO,
++ "The function requires m_queueMutex to be held.");
++ if (m_stopped)
++ return;
++ m_inFlightCount++;
++ const QByteArray body = m_translator->payload(b);
++ emit debugLog(body, false);
++ QNetworkReply *reply = m_manager->post(*m_request, body);
++ connect(reply, &QNetworkReply::finished, this,
++ [this, reply, batch = std::move(b), session = m_session.load()] {
++ translationReceived(reply, std::move(batch), session);
++ });
++ }
++
++ void MachineTranslator::processNextBatches()
++ {
++ Q_ASSERT_X(!m_queueMutex.tryLock(), Q_FUNC_INFO,
++ "The function requires m_queueMutex to be held.");
++ if (m_stopped || m_pendingBatches.isEmpty())
++ return;
++
++ const int maxConcurrent = TranslationSettings::maxConcurrentBatches();
++ const int batchesToSchedule = qMin(maxConcurrent - m_inFlightCount, m_pendingBatches.size());
++ for (int i = 0; i < batchesToSchedule; ++i) {
++ Batch batch = m_pendingBatches.dequeue();
++ translateBatch(std::move(batch));
++ }
++ }
++
++ void MachineTranslator::translationReceived(QNetworkReply *reply, Batch b, int session)
++ {
++ reply->deleteLater();
++
++ if (m_stopped || session != m_session) {
++ QMutexLocker locker(&m_queueMutex);
++ m_inFlightCount--;
++ processNextBatches();
++ return;
++ }
++
++ bool shouldRetry = false;
++ const QByteArray response = reply->readAll();
++ emit debugLog(response, true);
++ const int maxRetries = TranslationSettings::maxRetries();
++
++ if (reply->error() != QNetworkReply::NoError) {
++ const auto error = reply->error();
++
++ if (error == QNetworkReply::ProtocolInvalidOperationError)
++ m_translator->onRequestRejected();
++
++ const bool isRetriableError = error == QNetworkReply::OperationCanceledError
++ || error == QNetworkReply::TimeoutError
++ || error == QNetworkReply::UnknownNetworkError
++ || error == QNetworkReply::ProtocolInvalidOperationError;
++ shouldRetry = b.tries < maxRetries && isRetriableError;
++ if (!shouldRetry) {
++ QList<const TranslatorMessage *> failed;
++ for (const auto &i : std::as_const(b.items))
++ failed.append(i.msg);
++ emit translationFailed(std::move(failed));
++ }
++ } else {
++ QList<Item> items = std::move(b.items);
++ QHash<const TranslatorMessage *, QStringList> out;
++ QHash<QString, QStringList> translations =
++ m_translator->extractTranslations(response, b.pluralFormsCount > 1);
++
++ // First pass: exact matches
++ QList<Item> nonMatched;
++ for (Item &i : items) {
++ if (i.msg->translation().isEmpty()) {
++ if (auto translation = translations.find(i.msg->sourceText());
++ translation != translations.end()) {
++ out[i.msg] = *translation;
++ translations.erase(translation);
++ } else {
++ nonMatched.append(std::move(i));
++ }
++ }
++ }
++
++ // Second pass: fuzzy matching for non-matched items with unused translations
++ constexpr int similarityThreshold = 200;
++ for (Item &i : nonMatched) {
++ StringSimilarityMatcher matcher(i.msg->sourceText());
++ QString bestMatch;
++ int bestScore = 0;
++ for (auto it = translations.cbegin(); it != translations.cend(); ++it) {
++ const int score = matcher.getSimilarityScore(it.key());
++ if (score >= similarityThreshold && score > bestScore) {
++ bestScore = score;
++ bestMatch = it.key();
++ }
++ }
++
++ if (!bestMatch.isEmpty())
++ out[i.msg] = translations.take(bestMatch);
++ else
++ b.items.append(std::move(i));
++ }
++
++ const bool nonTranslatedItems = !b.items.empty();
++ shouldRetry = nonTranslatedItems && b.tries < maxRetries;
++ if (nonTranslatedItems && !shouldRetry) {
++ QList<const TranslatorMessage *> failed;
++ for (const auto &i : std::as_const(b.items))
++ failed.append(i.msg);
++ emit translationFailed(std::move(failed));
++ }
++ if (!out.empty())
++ emit batchTranslated(std::move(out));
++ }
++
++ QMutexLocker locker(&m_queueMutex);
++ m_inFlightCount--;
++ if (shouldRetry) {
++ b.tries++;
++ m_pendingBatches.prepend(std::move(b)); // Front of queue for priority
++ }
++ processNextBatches();
++ }
++
++ QT_END_NAMESPACE