ApplicationsLib::anonymous_namespace{ogs_embedded_python.cpp} Namespace Reference

Classes
struct	PipeCloser
	Custom deleter for FILE handles from popen. More...

Functions
std::optional< std::string >	executeCommand (std::string_view command)
	Executes a command and captures its stdout output using popen.
std::optional< std::pair< int, int > >	getPythonVersionFromVenv (std::filesystem::path const &venv_path)
	Gets Python version by executing the venv's python executable.
std::filesystem::path	findSitePackagesPath (std::filesystem::path const &venv_path)
	Finds site-packages path in the virtual environment.

Function Documentation

executeCommand()

std::optional< std::string > ApplicationsLib::anonymous_namespace{ogs_embedded_python.cpp}::executeCommand

(

std::string_view

command

)

Executes a command and captures its stdout output using popen.

Definition at line 55 of file ogs_embedded_python.cpp.

{
    std::array<char, 256> buffer;
    std::string result;
 
#ifdef _WIN32
    std::unique_ptr<FILE, PipeCloser> pipe(_popen(command.data(), "r"));
#else
    std::unique_ptr<FILE, PipeCloser> pipe(popen(command.data(), "r"));
#endif  // _WIN32
 
    if (!pipe)
    {
        DBUG("Failed to execute command: {}", command);
        return std::nullopt;
    }
 
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr)
    {
        result += buffer.data();
    }
 
    return result;
}

References DBUG(), and executeCommand().

Referenced by executeCommand(), and getPythonVersionFromVenv().

findSitePackagesPath()

std::filesystem::path ApplicationsLib::anonymous_namespace{ogs_embedded_python.cpp}::findSitePackagesPath

(

std::filesystem::path const &

venv_path

)

Finds site-packages path in the virtual environment.

Definition at line 140 of file ogs_embedded_python.cpp.

{
    namespace fs = std::filesystem;
 
#ifdef _WIN32
    // On Windows: venv/Lib/site-packages
    fs::path const site_packages = venv_path / "Lib" / "site-packages";
#else
    // On Unix: venv/lib/pythonX.Y/site-packages
    auto const version = getPythonVersionFromVenv(venv_path);
    if (!version.has_value())
    {
        OGS_FATAL(
            "Failed to determine Python version of the virtual environment.");
    }
    fs::path const site_packages = venv_path / "lib" /
                                   ("python" + std::to_string(version->first) +
                                    "." + std::to_string(version->second)) /
                                   "site-packages";
#endif  // _WIN32
 
    if (!fs::exists(site_packages))
    {
        OGS_FATAL("site-packages directory not found at '{}'",
                  site_packages.string());
    }
 
    return site_packages;
}

References findSitePackagesPath(), getPythonVersionFromVenv(), and OGS_FATAL.

Referenced by findSitePackagesPath().

getPythonVersionFromVenv()

std::optional< std::pair< int, int > > ApplicationsLib::anonymous_namespace{ogs_embedded_python.cpp}::getPythonVersionFromVenv

(

std::filesystem::path const &

venv_path

)

Gets Python version by executing the venv's python executable.

Definition at line 81 of file ogs_embedded_python.cpp.

{
    namespace fs = std::filesystem;
 
    fs::path python_exe;
#ifdef _WIN32
    python_exe = venv_path / "Scripts" / "python.exe";
#else
    python_exe = venv_path / "bin" / "python";
#endif  // _WIN32
 
    if (!fs::exists(python_exe))
    {
        DBUG("Python executable not found at: {}", python_exe.string());
        return std::nullopt;
    }
 
    std::string const command = "\"" + python_exe.string() + "\" --version";
    auto const output = executeCommand(command);
 
    if (!output.has_value())
    {
        DBUG("Failed to get Python version from: {}", python_exe.string());
        return std::nullopt;
    }
 
    // Parse output like "Python 3.11.5"
    std::string_view const out_view(output.value());
    constexpr std::string_view prefix = "Python ";
    std::string_view version_part = out_view.substr(prefix.size());
    int major = 0, minor = 0;
 
    auto dot = version_part.find('.');
    if (dot == std::string_view::npos)
    {
        DBUG("Failed to parse Python version from: {}", out_view);
        return std::nullopt;
    }
 
    auto parse = [](std::string_view sv, int& value)
    {
        auto [ptr, ec] =
            std::from_chars(sv.data(), sv.data() + sv.size(), value);
        return ec == std::errc{} && ptr != sv.data();
    };
 
    if (!parse(version_part.substr(0, dot), major) ||
        !parse(version_part.substr(dot + 1), minor))
    {
        DBUG("Failed to parse Python version from: {}", out_view);
        return std::nullopt;
    }
 
    DBUG("Detected Python version {}.{} from venv", major, minor);
    return std::make_pair(major, minor);
}

References DBUG(), executeCommand(), and getPythonVersionFromVenv().

Referenced by findSitePackagesPath(), and getPythonVersionFromVenv().