Slic3r::anonymous_namespace{PythonInterpreter.cpp} Namespace Reference

Functions
std::string	format_python_error (PyObject *ptype, PyObject *pvalue, PyObject *ptraceback)
std::string	executable_name (const char *base)
bool	add_sys_path_entry (const boost::filesystem::path &path, std::string &error, bool *inserted=nullptr)
void	log_python_stream (PyObject *sys, const char *name)
void	restore_python_stream (PyObject *sys, const char *name)
void	install_python_stderr_redirect ()
void	log_and_restore_python_stdio ()
bool	valid_python_home (const boost::filesystem::path &candidate)
boost::filesystem::path	find_bundled_python_home ()
boost::filesystem::path	find_python_executable (const boost::filesystem::path &python_home)

Variables
constexpr const char *	PYTHON_STDLIB_DIR = "python3.12"
constexpr const char *	PYTHON_EXECUTABLE = "python3.12"

Function Documentation

add_sys_path_entry()

bool Slic3r::anonymous_namespace{PythonInterpreter.cpp}::add_sys_path_entry	(	const boost::filesystem::path &	path,
		std::string &	error,
		bool *	inserted = nullptr )

{
    if (inserted)
        *inserted = false;
 
    PyObject* sys_path = PySys_GetObject("path");
    if (!sys_path || !PyList_Check(sys_path)) {
        error = "Python sys.path is not available";
        return false;
    }
 
    const std::string path_str = path.string();
    PyObjectPtr py_path(PyUnicode_DecodeFSDefault(path_str.c_str()));
    if (!py_path) {
        error = "Failed to decode path for Python sys.path: " + path_str;
        PyErr_Clear();
        return false;
    }
 
    const int contains = PySequence_Contains(sys_path, py_path.get());
    if (contains == 1)
        return true;
    if (contains < 0)
        PyErr_Clear();
 
    if (PyList_Insert(sys_path, 0, py_path.get()) != 0) {
        error = "Failed to add path to Python sys.path: " + path_str;
        PyErr_Clear();
        return false;
    }
 
    if (inserted)
        *inserted = true;
 
    return true;
}

References add_sys_path_entry(), Slic3r::Geometry::contains(), and Slic3r::PyObjectPtr::get().

Referenced by add_sys_path_entry().

Here is the call graph for this function:

Here is the caller graph for this function:

executable_name()

std::string Slic3r::anonymous_namespace{PythonInterpreter.cpp}::executable_name

(

const char *

base

)

{
#ifdef _WIN32
    return std::string(base) + ".exe";
#else
    return base;
#endif
}

References executable_name().

Referenced by executable_name().

Here is the call graph for this function:

Here is the caller graph for this function:

find_bundled_python_home()

boost::filesystem::path Slic3r::anonymous_namespace{PythonInterpreter.cpp}::find_bundled_python_home

(

)

{
    PyObject* sys = PyImport_ImportModule("sys");
    if (!sys) {
        PyErr_Clear();
        BOOST_LOG_TRIVIAL(warning) << "Python shutdown: failed to import sys for stdio diagnostics";
        return;
    }
 
    log_python_stream(sys, "stdout");
    log_python_stream(sys, "stderr");
    restore_python_stream(sys, "stdout");
    restore_python_stream(sys, "stderr");
 
    Py_DECREF(sys);
}
 
bool valid_python_home(const boost::filesystem::path& candidate)
{
#ifdef _WIN32
    return boost::filesystem::exists(candidate / "Lib" / "encodings") &&
           (boost::filesystem::exists(candidate / PYTHON_DLL) || boost::filesystem::exists(candidate / PYTHON_DEBUG_DLL));
#else
    return boost::filesystem::exists(candidate / "lib" / PYTHON_STDLIB_DIR / "encodings");
#endif
}
 
boost::filesystem::path find_bundled_python_home()
{
    namespace fs = boost::filesystem;
 
#ifdef __APPLE__
    fs::path bundle_python = fs::path(resources_dir()).parent_path() / "MacOS" / "python";
    if (valid_python_home(bundle_python))
        return bundle_python;
#elif !defined(_WIN32)
    fs::path linux_python = fs::path(resources_dir()).parent_path() / "lib" / "python";
    if (valid_python_home(linux_python))
        return linux_python;
#endif
 
    // Next to the executable: the Windows install layout, and the runtime copied
    // beside every platform's unit-test binary (tests/slic3rutils/CMakeLists.txt).

find_python_executable()

boost::filesystem::path Slic3r::anonymous_namespace{PythonInterpreter.cpp}::find_python_executable

(

const boost::filesystem::path &

python_home

)

                                                   {
        fs::path libpython = fs::path(prefix_path) / "libpython";
        if (valid_python_home(libpython))
            return libpython;
    }
 
    fs::path res_python = fs::path(resources_dir()) / "python";
    if (valid_python_home(res_python))
        return res_python;
 
#ifndef _WIN32
    fs::path data_python = fs::path(data_dir()) / "python";
    if (valid_python_home(data_python))

References valid_python_home().

Here is the call graph for this function:

format_python_error()

std::string Slic3r::anonymous_namespace{PythonInterpreter.cpp}::format_python_error	(	PyObject *	ptype,
		PyObject *	pvalue,
		PyObject *	ptraceback )

{
    std::string result;
 
    if (ptype) {
        PyObject* type_name = PyObject_GetAttrString(ptype, "__name__");
        if (type_name) {
            const char* s = PyUnicode_AsUTF8(type_name);
            if (s) result += s;
            Py_DECREF(type_name);
        }
    }
 
    if (pvalue) {
        if (!result.empty()) result += ": ";
        PyObject* s = PyObject_Str(pvalue);
        if (s) {
            const char* cstr = PyUnicode_AsUTF8(s);
            if (cstr) result += cstr;
            Py_DECREF(s);
        }
    }
 
    if (ptraceback) {
        result += "\nTraceback (most recent call last):";
        PyTracebackObject* tb = reinterpret_cast<PyTracebackObject*>(ptraceback);
        while (tb) {
            PyFrameObject* frame = tb->tb_frame;
            int line = PyFrame_GetLineNumber(frame);
            PyCodeObject* code = PyFrame_GetCode(frame); // returns a NEW strong reference; must be released
            const char* filename = code ? PyUnicode_AsUTF8(code->co_filename) : nullptr;
            const char* funcname = code ? PyUnicode_AsUTF8(code->co_name) : nullptr;
            result += "\n  File \"" + std::string(filename ? filename : "?") +
                      "\", line " + std::to_string(line) +
                      ", in " + std::string(funcname ? funcname : "?");
            Py_XDECREF(code);
            tb = tb->tb_next;
        }
    }
 
    return result;
}

References format_python_error().

Referenced by format_python_error().

Here is the call graph for this function:

Here is the caller graph for this function:

install_python_stderr_redirect()

void Slic3r::anonymous_namespace{PythonInterpreter.cpp}::install_python_stderr_redirect

(

)

{
    // Mirror the session filename convention from GUI_App: python_<weekday>_<mon>_<day>_<HH>_<MM>_<SS>_<pid>.log
    std::time_t t = std::time(nullptr);
    std::tm* now  = std::localtime(&t);
    std::ostringstream name;
    name << std::put_time(now, "python_%a_%b_%d_%H_%M_%S_") << get_current_pid() << ".log";
    const std::string log_path = (boost::filesystem::path(data_dir()) / "log" / name.str()).generic_string();
 
    const std::string redirect_script =
        "import io, os, sys, threading\n"
        "_ORCA_PYTHON_LOG = \"" + log_path + "\"\n"
        + std::string(R"REDIRECT_SCRIPT(
class _OrcaTeeStderr(io.TextIOBase):
    def __init__(self, original, path):
        self._original = original
        self._path = path
        self._lock = threading.Lock()
    def writable(self):
        return True
    def write(self, s):

References Slic3r::data_dir(), Slic3r::get_current_pid(), and install_python_stderr_redirect().

Referenced by install_python_stderr_redirect().

Here is the call graph for this function:

Here is the caller graph for this function:

log_and_restore_python_stdio()

void Slic3r::anonymous_namespace{PythonInterpreter.cpp}::log_and_restore_python_stdio

(

)

                                         :
                self._original.write(s)
        except Exception:
            pass
        try:
            with self._lock, open(self._path, "a", encoding="utf-8", errors="replace") as f:
                f.write(s)
        except Exception:
            pass
        return len(s)
    def flush(self):
        try:
            if self._original is not None:
                self._original.flush()
        except Exception:
            pass

log_python_stream()

void Slic3r::anonymous_namespace{PythonInterpreter.cpp}::log_python_stream	(	PyObject *	sys,
		const char *	name )

{
    PyObject* stream = PyObject_GetAttrString(sys, name);
    if (!stream) {
        PyErr_Clear();
        BOOST_LOG_TRIVIAL(info) << "Python shutdown: sys." << name << " is not set";
        return;
    }
 
    PyObject* original        = nullptr;
    std::string original_name = std::string("__") + name + "__";
    original                  = PyObject_GetAttrString(sys, original_name.c_str());
    if (!original)
        PyErr_Clear();
 
    BOOST_LOG_TRIVIAL(info) << "Python shutdown: sys." << name << " type=" << Py_TYPE(stream)->tp_name << " ptr=" << stream
                            << " original_ptr=" << original << " is_original=" << (stream == original);
 
    Py_XDECREF(original);
    Py_DECREF(stream);
}

References log_python_stream().

Referenced by log_python_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

restore_python_stream()

void Slic3r::anonymous_namespace{PythonInterpreter.cpp}::restore_python_stream	(	PyObject *	sys,
		const char *	name )

{
    std::string original_name = std::string("__") + name + "__";
    PyObject* original        = PyObject_GetAttrString(sys, original_name.c_str());
    if (!original) {
        PyErr_Clear();
        original = Py_NewRef(Py_None);
    }
 
    if (PyObject_SetAttrString(sys, name, original) < 0) {
        PyErr_Clear();
        BOOST_LOG_TRIVIAL(warning) << "Python shutdown: failed to restore sys." << name;
    } else {
        BOOST_LOG_TRIVIAL(info) << "Python shutdown: restored sys." << name << " to type=" << Py_TYPE(original)->tp_name
                                << " ptr=" << original;
    }
 
    Py_DECREF(original);
}

References restore_python_stream().

Referenced by restore_python_stream().

Here is the call graph for this function:

Here is the caller graph for this function:

valid_python_home()

bool Slic3r::anonymous_namespace{PythonInterpreter.cpp}::valid_python_home

(

const boost::filesystem::path &

candidate

)

                                                          {
        PyErr_Clear();
        BOOST_LOG_TRIVIAL(warning) << "Failed to install Python stderr redirect to " << log_path;
    } else {

Referenced by find_python_executable().

Here is the caller graph for this function:

Variable Documentation

PYTHON_EXECUTABLE

const char* Slic3r::anonymous_namespace{PythonInterpreter.cpp}::PYTHON_EXECUTABLE = "python3.12"

constexpr

PYTHON_STDLIB_DIR

const char* Slic3r::anonymous_namespace{PythonInterpreter.cpp}::PYTHON_STDLIB_DIR = "python3.12"

constexpr