a handle to a python tool for use via nanobind More...

#include <PythonToolHandle.h>

Inheritance diagram for columnar::PythonToolHandle:

Collaboration diagram for columnar::PythonToolHandle:

Public Member Functions
	PythonToolHandle ()
	standard constructor
void	setTypeAndName (const std::string &typeAndName)
	set the type and name for the tool
template<typename T>
void	setProperty (const std::string &key, T &&value)
	set a property on the tool
const asg::AsgToolConfig &	getConfig () const
	get the AsgToolConfig
void	preinitialize ()
	preinitialize the tool
void	renameContainers (const std::vector< std::pair< std::string, std::string > > &renames)
	rename the columns the tool uses
void	initialize ()
	initialize the tool
void	applySystematicVariation (const std::string &sysName)
	set the tool to apply the given systematic variation
template<typename CT>
void	setColumn (const std::string &key, std::size_t size, CT *dataPtr)
	set a column pointer (raw pointer version)
void	setColumnVoid (const std::string &name, std::size_t size, const void *dataPtr, const std::type_info &type, bool isConst)
	set a column pointer
std::tuple< std::size_t, const void , const std::type_info >	getColumnVoid (const std::string &name) const
	get a column pointer by name; returns {size, ptr, type_info}
void	call ()
	call the tool and reset the columns
std::vector< ColumnInfo >	getColumnInfo () const
	get the expected column info
std::vector< std::string >	getColumnNames () const
	get the expected column names
std::vector< std::string >	getRecommendedSystematics () const
	get the recommended systematics
void	setLevel (MSG::Level lvl)
	Change the current logging level.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
asg::AsgToolConfig	m_config
ToolHandle< asg::AsgTool >	m_toolHandle
std::shared_ptr< void >	m_cleanup
IColumnarTool *	m_tool = nullptr
CP::ISystematicsTool *	m_systTool = nullptr
std::shared_ptr< const ColumnVectorHeader >	m_columnHeader
std::shared_ptr< const ToolColumnVectorMap >	m_toolWrapper
std::unique_ptr< ColumnVectorData >	m_columns
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

a handle to a python tool for use via nanobind

This is meant to be used together with a nanobind python binding, to provide a higher level and stable interface to the tool wrappers. For other uses people should use the underlying interfaces directly or write a new higher level interface (depending on what's appropriate).

For now this is not thread-safe. The underlying code is thread-safe, as long as there is a separate ColumnarToolWrapperData object for each thread. Also, the way the tools handle setting systematics is currently not thread-safe.

Definition at line 39 of file PythonToolHandle.h.

Constructor & Destructor Documentation

◆ PythonToolHandle()

columnar::PythonToolHandle::PythonToolHandle ( )

inline

standard constructor

Public Members

Definition at line 47 of file PythonToolHandle.h.

47: asg::AsgMessaging("PythonToolHandle") {}

Member Function Documentation

◆ applySystematicVariation()

void columnar::PythonToolHandle::applySystematicVariation ( const std::string & sysName )

inline

set the tool to apply the given systematic variation

Definition at line 116 of file PythonToolHandle.h.

    {
      // by convention setting a systematic on a non-systematics tool
      // will do nothing
      if (m_systTool == nullptr)
        return;
      if (!m_systTool->applySystematicVariation (CP::SystematicSet (sysName)).isSuccess())
        throw std::runtime_error ("failed to apply systematic variation");
    }

◆ call()

void columnar::PythonToolHandle::call ( )

inline

call the tool and reset the columns

Definition at line 155 of file PythonToolHandle.h.

    {
      if (!m_columns)
        throw std::runtime_error ("no columns set");
      m_columns->checkData ();
      m_columns->callNoCheck (*m_tool);
      m_columns = std::make_unique<ColumnVectorData> (m_columnHeader.get());
    }

◆ getColumnInfo()

std::vector< ColumnInfo > columnar::PythonToolHandle::getColumnInfo ( ) const

inlinenodiscard

get the expected column info

Definition at line 165 of file PythonToolHandle.h.

    {
      if (!m_toolWrapper)
        throw std::runtime_error ("tool not initialized");
      return m_tool->getColumnInfo ();
    }

◆ getColumnNames()

std::vector< std::string > columnar::PythonToolHandle::getColumnNames ( ) const

inline

get the expected column names

Definition at line 173 of file PythonToolHandle.h.

    {
      if (!m_toolWrapper)
        throw std::runtime_error ("tool not initialized");
      return m_toolWrapper->getColumnNames ();
    }

◆ getColumnVoid()

std::tuple< std::size_t, const void *, const std::type_info * > columnar::PythonToolHandle::getColumnVoid ( const std::string & name ) const

inlinenodiscard

get a column pointer by name; returns {size, ptr, type_info}

Definition at line 144 of file PythonToolHandle.h.

    {
      if (!m_columns)
        throw std::runtime_error ("tool not initialized");
      const std::size_t index = m_toolWrapper->getColumnIndex (name);
      const std::type_info* type = m_columnHeader->getColumn (index).type;
      auto [size, ptr] = m_columns->getColumnVoid (index, type, true);
      return {size, ptr, type};
    }

◆ getConfig()

const asg::AsgToolConfig & columnar::PythonToolHandle::getConfig ( ) const

inlinenodiscard

get the AsgToolConfig

Definition at line 64 of file PythonToolHandle.h.

    {
      return m_config;
    }

◆ getRecommendedSystematics()

std::vector< std::string > columnar::PythonToolHandle::getRecommendedSystematics ( ) const

inline

get the recommended systematics

Definition at line 181 of file PythonToolHandle.h.

    {
      if (!m_systTool)
        return {""};
      std::vector<std::string> result;
      for (auto& sys : CP::make_systematics_vector (m_systTool->recommendedSystematics()))
        result.push_back (sys.name());
      return result;
    }

◆ initialize()

void columnar::PythonToolHandle::initialize ( )

inline

initialize the tool

Definition at line 104 of file PythonToolHandle.h.

    {
      if (m_tool == nullptr)
        preinitialize ();
 
      auto columnHeader = std::make_shared<ColumnVectorHeader> ();
      m_columnHeader = columnHeader;
      m_toolWrapper = std::make_shared<ToolColumnVectorMap> (*columnHeader, *m_tool);
      m_columns = std::make_unique<ColumnVectorData> (m_columnHeader.get());
    }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

◆ msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns: A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns: A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

◆ msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns: boolean Indicting if messages at given level will be printed; true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

◆ preinitialize()

void columnar::PythonToolHandle::preinitialize ( )

inline

preinitialize the tool

Definition at line 70 of file PythonToolHandle.h.

    {
      ANA_MSG_DEBUG("preinitializing with " << m_toolHandle << " and cleanup " << m_cleanup);
      if (!m_config.makeTool (m_toolHandle, m_cleanup).isSuccess())
        throw std::runtime_error ("failed to create tool");
 
      ANA_MSG_DEBUG("m_config created tool" << m_toolHandle);
 
      m_tool = dynamic_cast<IColumnarTool*> (&*m_toolHandle);
 
      ANA_MSG_DEBUG("attempting to dynamically cast to IColumnarTool* gives " << m_tool);
      if (m_tool == nullptr)
        throw std::runtime_error ("The tool does not implement IColumnarTool. First, check to make sure you're in the ColumnarAnalysis release. Then, check to see if the tool inherits from ColumnarTool.");
      m_systTool = dynamic_cast<CP::ISystematicsTool*> (m_tool);
    }

◆ renameContainers()

void columnar::PythonToolHandle::renameContainers ( const std::vector< std::pair< std::string, std::string > > & renames )

inline

rename the columns the tool uses

Definition at line 87 of file PythonToolHandle.h.

    {
      if (m_tool == nullptr)
        preinitialize ();
      {
        columnar::renameContainers(*m_tool, renames);
      }
      if (m_toolWrapper)
      {
        auto columnHeader = std::make_shared<ColumnVectorHeader> ();
        m_columnHeader = columnHeader;
        m_toolWrapper = std::make_shared<ToolColumnVectorMap> (*columnHeader, *m_tool);
        m_columns = std::make_unique<ColumnVectorData> (m_columnHeader.get());
      }
    }

◆ setColumn()

template<typename CT>

void columnar::PythonToolHandle::setColumn	(	const std::string &	key,
		std::size_t	size,
		CT *	dataPtr )

inline

set a column pointer (raw pointer version)

Definition at line 128 of file PythonToolHandle.h.

    {
      if (!m_columns)
        throw std::runtime_error ("tool not initialized");
      m_columns->setColumn (m_toolWrapper->getColumnIndex (key), size, dataPtr);
    }

◆ setColumnVoid()

void columnar::PythonToolHandle::setColumnVoid	(	const std::string &	name,
		std::size_t	size,
		const void *	dataPtr,
		const std::type_info &	type,
		bool	isConst )

inline

set a column pointer

Definition at line 136 of file PythonToolHandle.h.

                                                                                                                            {
      if (!m_columns)
        throw std::runtime_error ("tool not initialized");
      m_columns->setColumnVoid (m_toolWrapper->getColumnIndex (name), size, dataPtr, type, isConst);
    }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

◆ setProperty()

template<typename T>

void columnar::PythonToolHandle::setProperty	(	const std::string &	key,
		T &&	value )

inline

set a property on the tool

Definition at line 57 of file PythonToolHandle.h.

    {
      if (m_config.setProperty (key, std::forward<T> (value)).isFailure())
        throw std::runtime_error ("failed to set property: " + key);
    }

◆ setTypeAndName()

void columnar::PythonToolHandle::setTypeAndName ( const std::string & typeAndName )

inline

set the type and name for the tool

Definition at line 50 of file PythonToolHandle.h.

    {
      m_config.setTypeAndName (typeAndName);
    }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_cleanup

std::shared_ptr<void> columnar::PythonToolHandle::m_cleanup

private

Definition at line 200 of file PythonToolHandle.h.

◆ m_columnHeader

std::shared_ptr<const ColumnVectorHeader> columnar::PythonToolHandle::m_columnHeader

private

Definition at line 205 of file PythonToolHandle.h.

◆ m_columns

std::unique_ptr<ColumnVectorData> columnar::PythonToolHandle::m_columns

private

Definition at line 207 of file PythonToolHandle.h.

◆ m_config

asg::AsgToolConfig columnar::PythonToolHandle::m_config

private

Private Members

Definition at line 198 of file PythonToolHandle.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

135{ nullptr };

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

138{ MSG::NIL };

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_systTool

CP::ISystematicsTool* columnar::PythonToolHandle::m_systTool = nullptr

private

Definition at line 203 of file PythonToolHandle.h.

◆ m_tool

IColumnarTool* columnar::PythonToolHandle::m_tool = nullptr

private

Definition at line 202 of file PythonToolHandle.h.

◆ m_toolHandle

ToolHandle<asg::AsgTool> columnar::PythonToolHandle::m_toolHandle

private

Definition at line 199 of file PythonToolHandle.h.

◆ m_toolWrapper

std::shared_ptr<const ToolColumnVectorMap> columnar::PythonToolHandle::m_toolWrapper

private

Definition at line 206 of file PythonToolHandle.h.

The documentation for this class was generated from the following file:

PythonToolHandle.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PythonToolHandle()

Public Members

Member Function Documentation

◆ applySystematicVariation()

◆ call()

◆ getColumnInfo()

◆ getColumnNames()

◆ getColumnVoid()

◆ getConfig()

◆ getRecommendedSystematics()

◆ initialize()

◆ initMessaging()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ preinitialize()

◆ renameContainers()

◆ setColumn()

◆ setColumnVoid()

◆ setLevel()

◆ setProperty()

◆ setTypeAndName()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_cleanup

◆ m_columnHeader

◆ m_columns

◆ m_config

Private Members

◆ m_imsg

◆ m_lvl

◆ m_msg_tls

◆ m_nm

◆ m_systTool

◆ m_tool

◆ m_toolHandle

◆ m_toolWrapper