PyAthenaUtils.cxx File Reference

#include "Python.h"
#include "AthenaPython/PyAthenaUtils.h"
#include "RootUtils/PyAthenaGILStateEnsure.h"
#include "RootUtils/PyGetString.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/StatusCode.h"
#include "TPython.h"
#include "DataModelRoot/RootType.h"
#include "TClassRef.h"
#include <string>
#include <iostream>
#include <sstream>
#include <stdexcept>

Go to the source code of this file.

Functions
StatusCode PyAthena::callPyMethod	ATLAS_NOT_THREAD_SAFE (PyObject *self, const char *methodName, PyObject *arg)
StatusCode PyAthena::queryInterface	ATLAS_NOT_THREAD_SAFE (PyObject *self, const InterfaceID &riid, void **ppvInterface)
void PyAthena::pyAudit	ATLAS_NOT_THREAD_SAFE (PyObject *self, const char *method, const char *evt, const char *component)
	helper function for PyAthena::Aud
void PyAthena::pyAudit	ATLAS_NOT_THREAD_SAFE (PyObject *self, const char *method, const char *evt, const char *component, const StatusCode &sc)
	helper function for PyAthena::Aud

Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/4]

void PyAthena::pyAudit ATLAS_NOT_THREAD_SAFE	(	PyObject *	self,
		const char *	method,
		const char *	evt,
		const char *	component )

helper function for PyAthena::Aud

Definition at line 355 of file PyAthenaUtils.cxx.

{
  RootUtils::PyGILStateEnsure ensure;
  PyObject* call = PyObject_CallMethod(self,
                       (char*)method,
                       (char*)"ss", evt, component);
  if ( !call ) {
    Py_XDECREF(call);
    throw_py_exception();
  }
  Py_DECREF(call);
  return;
}

ATLAS_NOT_THREAD_SAFE() [2/4]

void PyAthena::pyAudit ATLAS_NOT_THREAD_SAFE	(	PyObject *	self,
		const char *	method,
		const char *	evt,
		const char *	component,
		const StatusCode &	sc )

helper function for PyAthena::Aud

Definition at line 374 of file PyAthenaUtils.cxx.

{
  RootUtils::PyGILStateEnsure ensure;
  PyObject* pySc = TPython::CPPInstance_FromVoidPtr((void*)&sc,
                            "StatusCode");
  if ( !pySc ) {
#ifdef ATLAS_HAVE_CPYCPPYY
    throw CPyCppyy::PyException();
#else
    throw std::runtime_error ("Python exception");
#endif  // ATLAS_HAVE_CPYCPPYY
  }
 
  PyObject* call = PyObject_CallMethod(self,
                       (char*)method,
                       (char*)"ssO", evt, component, pySc);
  Py_DECREF(pySc);
 
  if ( !call ) {
    Py_XDECREF(call);
    throw_py_exception();
  }
  Py_DECREF(call);
  return;
}

ATLAS_NOT_THREAD_SAFE() [3/4]

StatusCode PyAthena::callPyMethod ATLAS_NOT_THREAD_SAFE	(	PyObject *	self,
		const char *	methodName,
		PyObject *	arg )

Definition at line 171 of file PyAthenaUtils.cxx.

{
  // that's a bit ugly...
  char* method = const_cast<char*>(methodName);
 
  // check arguments
  if ( 0 == self || 0 == method ) { return StatusCode::FAILURE; }
 
  // call Python
  RootUtils::PyGILStateEnsure ensure;
  PyObject* r;
  if (arg)
    r = PyObject_CallMethod( self, method, const_cast<char*>("O"), arg );
  else
    r = PyObject_CallMethod( self, method, const_cast<char*>("") );
 
  if ( 0 == r ) {
    throw_py_exception();
  }
 
  if ( PyLong_Check( r ) ) {
    StatusCode sc(PyLong_AS_LONG( r ));
    Py_DECREF( r );
    return sc;
  }
 
  // look for the method getCode with the signature:
  //  ' int getCode() '
  PyObject* c = 0;
  if ( PyObject_HasAttrString (r, (char*)"getCode") ) {
    c = PyObject_CallMethod( r,
                 const_cast<char*>("getCode"),
                 const_cast<char*>("") );
    Py_DECREF (r);
  }
 
  else {
    std::ostringstream msg;
    msg << "unexpected returned type from (python) function '"
    << method << "()' [got "
    << PyAthena::repr ((PyObject*)r->ob_type)
    << "]";
    PyErr_SetString (PyExc_TypeError, msg.str().c_str());
    Py_XDECREF (c);
    throw_py_exception();
  }
 
  if ( !c ) {
    // error on python side...
    throw_py_exception();
  }
 
  if ( PyLong_Check (c) ) {
    StatusCode sc(PyLong_AsLong (c));
    Py_DECREF (c);
    return sc;
  }
 
  else {
    std::ostringstream msg;
    msg << "unexpected returned type from (python) function '"
    << method << "().getCode()' [got "
    << PyAthena::repr ((PyObject*)c->ob_type)
    << "]";
    PyErr_SetString (PyExc_TypeError, msg.str().c_str());
    Py_DECREF (c);
    throw_py_exception();
  }
  return StatusCode::FAILURE;
}

ATLAS_NOT_THREAD_SAFE() [4/4]

StatusCode PyAthena::queryInterface ATLAS_NOT_THREAD_SAFE	(	PyObject *	self,
		const InterfaceID &	riid,
		void **	ppvInterface )

Definition at line 244 of file PyAthenaUtils.cxx.

{
  StatusCode sc = StatusCode::FAILURE;
 
  {
    std::cout
      << "==============[ " << PyAthena::repr(self) << " ]=============="
      << std::endl;
  }
 
  RootUtils::PyGILStateEnsure ensure;
  PyObject* type = PyObject_GetAttrString( self,
                       const_cast<char*>("__class__") );
  if ( !type ) {
    Py_XDECREF(type);
    return sc;
  }
 
  PyObject* bases;
  bases = PyObject_CallMethod( type,
                   const_cast<char*>("mro"),
                   const_cast<char*>("") );
  if ( !bases || !PySequence_Check( bases ) ) {
    Py_XDECREF(type);
    Py_XDECREF(bases);
    return sc;
  }
 
  const int nBases = PySequence_Size( bases );
  if ( -1 == nBases ) {
    Py_XDECREF(type);
    Py_XDECREF(bases);
    return sc;
  }
 
  for ( int i = 0; i < nBases; ++i ) {
    PyObject* base = PySequence_GetItem( bases, i );
    if ( !base ) {
      Py_XDECREF( base );
      continue;
    }
    unsigned long id = 0;
    unsigned long major = 0;
    unsigned long minor = 0;
    if ( !fetchInterfaceId( base, id, major, minor ).isSuccess() ) {
      Py_DECREF( base );
      continue;
    }
 
    InterfaceID pyID( id, major, minor );
    if ( !pyID.versionMatch( riid ) ) {
      Py_DECREF( base );
      continue;
    }
 
    PyObject* pyname = 0;
    pyname = PyObject_GetAttrString( base,
                     const_cast<char*>("__name__") );
    auto [cppBaseName, flag] = RootUtils::PyGetString (pyname);
    Py_DECREF(pyname);
    if ( !flag ) {
      Py_DECREF ( base   );
      continue;
    }
 
    const std::string cppName = reinterpret_cast<MyObjProxy*>(self)->m_class->GetName();
 
    std::cout << "::: would like to do: *ppvInterface = static_cast<"
          << cppBaseName << "*>( "
          << cppName << "|m_self );"
          << std::endl;
 
    const RootType fromType( cppName );
    const RootType toType( cppBaseName );
    void* objProxy = TPython::CPPInstance_AsVoidPtr(self);
    *ppvInterface = objProxy;
    if (fromType.Class() && toType.Class())
      *ppvInterface = fromType.Class()->DynamicCast (toType.Class(), objProxy);
    std::cout << "::: [" << cppName << "]: "
          << ( (bool)fromType ? " OK" : "ERR" )
          << " " << objProxy
          << "\n"
          << "::: [" << cppBaseName << "]: "
          << ( (bool)toType ? " OK" : "ERR" )
          << " " << *ppvInterface
          << "\n";
    std::cout << "::: *ppvInterface: " << *ppvInterface << std::endl;
    if ( *ppvInterface ) {
      PyObject* c = PyObject_CallMethod( self,
                     const_cast<char*>("addRef"),
                     const_cast<char*>("") );
      if ( c && PyLong_Check(c) ) {
    sc = StatusCode::SUCCESS;
      }
      Py_DECREF(c);
    }
    Py_DECREF( base );
    if ( sc.isSuccess() ) {
      break;
    }
  }
 
  Py_DECREF(type);
  Py_DECREF(bases);
  return sc;
}