PyAthenaAud.cxx

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// PyAthenaAud.cxx 
// Implementation file for class PyAthena::Aud
// Author: S.Binet<binet@cern.ch>
// Modified: Wim Lavrijsen <WLavrijsen@lbl.gov>
 
// Python includes
#include "Python.h"
 
// PyROOT includes
#include "TPython.h"
 
// AthenaPython includes
#include "AthenaPython/PyAthenaUtils.h"
#include "AthenaPython/PyAthenaAud.h"
#include "RootUtils/PyAthenaGILStateEnsure.h"
 
// STL includes
#include <algorithm>
 
// FrameWork includes
#include "GaudiKernel/System.h"
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/ServiceHandle.h"
#include "AthenaPython/IPyComponentMgr.h"
 
namespace PyAthena {
 
// Public methods: 
 
// Constructors
 
Aud::Aud( const std::string& name, ISvcLocator* svcLocator ) :
  Gaudi::Auditor( name, svcLocator ),
  m_self   ( nullptr )
{}
 
// Destructor
Aud::~Aud()
{ 
  if ( m_self ) {
    RootUtils::PyGILStateEnsure ensure;
    Py_DECREF( m_self );
    m_self = nullptr;
  }
}
 
// Athena Auditor's Hooks
StatusCode 
Aud::initialize()
{
  return PyAthena::callPyMethod( m_self, "sysInitialize" );
}
 
StatusCode
Aud::sysInitialize()
{
  ServiceHandle<IPyComponentMgr> pyMgr
    ( "PyAthena::PyComponentMgr/PyComponentMgr", name() );
  if ( !pyMgr.retrieve().isSuccess() ) {
    return StatusCode::FAILURE;
  }
 
  // first retrieve our python object cousin...
  m_self = pyMgr->pyObject( this );
 
  if ( m_self == Py_None ) {
    return StatusCode::FAILURE;
  }
 
  // re-route to usual sysInit...
  return Gaudi::Auditor::sysInitialize();
}
 
StatusCode 
Aud::finalize()
{
  return PyAthena::callPyMethod( m_self, "sysFinalize" );
}
 
// Const methods: 
 
const char*
Aud::typeName() const
{ 
  static const std::string tname = System::typeinfoName(typeid(*this));
  return tname.c_str();
}
 
// Non-const methods: 
 
void
Aud::before(const std::string& evt, const std::string& name,
            const EventContext&)
{
  std::string evtname = evt;
  std::transform(evt.begin(), evt.end(), evtname.begin(), ::tolower);
  PyAthena::pyAudit (m_self, "before", evtname.c_str(), name.c_str());
}
 
void
Aud::after(const std::string& evt, const std::string& name,
           const EventContext&, const StatusCode& sc)
{
  std::string evtname = evt;
  std::transform(evt.begin(), evt.end(), evtname.begin(), ::tolower);
  PyAthena::pyAudit (m_self, "after", evtname.c_str(), name.c_str(), sc);
}
 
// Non-const methods: 
 
bool
Aud::setPyAttr( PyObject* o )
{
  // now we tell the PyObject which C++ object it is the cousin of.
  RootUtils::PyGILStateEnsure ensure;
  PyObject* pyobj = TPython::CPPInstance_FromVoidPtr
    ( (void*)this, this->typeName() );
  if ( !pyobj ) {
    PyErr_Clear();
    // try PyAthena::Aud
    pyobj = TPython::CPPInstance_FromVoidPtr ((void*)this, "PyAthena::Aud");
    MsgStream msg( msgSvc(), name() );
    msg << MSG::INFO
        << "could not dyncast component [" << name() << "] to a python "
        << "object of type [" << this->typeName() << "] (probably a missing "
        << "dictionary)" << endmsg
        << "fallback to [PyAthena::Aud]..."
        << endmsg;
  }
  if ( !pyobj ) {
    PyErr_Clear();
    MsgStream msg( msgSvc(), name() );
    msg << MSG::WARNING << "Could not dyncast component ["
        << name() << "] to a pyobject of type [" 
        << this->typeName() << "]"
        << endmsg;
  } else {
    if ( -1 == PyObject_SetAttrString(o, "_cppHandle", pyobj) ) {
      PyErr_Clear();
      MsgStream msg( msgSvc(), name() );
      msg << MSG::WARNING 
          << "Could not attach C++ handle [" << name() << "] to its python "
          << "cousin !"
          << endmsg;
      if ( -1 == PyObject_SetAttrString(o, "_cppHandle", Py_None) ) {
        PyErr_Clear();
        msg << MSG::WARNING
            << "could not attach a dummy C++ handle [" << name() << "] to its "
            << "python cousin !"
            << endmsg;
      }
    } else {
      return true;
    }
  }
  return false;
}
 
} //> end namespace PyAthena