ApplicationsLib::anonymous_namespace{ogs_embedded_python.cpp} Namespace Reference

Functions
std::vector< std::filesystem::path >	findAlternativeSitePackagesPaths (std::filesystem::path const &venv_path)
std::filesystem::path	findSitePackagesPath (std::filesystem::path const &venv_path, int const emb_major, int const emb_minor)
	Finds site-packages path in the virtual environment.

Function Documentation

findAlternativeSitePackagesPaths()

std::vector< std::filesystem::path > ApplicationsLib::anonymous_namespace{ogs_embedded_python.cpp}::findAlternativeSitePackagesPaths

(

std::filesystem::path const &

venv_path

)

Definition at line 121 of file ogs_embedded_python.cpp.

{
    namespace fs = std::filesystem;
 
    std::vector<fs::path> alternatives;
    fs::path const lib_path = venv_path / "lib";
 
    if (!fs::exists(lib_path) || !fs::is_directory(lib_path))
    {
        // Should not happen, i.e. if venv directory is not valid
        return {};
    }
 
    for (auto const& entry : fs::directory_iterator(lib_path))
    {
        if (!entry.is_directory())
        {
            continue;
        }
 
        std::string const dirname = entry.path().filename().string();
        if (!dirname.starts_with("python"))
        {
            continue;
        }
 
        fs::path const candidate = entry.path() / "site-packages";
        if (fs::exists(candidate) && fs::is_directory(candidate))
        {
            alternatives.push_back(candidate);
        }
    }
 
    return alternatives;
}

References findAlternativeSitePackagesPaths().

Referenced by findAlternativeSitePackagesPaths(), and findSitePackagesPath().

findSitePackagesPath()

std::filesystem::path ApplicationsLib::anonymous_namespace{ogs_embedded_python.cpp}::findSitePackagesPath	(	std::filesystem::path const &	venv_path,
		int const	emb_major,
		int const	emb_minor )

Finds site-packages path in the virtual environment.

Definition at line 159 of file ogs_embedded_python.cpp.

{
    namespace fs = std::filesystem;
 
#ifdef _WIN32
    // On Windows only: compare embedded python interpreter version with the
    // version of the python executable in the virtual environment.
    auto const venv_version = getPythonVersionFromVenv(venv_path);
    if (!venv_version.has_value())
    {
        OGS_FATAL(
            "Failed to determine Python version from virtual environment at "
            "'{}'.",
            venv_path.string());
    }
 
    if (venv_version->first != emb_major || venv_version->second != emb_minor)
    {
        OGS_FATAL(
            "Python version mismatch: embedded interpreter is {}.{}, but "
            "virtual environment at '{}' uses {}.{}.",
            emb_major, emb_minor, venv_path.string(), venv_version->first,
            venv_version->second);
    }
 
    fs::path const site_packages = venv_path / "Lib" / "site-packages";
#else
    // On Linux / macOS: Construct path to site-packages directory where the
    // Python version is embedded in the path. Then check for compatibility.
    // E.g.: .venv/lib/python3.14/site-packages.
    // Executing the virtual environment's Python interpreter may not possible
    // when executing Python BCs from within a container environment, i.e.
    // this would execute Python from the host inside the container.
    fs::path const site_packages = venv_path / "lib" /
                                   ("python" + std::to_string(emb_major) + "." +
                                    std::to_string(emb_minor)) /
                                   "site-packages";
#endif  // _WIN32
 
    if (!fs::exists(site_packages))
    {
#ifndef _WIN32
        // If correct site-packages directory is not found, check for
        // directories for other Python versions, indicating a Python version
        // mismatch. Possible on Linux / macOS only.
        auto const alternatives = findAlternativeSitePackagesPaths(venv_path);
        if (!alternatives.empty())
        {
            std::string alternative_paths;
            for (std::size_t i = 0; i < alternatives.size(); ++i)
            {
                if (i > 0)
                {
                    alternative_paths += ", ";
                }
                alternative_paths += "'" + alternatives[i].string() + "'";
            }
 
            WARN(
                "Expected site-packages directory '{}' was not found. "
                "Found other site-packages directory/directories: {}. This "
                "may indicate a Python version mismatch between the embedded "
                "interpreter {}.{} and the virtual environment.",
                site_packages.string(), alternative_paths, emb_major,
                emb_minor);
        }
#endif  // _WIN32
        OGS_FATAL("site-packages directory not found at '{}'",
                  site_packages.string());
    }
 
    return site_packages;
}

References findAlternativeSitePackagesPaths(), findSitePackagesPath(), OGS_FATAL, and WARN().

Referenced by findSitePackagesPath().