AthenaInternal Namespace Reference

Classes
struct	AthenaInternalInstan
class	ROOT6_AthenaPython_WorkAround_Dummy
class	ROOT6_StoreGateBindings_WorkAround_Dummy

Functions
CLID	getClid (IClassIDSvc *self, const std::string &typeName)
StatusCode	initPyInterpreter ()
	correctly initialize the python interpreter in case it hasn't been done yet.
PyObject *	recordObjectToStore (StoreGateSvc *store, PyObject *obj, PyObject *pykey, bool allowMods=true, bool resetOnly=true, bool noHist=false)
	record object to storegate
void	py_sg_clearProxyPayload (StoreGateSvc *self, SG::DataProxy *)
PyObject *	retrieveObjectFromStore (PyObject *storeGateSvc, PyObject *tp, PyObject *key)
PyObject *	recordObjectToStore (PyObject *storeGateSvc, PyObject *obj, PyObject *key, bool allowMods=true, bool resetOnly=true, bool noHist=false)
PyObject *	py_sg_contains (PyObject *storeGateSvc, PyObject *tp, PyObject *key)
PyObject *	py_sg_getitem (PyObject *storeGateSvc, PyObject *key)
PyObject *	retrieveObjectFromStore (StoreGateSvc *store, PyObject *tp, PyObject *pykey)
	retrieve object of specified type from storegate
PyObject *	py_sg_getitem (StoreGateSvc *self, PyObject *pykey)
	typeless retrieve ... slower than above, and potential to return unexpected type if objects of different type but same key
PyObject *	py_sg_contains (StoreGateSvc *store, PyObject *tp, PyObject *pykey)
	check if object of specified type is in storegate

Function Documentation

getClid()

CLID AthenaInternal::getClid	(	IClassIDSvc *	self,
		const std::string &	typeName )

Definition at line 35 of file AthenaPythonDict.h.

                                                               {
    CLID clid = CLID_NULL;
    self->getIDOfTypeName(typeName, clid).ignore();
    return clid;
  }

initPyInterpreter()

StatusCode AthenaInternal::initPyInterpreter

(

)

correctly initialize the python interpreter in case it hasn't been done yet.

Definition at line 60 of file initPyInterpreter.cxx.

{
  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;
}

py_sg_clearProxyPayload()

void AthenaInternal::py_sg_clearProxyPayload	(	StoreGateSvc *	self,
		SG::DataProxy *	dp )

Definition at line 458 of file StoreGatePyExt.cxx.

{
  return self->clearProxyPayload(dp);
}

py_sg_contains() [1/2]

PyObject * AthenaInternal::py_sg_contains	(	PyObject *	storeGateSvc,
		PyObject *	tp,
		PyObject *	key )

Definition at line 346 of file StoreGatePyExt.cxx.

{
  StoreGateSvc* store = (StoreGateSvc*)CPPInstance_ASVOIDPTR(self);
  return py_sg_contains(store,tp,pykey);
}

py_sg_contains() [2/2]

PyObject * AthenaInternal::py_sg_contains	(	StoreGateSvc *	store,
		PyObject *	tp,
		PyObject *	pykey )

check if object of specified type is in storegate

Definition at line 354 of file StoreGatePyExt.cxx.

{
  static SG::PyProxyMgr& s_mgr = SG::PyProxyMgr::instance();
 
  
 
  // unlikely to happen, but checking is cheap
  if ( ! store ) {
    PyErr_SetString( PyExc_RuntimeError, 
                     "no store available, is Athena initialized?" );
    return 0;
  }
 
  // expect a type or type name and an optional string key
  PyObject* pyname = pynameFromType( tp );
  if (!pyname) {
    return pyname;
  }
 
  auto [namestr, nameflag] = RootUtils::PyGetString (pyname);
  auto [keystr,  keyflag]  = RootUtils::PyGetString (pykey);
 
  if ( !keyflag ) {
    PyErr_SetString( PyExc_TypeError, 
                     "contains() argument 2 must be string key" );
    Py_XDECREF (pyname);
    return 0;
  }
 
  // retrieve CLID corresponding to the request
  const CLID clid = s_mgr.clid (pyname);
  if ( clid == CLID_NULL ) {
    PyErr_Format( PyExc_NameError, 
                  "ID of \"%s\" is unknown", namestr.c_str() );
    return 0;
  }
 
  Py_XDECREF (pyname);
  pyname = 0;
 
  const bool sg_contains = 
    store->contains (clid, keystr) ;
 
  _SGPY_MSG("sg::contains(" << clid
            << "/" << namestr.c_str() << ", "
            << keystr.c_str()
            << ") = [" 
            << (sg_contains ? std::string("true") : std::string("false"))
            << "]");
 
  PyObject* o = sg_contains
    ? Py_True
    : Py_False;
  Py_INCREF (o);
  return o;
}

py_sg_getitem() [1/2]

PyObject * AthenaInternal::py_sg_getitem	(	PyObject *	storeGateSvc,
		PyObject *	key )

Definition at line 414 of file StoreGatePyExt.cxx.

{
  StoreGateSvc* store = (StoreGateSvc*)CPPInstance_ASVOIDPTR(self);
  return py_sg_getitem(store,pykey);
}

py_sg_getitem() [2/2]

PyObject * AthenaInternal::py_sg_getitem	(	StoreGateSvc *	self,
		PyObject *	pykey )

typeless retrieve ... slower than above, and potential to return unexpected type if objects of different type but same key

Definition at line 422 of file StoreGatePyExt.cxx.

{
  static SG::PyProxyMgr& s_mgr = SG::PyProxyMgr::instance();
 
  
 
  // unlikely to happen, but checking is cheap
  if ( ! store ) {
    PyErr_SetString( PyExc_RuntimeError, 
                     "no store available, is Athena initialized?" );
    return 0;
  }
 
  auto [keystr, keyflag] = RootUtils::PyGetString (pykey);
  if ( ! keyflag ) {
    PyErr_SetString( PyExc_TypeError, 
                     "__getitem__() argument 1 must be string key" );
    return 0;
  }
 
  // Retrieve the main @c CLID of the object recorded in @c StoreGate
  const CLID clid = store->clid (keystr);
  if ( CLID_NULL == clid ) {
    PyErr_Format (PyExc_LookupError, 
                  "no clid for key=%s", 
                  keystr.c_str());
    return 0;
  }
  
  return AthenaInternal::retrieveObjectFromStore (store, 
                                                  s_mgr.pytp(clid), 
                                                  pykey);
}

recordObjectToStore() [1/2]

PyObject * AthenaInternal::recordObjectToStore	(	PyObject *	storeGateSvc,
		PyObject *	obj,
		PyObject *	key,
		bool	allowMods = true,
		bool	resetOnly = true,
		bool	noHist = false )

Definition at line 464 of file StoreGatePyExt.cxx.

{
  StoreGateSvc* store = (StoreGateSvc*)CPPInstance_ASVOIDPTR(self);
  return recordObjectToStore(store,obj,pykey,allowMods,resetOnly,noHist);
}

recordObjectToStore() [2/2]

PyObject * AthenaInternal::recordObjectToStore	(	StoreGateSvc *	,
		PyObject *	,
		PyObject *	,
		bool	,
		bool	,
		bool	)

record object to storegate

Definition at line 476 of file StoreGatePyExt.cxx.

{
  static SG::PyProxyMgr& s_mgr = SG::PyProxyMgr::instance();
 
  
 
  // unlikely to happen, but checking is cheap
  if ( ! store ) {
    PyErr_SetString( PyExc_RuntimeError, 
                     "no store available, is Athena initialized?" );
    return 0;
  }
 
  // expect a type or type name
  PyObject* tp = PyObject_GetAttrString( obj, (char*)"__class__" );
  if ( ! PyType_Check( tp ) ) {
    PyErr_SetString( PyExc_RuntimeError, 
                     "could not retrieve type of object" );
    return 0;
  }
 
  PyObject* pyname = 0;
  // check if this is a PyRoot object or a 'regular' PyObject
  const bool isPlainPyObj = !TPython::CPPInstance_Check (obj);
  if ( isPlainPyObj ) {
    pyname = PyUnicode_FromString ((char*)"PyObject");
  } else {
    pyname = pynameFromType( tp );
  }
 
  if ( PyErr_Occurred() )
    return 0;
 
  auto [keystr, keyflag] = RootUtils::PyGetString (pykey);
  auto [namestr, nameflag] = RootUtils::PyGetString (pyname);
 
  if ( ! keyflag ) {
    PyErr_SetString( PyExc_TypeError, 
                     "record() argument 2 must be string key" );
    Py_XDECREF (pyname);
    return 0;
  }
  
  // retrieve CLID corresponding to the request
  const CLID id = s_mgr.clid(pyname);
  if ( CLID_NULL == id ) {
    PyErr_Format( PyExc_NameError, 
                  "ID of \"%s\" is unknown", namestr.c_str() );
    return 0;
  }
 
  Py_XDECREF (pyname);
  pyname = 0;
 
  // make sure everything has been loaded for that clid...
  s_mgr.load_type(id);
 
  _SGPY_MSG("ID=" << id
            << ", tp=" << namestr.c_str()
            << ", key=" << keystr.c_str());
 
  SG::PyDataBucket* dbb = new SG::PyDataBucket (obj, id);
 
  _SGPY_MSG("created a pdb @" << dbb << ", clID=" << dbb->clID()
            << ", pdb-obj @" << dbb->object()
            << ", obj @" << (void*)obj
            << ", cc: " << CPPInstance_ASVOIDPTR(obj)
            << ", isplain-pyobj: [" << (int)isPlainPyObj << "]"
            << ", pyrobj @" << CPPInstance_ASVOIDPTR(obj));
  _SGPY_MSG("pdb-cast(" << dbb->clID() << "): " << dbb->cast(dbb->clID()));
        
  int sc = store->typeless_record( dbb, keystr,
                                   isPlainPyObj 
                                   ? (void*)obj
                                   : CPPInstance_ASVOIDPTR(obj),
                                   allowMods,
                                   resetOnly,
                                   noHist ).isSuccess()
    ? 1
    : 0; 
  return Py_BuildValue( const_cast<char*>("i"), sc );
}

retrieveObjectFromStore() [1/2]

PyObject * AthenaInternal::retrieveObjectFromStore	(	PyObject *	storeGateSvc,
		PyObject *	tp,
		PyObject *	key )

Definition at line 101 of file StoreGatePyExt.cxx.

{
  StoreGateSvc* store = (StoreGateSvc*)CPPInstance_ASVOIDPTR(self);
  return retrieveObjectFromStore(store,tp,pykey);
}

retrieveObjectFromStore() [2/2]

PyObject * AthenaInternal::retrieveObjectFromStore	(	StoreGateSvc *	store,
		PyObject *	tp,
		PyObject *	pykey )

retrieve object of specified type from storegate

Definition at line 109 of file StoreGatePyExt.cxx.

{
  void* res = 0;
  PyObject* objProxy = NULL;
 
  static SG::PyProxyMgr& s_mgr = SG::PyProxyMgr::instance();
 
 
  // unlikely to happen, but checking is cheap
  if ( ! store ) {
    PyErr_SetString( PyExc_RuntimeError, 
                     "no store available, is Athena initialized?" );
    return 0;
  }
 
  // expect a type or type name and an optional string key
  PyObject* pyname = pynameFromType( tp );
  if (!pyname) {
    return pyname;
  }
 
  auto [namestr, nameflag] = RootUtils::PyGetString( pyname );
  auto [keystr, keyflag] = RootUtils::PyGetString( pykey );
  if ( !keyflag ) {
    if (pykey == Py_None) {
      keystr = "<None>";
    }
    else {
      PyErr_SetString( PyExc_TypeError, 
                       "retrieve() argument 2 must be string key" );
      Py_XDECREF (pyname);
      return 0;
    }
  }
 
  SG::PyProxyDict* proxyDict = s_mgr.pyproxy(store);
  // retrieve CLID corresponding to the request
  PyObject* pyclid = s_mgr.pyclid(pyname);
  if ( ! pyclid ) {
    PyErr_Format( PyExc_NameError, 
                  "ID of \"%s\" is unknown", namestr.c_str() );
    Py_XDECREF (pyname);
    return 0;
  }
 
  Py_XDECREF (pyname);
  pyname = 0;
 
  _SGPY_MSG("retrieving py-proxy...");
  PyObject* pyproxy = proxyDict->proxy(pyclid, pykey);
  if ( ! pyproxy ) {
    PyErr_Format( PyExc_LookupError, 
                  "no py-proxies for (clid=%lu, type=%s, key=%s)", 
                  PyLong_AsUnsignedLong(pyclid),
                  namestr.c_str(),
                  (pykey == Py_None) ? "<None>" : keystr.c_str()
                  );
    return 0;
  }
 
  _SGPY_MSG("retrieved py-proxy [clid=" << PyLong_AsUnsignedLong(pyclid)
            << ", type=" << namestr.c_str()
            << ", key=" << (pykey == Py_None) ? "<None>" : keystr.c_str()
            << "]");
 
  SG::DataProxy* proxy = (SG::DataProxy*)CPPInstance_ASVOIDPTR(pyproxy);
 
  if ( ! proxy ) {
    PyErr_Format( PyExc_LookupError, 
                  "no proxies for (clid=%lu, type=%s, key=%s)", 
                  PyLong_AsUnsignedLong(pyclid),
                  namestr.c_str(),
                  (pykey == Py_None) ? "<None>" : keystr.c_str()
                  );
    return 0;
  }
 
  _SGPY_MSG("retrieved cpp-proxy [clid=" << proxy->clID()
            << ", key=" << proxy->name() << "]");
 
  // cast proxy to pointer type if needed (setting on return type is evil hack)
  DataObject* dobj = proxy->accessData();
  if ( ! dobj ) {
    PyErr_Format( PyExc_LookupError, 
                  "no such object \"%s\"", namestr.c_str() );
    return 0;
  }
 
  _SGPY_MSG("retrieved dobj [clID=" << dobj->clID()
            << ", classID=" << dobj->classID()
            << ", name=" << dobj->name() << "]");
 
  DataBucketBase* dbb = dynamic_cast< DataBucketBase* >( dobj );
  if ( ! dbb ) {
    PyErr_SetString
      ( PyExc_TypeError,
        "unexpected kind of DataObject: can not verify final type" );
    return 0;
  }
 
  _SGPY_MSG("retrieved dbb [clID=" << dbb->clID()
            << ", classID=" << dbb->classID()
            << ", name=" << dbb->name() << "]");
 
  CLID id     = proxy->clID();
  CLID realID = dbb->clID();
 
  _SGPY_MSG("pyid= " << PyLong_AsUnsignedLong(pyclid)
            << ", id=" << id
            << ", realID=" << realID);
 
  // special case of a regular PyObject
  if ( PyCLID == realID ) {
    objProxy = (PyObject*)dbb->object();
 
  } else if (realID == bool_clid) {
    res = dbb->cast( bool_clid );
    bool *v = reinterpret_cast<bool*>(res);
    objProxy = PyBool_FromLong(*v);
    return objProxy;
 
  } else if (realID == char_clid) {
    res = dbb->cast( char_clid );
    char *v = reinterpret_cast<char*>(res);
    objProxy = PyUnicode_FromStringAndSize(v, 1);
    return objProxy;
 
  } else if (realID == int_clid) {
    res = dbb->cast( int_clid );
    int *v = reinterpret_cast<int*>(res);
    objProxy = PyLong_FromLong(*v);
    return objProxy;
 
  } else if (realID == uint_clid) {
    res = dbb->cast( uint_clid );
    unsigned int *v = reinterpret_cast<unsigned int*>(res);
    objProxy = PyLong_FromLong(*v);
    return objProxy;
 
  } else if (realID == long_clid) {
    res = dbb->cast( long_clid );
    long *v =reinterpret_cast<long*>(res);
    objProxy = PyLong_FromLong(*v);
    return objProxy;
 
  } else if (realID == ulong_clid) {
    res = dbb->cast( ulong_clid );
    unsigned long *v =reinterpret_cast<unsigned long*>(res);
    objProxy = PyLong_FromUnsignedLong(*v);
    return objProxy;
    
  } else if (realID == longlong_clid) {
    res = dbb->cast( longlong_clid );
    long long *v =reinterpret_cast<long long*>(res);
    objProxy = PyLong_FromUnsignedLong(*v);
    return objProxy;
    
  } else if (realID == float_clid) {
    res = dbb->cast( float_clid );
    float *v =reinterpret_cast<float*>(res);
    objProxy = PyFloat_FromDouble(*v);
    return objProxy;
  
  } else if (realID == double_clid) {
    res = dbb->cast( double_clid );
    double *v =reinterpret_cast<double*>(res);
    objProxy = PyFloat_FromDouble(*v);
    return objProxy;
  
  } else if ( id == realID ) {
    res = dbb->object();
    
    _SGPY_MSG("pyid= " << PyLong_AsUnsignedLong(pyclid)
              << ", id=" << id
              << ", realID=" << realID << " => res = [" << res << "]");
 
    if ( ! res ) {
      PyErr_Format( PyExc_RuntimeError, "found an invalid object" );
      return 0;
    }
    
    const char* klass_name = s_mgr.load_type(id);
    _SGPY_MSG("retrieving objProxy(" << klass_name
              << ", " << res << ")...");
    objProxy = proxyDict->newPyDataObject(klass_name, res);
    _SGPY_MSG("retrieving objProxy(" << klass_name
              << ", " << res << ")... [done]");
 
  } else {
    // either use CLID BaseInfo<> or Reflex, try both as appropriate
    res = dbb->cast( id );
 
    // ensure everything is loaded for that clid
    const char* real_typename = s_mgr.load_type(realID);
    
    _SGPY_MSG("dbb::cast(" << id << ") = " << res);
 
    if ( res ) {
 
      objProxy= proxyDict->newPyDataObject(real_typename, res);
    } else {
      // -> try Reflex...
      IClassIDSvc* clidSvc = s_mgr.m_clidSvc;
      std::string realName = "";
      if ( !clidSvc->getTypeNameOfID(realID, realName).isSuccess() ) {
        PyErr_Format( PyExc_TypeError, "actual type of CLID %lu unknown",
                      (long unsigned int)realID );
        return 0;
      }
      
      const RootType& fromType = RootType::ByNameNoQuiet(realName);
      
      if ( (bool)fromType ) {
        const RootType& toType = RootType::ByNameNoQuiet( namestr );
        res = dbb->object();
        if (fromType.Class() && toType.Class())
          res = fromType.Class()->DynamicCast (toType.Class(), res);
    
        if ( res ) {
          objProxy = proxyDict->newPyDataObject(realName.c_str(), res);
        }
      }
    }
 
    if ( ! res ) {
      PyErr_SetString( PyExc_TypeError, "cast to requested type failed" );
      return 0;
    }
 
  }
 
  Py_INCREF(objProxy);
  return objProxy;
}