use venv

pythonrunner.cpp

@@ -1,12 +1,30 @@
 #include "pythonrunner.h"
 #include <QDebug>
+#include <QDir>
+#include <QStandardPaths>
+#include <QCoreApplication>
 
 PythonRunner::PythonRunner(QTextEdit* outputWidget, QObject* parent)
-    : QObject(parent), m_outputWidget(outputWidget), m_process(nullptr) {
+    : QObject(parent), m_outputWidget(outputWidget), m_process(nullptr), m_venvProcess(nullptr),
+      ready(false), venvPreparing(false) {
     m_process = new QProcess(this);
+    m_venvProcess = new QProcess(this);
     connect(m_process, &QProcess::readyReadStandardOutput, this, &PythonRunner::onOutputAvailable);
     connect(m_process, &QProcess::readyReadStandardError, this, &PythonRunner::onErrorAvailable);
     connect(m_process, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &PythonRunner::onProcessFinished);
+    connect(m_venvProcess, &QProcess::readyReadStandardOutput, this, [this]() {
+        QByteArray output = m_venvProcess->readAllStandardOutput();
+        m_outputWidget->append(output);
+        m_outputWidget->moveCursor(QTextCursor::End);
+        emit venvPreparationProgress(output);
+    });
+    connect(m_venvProcess, &QProcess::readyReadStandardError, this, [this]() {
+        QByteArray error = m_venvProcess->readAllStandardError();
+        m_outputWidget->append(error);
+        m_outputWidget->moveCursor(QTextCursor::End);
+        emit venvPreparationProgress(error);
+    });
+    connect(m_venvProcess, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &PythonRunner::onVenvProcessFinished);
 }
 
 PythonRunner::~PythonRunner() {
@@ -14,6 +32,10 @@ PythonRunner::~PythonRunner() {
         m_process->terminate();
         m_process->waitForFinished(1000);
     }
+    if (m_venvProcess) {
+        m_venvProcess->terminate();
+        m_venvProcess->waitForFinished(1000);
+    }
 }
 
 bool PythonRunner::runScript(const QString& scriptContent) {
@@ -23,7 +45,17 @@ bool PythonRunner::runScript(const QString& scriptContent) {
     }
 
     m_outputWidget->clear();
-    m_process->start("python3", QStringList() << "-u" << "-c" << scriptContent);
+
+    // Check if venv is ready, if not prepare it
+    if (!isVenvReady()) {
+        m_outputWidget->append("Preparing Python environment...\n");
+        m_outputWidget->moveCursor(QTextCursor::End);
+        prepareVenv();
+        return true; // Return early - venv preparation will handle script execution when ready
+    }
+
+    QString pythonPath = getVenvPythonPath();
+    m_process->start(pythonPath, QStringList() << "-u" << "-c" << scriptContent);
 
     return true;
 }
@@ -54,3 +86,158 @@ void PythonRunner::onProcessFinished(int exitCode, QProcess::ExitStatus exitStat
     }
     emit scriptFinished(exitCode);
 }
+
+void PythonRunner::onVenvProcessFinished(int exitCode, QProcess::ExitStatus exitStatus) {
+    if (exitStatus == QProcess::NormalExit && exitCode == 0) {
+        // Check if this was venv creation or pip installation
+        QString venvPythonPath = getVenvPythonPath();
+        if (!QFile::exists(venvPythonPath)) {
+            // This was venv creation, now install eismultiplexer package
+            installEismultiplexerPackage();
+        } else {
+            // This was pip installation, mark as ready
+            ready = true;
+            m_outputWidget->append("Python environment prepared successfully.\n");
+
+            // Signal that venv preparation is complete
+            {
+                QMutexLocker locker(&venvMutex);
+                venvPreparing = false;
+                venvCondition.wakeAll();
+            }
+
+            emit venvPreparationFinished();
+        }
+    } else {
+        ready = false;
+        m_outputWidget->append(QString("Failed to prepare Python environment (code %1)\n").arg(exitCode));
+
+        // Signal that venv preparation failed
+        {
+            QMutexLocker locker(&venvMutex);
+            venvPreparing = false;
+            venvCondition.wakeAll();
+        }
+
+        emit venvPreparationFinished();
+    }
+}
+
+void PythonRunner::prepareVenv() {
+    // Start venv preparation in a non-blocking manner
+    QMutexLocker locker(&venvMutex);
+    venvPreparing = true;
+
+    // Create virtual environment
+    QString pythonPath = getPythonExecutable();
+    QString venvPath = getVenvPath();
+
+    m_outputWidget->append(QString("Creating virtual environment at %1...\n").arg(venvPath));
+    m_outputWidget->moveCursor(QTextCursor::End);
+
+    QStringList args;
+    args << "-m" << "venv" << venvPath;
+
+    m_venvProcess->start(pythonPath, args);
+    if (!m_venvProcess->waitForStarted()) {
+        m_outputWidget->append("Failed to start virtual environment creation process.\n");
+        ready = false;
+        venvPreparing = false;
+        return;
+    }
+
+    // Don't wait for completion - this will be handled by the finished signal
+    // The installEismultiplexerPackage will be called in the finished signal handler
+}
+
+void PythonRunner::installEismultiplexerPackage() {
+    QString venvPythonPath = getVenvPythonPath();
+    QString venvPipPath = QString("%1 -m pip").arg(venvPythonPath);
+
+    m_outputWidget->append("Installing eismultiplexer package...\n");
+    m_outputWidget->moveCursor(QTextCursor::End);
+
+    QStringList args;
+    args << "install" << "eismultiplexer";
+
+    m_venvProcess->start(venvPipPath, args);
+    if (!m_venvProcess->waitForStarted()) {
+        m_outputWidget->append("Failed to start pip installation process.\n");
+        ready = false;
+
+        // Signal that venv preparation failed
+        {
+            QMutexLocker locker(&venvMutex);
+            venvPreparing = false;
+            venvCondition.wakeAll();
+        }
+
+        emit venvPreparationFinished();
+        return;
+    }
+
+    // Don't wait for completion - this will be handled by the finished signal
+}
+
+QString PythonRunner::getPythonExecutable() {
+    QString pythonPath;
+
+    // Try to find python3 first, then python
+    QStringList pythonCandidates;
+    pythonCandidates << "python3" << "python";
+
+    for (const QString& candidate : pythonCandidates) {
+        QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+        QString path = env.value("PATH");
+        QStringList pathDirs = path.split(';', Qt::SkipEmptyParts);
+
+        for (const QString& dir : pathDirs) {
+            QString pythonExecutable = QDir(dir).filePath(candidate);
+            if (QFile::exists(pythonExecutable)) {
+                pythonPath = pythonExecutable;
+                break;
+            }
+        }
+        if (!pythonPath.isEmpty()) {
+            break;
+        }
+    }
+
+    // If still not found, use the default python from QProcessEnvironment
+    if (pythonPath.isEmpty()) {
+        pythonPath = "python";
+    }
+
+    return pythonPath;
+}
+
+QString PythonRunner::getVenvPath() {
+    // Create venv in a temporary directory
+    QString venvDir = dir.path() + QDir::separator() + "venv";
+    return venvDir;
+}
+
+QString PythonRunner::getVenvPythonPath() {
+    QString venvPath = getVenvPath();
+    QString venvPython;
+
+    // Determine the correct python path for the venv based on platform
+    QString pythonExecutable = "python";
+
+    // On Windows, the python executable is in Scripts directory
+    // On Linux/macOS, it's in bin directory
+    QString venvBinDir;
+    #ifdef Q_OS_WIN
+    venvBinDir = venvPath + QDir::separator() + "Scripts";
+    #else
+    venvBinDir = venvPath + QDir::separator() + "bin";
+    #endif
+
+    venvPython = QDir(venvBinDir).filePath(pythonExecutable);
+    return venvPython;
+}
+
+bool PythonRunner::isVenvReady() {
+    QString venvPythonPath = getVenvPythonPath();
+    return QFile::exists(venvPythonPath);
+}