initPyInterpreter.cxx

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
// initPyInterpreter.cxx 
// state of the art initialization of the python interpreter
// Author: S.Binet<binet@cern.ch>
 
// Python
#include "Python.h"
// fixes 'dereferencing type-punned pointer will break strict-aliasing rules'
#ifdef Py_True
#undef Py_True
#define Py_True ( (PyObject*)(void*)&_Py_TrueStruct )
#endif
#ifdef Py_False
#undef Py_False
#define Py_False ( (PyObject*)(void*)&_Py_ZeroStruct )
#endif
 
#include "CxxUtils/checker_macros.h"
 
// gaudi
#include "GaudiKernel/System.h"
#include "GaudiKernel/StatusCode.h"
 
#include <locale>
#include <codecvt>
 
namespace {
  void report_py_exception (bool display = true)
  {
    if (display) {
      // fetch error
      PyObject* pytype = nullptr, *pyvalue = nullptr, *pytrace = nullptr;
      PyErr_Fetch (&pytype, &pyvalue, &pytrace);
      Py_XINCREF  (pytype);
      Py_XINCREF  (pyvalue);
      Py_XINCREF  (pytrace);
      // restore...
      PyErr_Restore (pytype, pyvalue, pytrace);
      // and print
      PyErr_Print();
    }
  }
}
 
namespace AthenaInternal {
StatusCode initPyInterpreter();
 
StatusCode 
initPyInterpreter()
{
  if (Py_IsInitialized()) {
    return StatusCode::SUCCESS;
  }
 
  /*
   * The GIL is initialized by Py_Initialize() since Python 3.7."
   */
 
#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 11
  Py_Initialize();
 
  if (!Py_IsInitialized()) {
    ::report_py_exception();
    return StatusCode::FAILURE;
  }
 
  // init the sys.argv...
  auto wargsinit = 
    []() { std::vector<std::wstring> wargs;
           int argc = System::argc();
           char** argv = System::argv();
           wargs.reserve (argc);
           using convert_t = std::codecvt_utf8<wchar_t>;
           std::wstring_convert<convert_t, wchar_t> strconverter;
           for (int i=0; i < argc; ++i) {
             wargs.push_back (strconverter.from_bytes (argv[i]));
           }
           return wargs;
  };
  static const std::vector<std::wstring> wargs = wargsinit();
 
  auto wargvinit =
    [](const std::vector<std::wstring>& wargs)
      { std::vector<const wchar_t*> wargv;
        int argc = System::argc();
        for (int i=0; i < argc; ++i) {
          wargv.push_back (wargs[i].data());
        }
        return wargv;
  };
  static const std::vector<const wchar_t*> wargv = wargvinit (wargs);
 
  // Bleh --- python takes non-const argv pointers.
  wchar_t** wargv_nc ATLAS_THREAD_SAFE = const_cast<wchar_t**> (wargv.data());
  PySys_SetArgv(System::argc(), wargv_nc);
#else
  PyConfig config;
  PyConfig_InitPythonConfig (&config);
  PyStatus status = PyConfig_SetBytesArgv (&config, System::argc(),
                                           System::argv());
  if (PyStatus_Exception (status)) {
    report_py_exception();
    PyConfig_Clear (&config);
    return StatusCode::FAILURE;
  }
 
  status = Py_InitializeFromConfig (&config);
  if (PyStatus_Exception (status)) {
    report_py_exception();
    PyConfig_Clear (&config);
    return StatusCode::FAILURE;
  }
  PyConfig_Clear (&config);
#endif
  return StatusCode::SUCCESS;
}
 
} //> !AthenaInternal