embed.h
Go to the documentation of this file.
1 /*
2  pybind11/embed.h: Support for embedding the interpreter
3 
4  Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
5 
6  All rights reserved. Use of this source code is governed by a
7  BSD-style license that can be found in the LICENSE file.
8 */
9 
10 #pragma once
11 
12 #include "pybind11.h"
13 #include "eval.h"
14 
15 #include <memory>
16 #include <vector>
17 
18 #if defined(PYPY_VERSION)
19 # error Embedding the interpreter is not supported with PyPy
20 #endif
21 
22 #define PYBIND11_EMBEDDED_MODULE_IMPL(name) \
23  extern "C" PyObject *pybind11_init_impl_##name(); \
24  extern "C" PyObject *pybind11_init_impl_##name() { return pybind11_init_wrapper_##name(); }
25 
41 #define PYBIND11_EMBEDDED_MODULE(name, variable) \
42  static ::pybind11::module_::module_def PYBIND11_CONCAT(pybind11_module_def_, name); \
43  static void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ &); \
44  static PyObject PYBIND11_CONCAT(*pybind11_init_wrapper_, name)() { \
45  auto m = ::pybind11::module_::create_extension_module( \
46  PYBIND11_TOSTRING(name), nullptr, &PYBIND11_CONCAT(pybind11_module_def_, name)); \
47  try { \
48  PYBIND11_CONCAT(pybind11_init_, name)(m); \
49  return m.ptr(); \
50  } \
51  PYBIND11_CATCH_INIT_EXCEPTIONS \
52  } \
53  PYBIND11_EMBEDDED_MODULE_IMPL(name) \
54  ::pybind11::detail::embedded_module PYBIND11_CONCAT(pybind11_module_, name)( \
55  PYBIND11_TOSTRING(name), PYBIND11_CONCAT(pybind11_init_impl_, name)); \
56  void PYBIND11_CONCAT(pybind11_init_, name)(::pybind11::module_ \
57  & variable) // NOLINT(bugprone-macro-parentheses)
58 
61 
62 struct embedded_module {
64  using init_t = PyObject *(*) ();
65  embedded_module(const char *name, init_t init) {
66  if (Py_IsInitialized() != 0) {
67  pybind11_fail("Can't add new modules after the interpreter has been initialized");
68  }
69 
70  auto result = PyImport_AppendInittab(name, init);
71  if (result == -1) {
72  pybind11_fail("Insufficient memory to add a new module");
73  }
74  }
75 };
76 
78  void operator()(wchar_t *ptr) const {
79  // API docs: https://docs.python.org/3/c-api/sys.html#c.Py_DecodeLocale
80  PyMem_RawFree(ptr);
81  }
82 };
83 
84 inline wchar_t *widen_chars(const char *safe_arg) {
85  wchar_t *widened_arg = Py_DecodeLocale(safe_arg, nullptr);
86  return widened_arg;
87 }
88 
89 inline void precheck_interpreter() {
90  if (Py_IsInitialized() != 0) {
91  pybind11_fail("The interpreter is already running");
92  }
93 }
94 
95 #if !defined(PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX)
96 # define PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX (0x03080000)
97 #endif
98 
99 #if PY_VERSION_HEX < PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
100 inline void initialize_interpreter_pre_pyconfig(bool init_signal_handlers,
101  int argc,
102  const char *const *argv,
103  bool add_program_dir_to_path) {
105  Py_InitializeEx(init_signal_handlers ? 1 : 0);
106 
107  // Before it was special-cased in python 3.8, passing an empty or null argv
108  // caused a segfault, so we have to reimplement the special case ourselves.
109  bool special_case = (argv == nullptr || argc <= 0);
110 
111  const char *const empty_argv[]{"\0"};
112  const char *const *safe_argv = special_case ? empty_argv : argv;
113  if (special_case) {
114  argc = 1;
115  }
116 
117  auto argv_size = static_cast<size_t>(argc);
118  // SetArgv* on python 3 takes wchar_t, so we have to convert.
119  std::unique_ptr<wchar_t *[]> widened_argv(new wchar_t *[argv_size]);
120  std::vector<std::unique_ptr<wchar_t[], detail::wide_char_arg_deleter>> widened_argv_entries;
121  widened_argv_entries.reserve(argv_size);
122  for (size_t ii = 0; ii < argv_size; ++ii) {
123  widened_argv_entries.emplace_back(detail::widen_chars(safe_argv[ii]));
124  if (!widened_argv_entries.back()) {
125  // A null here indicates a character-encoding failure or the python
126  // interpreter out of memory. Give up.
127  return;
128  }
129  widened_argv[ii] = widened_argv_entries.back().get();
130  }
131 
132  auto *pysys_argv = widened_argv.get();
133 
134  PySys_SetArgvEx(argc, pysys_argv, static_cast<int>(add_program_dir_to_path));
135 }
136 #endif
137 
139 
140 #if PY_VERSION_HEX >= PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
141 inline void initialize_interpreter(PyConfig *config,
142  int argc = 0,
143  const char *const *argv = nullptr,
144  bool add_program_dir_to_path = true) {
146  PyStatus status = PyConfig_SetBytesArgv(config, argc, const_cast<char *const *>(argv));
147  if (PyStatus_Exception(status) != 0) {
148  // A failure here indicates a character-encoding failure or the python
149  // interpreter out of memory. Give up.
150  PyConfig_Clear(config);
151  throw std::runtime_error(PyStatus_IsError(status) != 0 ? status.err_msg
152  : "Failed to prepare CPython");
153  }
154  status = Py_InitializeFromConfig(config);
155  if (PyStatus_Exception(status) != 0) {
156  PyConfig_Clear(config);
157  throw std::runtime_error(PyStatus_IsError(status) != 0 ? status.err_msg
158  : "Failed to init CPython");
159  }
160  if (add_program_dir_to_path) {
161  PyRun_SimpleString("import sys, os.path; "
162  "sys.path.insert(0, "
163  "os.path.abspath(os.path.dirname(sys.argv[0])) "
164  "if sys.argv and os.path.exists(sys.argv[0]) else '')");
165  }
166  PyConfig_Clear(config);
167 }
168 #endif
169 
189 inline void initialize_interpreter(bool init_signal_handlers = true,
190  int argc = 0,
191  const char *const *argv = nullptr,
192  bool add_program_dir_to_path = true) {
193 #if PY_VERSION_HEX < PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
195  init_signal_handlers, argc, argv, add_program_dir_to_path);
196 #else
197  PyConfig config;
198  PyConfig_InitPythonConfig(&config);
199  // See PR #4473 for background
200  config.parse_argv = 0;
201 
202  config.install_signal_handlers = init_signal_handlers ? 1 : 0;
203  initialize_interpreter(&config, argc, argv, add_program_dir_to_path);
204 #endif
205 }
206 
242 inline void finalize_interpreter() {
243  // Get the internals pointer (without creating it if it doesn't exist). It's possible for the
244  // internals to be created during Py_Finalize() (e.g. if a py::capsule calls `get_internals()`
245  // during destruction), so we get the pointer-pointer here and check it after Py_Finalize().
246  detail::internals **internals_ptr_ptr = detail::get_internals_pp();
247  // It could also be stashed in state_dict, so look there too:
248  if (object internals_obj
250  internals_ptr_ptr = detail::get_internals_pp_from_capsule(internals_obj);
251  }
252  // Local internals contains data managed by the current interpreter, so we must clear them to
253  // avoid undefined behaviors when initializing another interpreter
256 
257  Py_Finalize();
258 
259  if (internals_ptr_ptr) {
260  delete *internals_ptr_ptr;
261  *internals_ptr_ptr = nullptr;
262  }
263 }
264 
281 public:
282  explicit scoped_interpreter(bool init_signal_handlers = true,
283  int argc = 0,
284  const char *const *argv = nullptr,
285  bool add_program_dir_to_path = true) {
286  initialize_interpreter(init_signal_handlers, argc, argv, add_program_dir_to_path);
287  }
288 
289 #if PY_VERSION_HEX >= PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
290  explicit scoped_interpreter(PyConfig *config,
291  int argc = 0,
292  const char *const *argv = nullptr,
293  bool add_program_dir_to_path = true) {
294  initialize_interpreter(config, argc, argv, add_program_dir_to_path);
295  }
296 #endif
297 
298  scoped_interpreter(const scoped_interpreter &) = delete;
299  scoped_interpreter(scoped_interpreter &&other) noexcept { other.is_valid = false; }
302 
304  if (is_valid) {
306  }
307  }
308 
309 private:
310  bool is_valid = true;
311 };
312 
name
Annotation for function names.
Definition: attr.h:51
embedded_module
Python 2.7/3.x compatible version of PyImport_AppendInittab and error checks.
Definition: embed.h:63
embedded_module::init_t
PyObject *(*)() init_t
Definition: embed.h:64
finalize_interpreter
void finalize_interpreter()
Definition: embed.h:242
embedded_module::embedded_module
embedded_module(const char *name, init_t init)
Definition: embed.h:65
wide_char_arg_deleter
Definition: embed.h:77
local_internals::registered_exception_translators
std::forward_list< ExceptionTranslator > registered_exception_translators
Definition: internals.h:568
PYBIND11_NAMESPACE_END
#define PYBIND11_NAMESPACE_END(name)
Definition: wrap/pybind11/include/pybind11/detail/common.h:80
detail
Definition: testSerializationNonlinear.cpp:70
initialize_interpreter_pre_pyconfig
void initialize_interpreter_pre_pyconfig(bool init_signal_handlers, int argc, const char *const *argv, bool add_program_dir_to_path)
Definition: embed.h:100
get_internals_pp_from_capsule
internals ** get_internals_pp_from_capsule(handle obj)
Definition: internals.h:459
PYBIND11_NAMESPACE_BEGIN
#define PYBIND11_NAMESPACE_BEGIN(name)
Definition: wrap/pybind11/include/pybind11/detail/common.h:76
result
Values result
Definition: OdometryOptimize.cpp:8
scoped_interpreter::is_valid
bool is_valid
Definition: embed.h:310
scoped_interpreter::scoped_interpreter
scoped_interpreter(bool init_signal_handlers=true, int argc=0, const char *const *argv=nullptr, bool add_program_dir_to_path=true)
Definition: embed.h:282
local_internals::registered_types_cpp
type_map< type_info * > registered_types_cpp
Definition: internals.h:567
initialize_interpreter
void initialize_interpreter(bool init_signal_handlers=true, int argc=0, const char *const *argv=nullptr, bool add_program_dir_to_path=true)
Definition: embed.h:189
scoped_interpreter
Definition: embed.h:280
scoped_interpreter::~scoped_interpreter
~scoped_interpreter()
Definition: embed.h:303
eval.h
PYBIND11_NAMESPACE
Definition: test_custom_type_casters.cpp:24
widen_chars
wchar_t * widen_chars(const char *safe_arg)
Definition: embed.h:84
pybind11_fail
PyExc_RuntimeError PYBIND11_NOINLINE void pybind11_fail(const char *reason)
Used internally.
Definition: wrap/pybind11/include/pybind11/detail/common.h:1026
pybind11.h
get_python_state_dict
object get_python_state_dict()
Definition: internals.h:433
get_internals_obj_from_state_dict
object get_internals_obj_from_state_dict(handle state_dict)
Definition: internals.h:454
get_local_internals
local_internals & get_local_internals()
Works like get_internals, but for things which are locally registered.
Definition: internals.h:606
get_internals_pp
internals **& get_internals_pp()
Definition: internals.h:321
precheck_interpreter
void precheck_interpreter()
Definition: embed.h:89
wide_char_arg_deleter::operator()
void operator()(wchar_t *ptr) const
Definition: embed.h:78
init
Definition: TutorialInplaceLU.cpp:2
scoped_interpreter::scoped_interpreter
scoped_interpreter(scoped_interpreter &&other) noexcept
Definition: embed.h:299
scoped_interpreter::operator=
scoped_interpreter & operator=(const scoped_interpreter &)=delete
pybind_wrapper_test_script.other
other
Definition: pybind_wrapper_test_script.py:42


gtsam
Author(s):
autogenerated on Fri Nov 1 2024 03:32:29