RootUtils Namespace Reference

Classes
class	ILogger
	Very simple interface for writing log messages. More...
class	InitHist
	Initialize Root's getline history. More...
class	PyBytes
class	PyGILStateEnsure
class	PyLogger
	A concrete implementation of ILogger that calls back to Python. More...
class	PyROOTInspector
class	PyROOTIteratorFuncs
	Provide functions for iterator comparisons. More...
class	PyROOTPickle
class	PyROOTTTreePatch
class	PyROOTTypePatch
	Work around pyroot problem with __pair_base. More...
class	ScatterH2
	A 2-D histogram that can draw a proper scatter plot. More...
class	TRandomTLS
	Thread-local TRandom generator. More...
class	TreeNotifier
	Tree notification handler. More...
class	TSMethodCall
	Helper for making a thread-safe function call. More...
class	Type
	Wrapper for ROOT types. More...
class	WithRootErrorHandler
	Run a MT piece of code with an alternate root error handler. More...

Typedefs
using	PyException = CPyCppyy::PyException

Functions
std::pair< std::string, bool >	PyGetString (PyObject *s)
	Convert python string -> C++ string for py2 and py3. More...
PyBytes	_pythonize_read_root_file (TFile *f, Int_t len)
	read len bytes from file f More...
Long64_t	_pythonize_tell_root_file (TFile *f)
	tell the current position in file f More...
PyObject *	CPPInstanceReduce (PyObject *self, PyObject *)
	PyROOT object proxy pickle support. More...
PyObject *	CPPInstanceExpand (PyObject *, PyObject *args)
	Helper for (un)pickling of CPPInstance's. More...
PyObject *	treeSetNotify (PyObject *, PyObject *args)
	Implementation for pythonization of TTree::SetNotify. More...
PyObject *	treeGetNotify (PyObject *, PyObject *args)
	Implementation for pythonization of TTree::SetNotify. More...
PyObject *	branchSetAddress (PyObject *, PyObject *args)
	Pythonization of TBranch::SetAddress. More...
void	installMethod (PyObject *pyclass, PyMethodDef &pdef, const char *name, PyCFunction cfunc)
	Helper to install a method in a Python class. More...
int	GetBuffer (PyObject *pyobject, char tc, int size, void *&buf, Bool_t check)
PyObject *	getRootModule ()
PyObject *	rootModule ()
TClass *	objectIsA (PyObject *obj)
PyObject *	getSetOwnershipFunc ()
PyObject *	setOwnershipFunc ()
bool	setOwnership (PyObject *obj, bool flag)

Typedef Documentation

PyException

using RootUtils::PyException = typedef CPyCppyy::PyException

Definition at line 24 of file Utility.h.

Function Documentation

_pythonize_read_root_file()

PyBytes RootUtils::_pythonize_read_root_file	(	TFile *	f,
		Int_t	len
	)

read len bytes from file f

Definition at line 60 of file PyROOTTFilePythonize.cxx.

{
  if (!f) {
    //err
    return PyBytes(0);
  }
 
  Long64_t totsz  = f->GetSize();
  Long64_t curpos = _pythonize_tell_root_file(f);
  Long64_t remain = totsz - curpos;
  remain = (remain>0) ? remain : 0;
 
  len = (len>remain) ? remain : len;
  PyBytes buf(len);
  if (f->ReadBuffer((char*)buf.buf.data(), buf.sz)) {
    //err
    return PyBytes(0);
  }
 
  f->Seek(buf.sz + curpos);
  return buf;
}

_pythonize_tell_root_file()

Long64_t RootUtils::_pythonize_tell_root_file

(

TFile *

f

)

tell the current position in file f

Definition at line 49 of file PyROOTTFilePythonize.cxx.

{
  if (f) {
    return f->GetRelOffset();
  }
  fprintf (stderr, 
           "::RootUtils::_pythonize_tell_root_file got a NULL TFile ptr!\n");
  return 0;
}

branchSetAddress()

PyObject* RootUtils::branchSetAddress	(	PyObject *	,
		PyObject *	args
	)

Pythonization of TBranch::SetAddress.

Parameters

args	The Python arguments.

Definition at line 268 of file PyROOTTTreePatch.cxx.

{
  // Decode arguments --- the branch and the buffer.
  PyObject* self = 0;
  PyObject* address = 0;
  if ( ! PyArg_ParseTuple( args, const_cast< char* >( "OO:SetBranchAddress" ),
                           &self, &address ) )
    return 0;
 
  // The branch as a Root object.
  TBranch* branch = 0;
  if (TPython::CPPInstance_Check (self)) {
    branch =  (TBranch*)objectIsA(self)->DynamicCast
      ( TBranch::Class(),
        TPython::CPPInstance_AsVoidPtr(self) );
  }
 
  if ( ! branch ) {
    PyErr_SetString( PyExc_TypeError,
                     "TBranch::SetAddress must be called with a "
                     "TBranch instance as first argument" );
    return 0;
  }
 
  // Convert the buffer argument to an address.
  void* buf = 0;
  if ( TPython::CPPInstance_Check( address ) ) {
    auto* inst = reinterpret_cast<CPPInstance*>(address);
    if ( inst->fFlags & CPPInstance::kIsReference )
      buf = inst->fObject;
    else
      buf = &inst->fObject;
  }
  else
    RootUtils::GetBuffer( address, '*', 1, buf, kFALSE );
 
  // Make the call and return.
  if ( buf != 0 )
    branch->SetAddress( buf );
 
  Py_INCREF( Py_None );
  return Py_None;
}

CPPInstanceExpand()

PyObject* RootUtils::CPPInstanceExpand	(	PyObject *	,
		PyObject *	args
	)

Helper for (un)pickling of CPPInstance's.

Parameters

args	The Python arguments.

Definition at line 86 of file PyROOTPickle.cxx.

{
  // This method is a helper for (un)pickling of CPPInstance instances.
  PyObject* pybuf = 0;
  const char* clname = 0;
  if ( ! PyArg_ParseTuple( args, const_cast< char* >( "O!s:__expand__" ),
           &PyUnicode_Type, &pybuf, &clname ) )
    return 0;
 
  // use the PyString macros to by-pass error checking; do not adopt the buffer,
  // as the local TBufferFile can go out of scope (there is no copying)
  TBufferFile buf( TBuffer::kRead,
                   PyUnicode_GET_LENGTH( pybuf ),
                   (char*)PyGetString( pybuf ).first.c_str(),
                   kFALSE );
 
  void* result = buf.ReadObjectAny( 0 );
  return TPython::CPPInstance_FromVoidPtr( result, clname );
}

CPPInstanceReduce()

PyObject* RootUtils::CPPInstanceReduce	(	PyObject *	self,
		PyObject *
	)

PyROOT object proxy pickle support.

Parameters

self	object proxy instance to be pickled

Definition at line 36 of file PyROOTPickle.cxx.

{
  // Turn the object proxy instance into a character stream and return for
  // pickle, together with the callable object that can restore the stream
  // into the object proxy instance.
 
  void* vself = TPython::CPPInstance_AsVoidPtr( self );    // checks type
  if ( ! vself ) {
     PyErr_SetString( PyExc_TypeError,
       "__reduce__ requires an object proxy instance as first argument" );
     return 0;
  }
 
  PyObject* nattr = PyObject_GetAttrString( (PyObject*)self->ob_type, (char*)"__name__" );
  PyObject* pyname = PyObject_Str( nattr );
  Py_DECREF( nattr );
 
  std::string klassname = PyGetString( pyname ).first;
  TClass* klass = TClass::GetClass( klassname.c_str() );
 
  // no cast is needed, but WriteObject taking a TClass argument is protected,
  // so use WriteObjectAny()
  TBufferFile buf( TBuffer::kWrite );
  if ( buf.WriteObjectAny( vself, klass ) != 1 ) {
     PyErr_Format( PyExc_IOError,
                   "could not stream object of type %s", klassname.c_str() );
     Py_DECREF( pyname );
     return 0;
  }
 
  // use a string for the serialized result, as a python buffer will not copy
  // the buffer contents; use a string for the class name, used when casting
  // on reading back in
  PyObject* res2 = PyTuple_New( 2 );
  PyTuple_SET_ITEM( res2, 0, PyUnicode_FromStringAndSize( buf.Buffer(), buf.Length() ) );
  PyTuple_SET_ITEM( res2, 1, pyname );
 
  PyObject* result = PyTuple_New( 2 );
  Py_INCREF( gExpand );
  PyTuple_SET_ITEM( result, 0, gExpand );
  PyTuple_SET_ITEM( result, 1, res2 );
 
  return result;
}

GetBuffer()

int RootUtils::GetBuffer	(	PyObject *	pyobject,
		char	tc,
		int	size,
		void *&	buf,
		Bool_t	check
	)

Definition at line 26 of file Utility.cxx.

{
// Retrieve a linear buffer pointer from the given pyobject.
 
// special case: don't handle character strings here (yes, they're buffers, but not quite)
   if ( PyBytes_Check( pyobject ) )
      return 0;
 
// attempt to retrieve pointer to buffer interface
   PyBufferProcs* bufprocs = Py_TYPE(pyobject)->tp_as_buffer;
 
   PySequenceMethods* seqmeths = Py_TYPE(pyobject)->tp_as_sequence;
   if ( seqmeths != 0 && bufprocs != 0
        && bufprocs->bf_getbuffer != 0
      ) {
 
   // get the buffer
      Py_buffer bufinfo;
      (*(bufprocs->bf_getbuffer))( pyobject, &bufinfo, PyBUF_WRITABLE );
      buf = (char*)bufinfo.buf;
      Py_ssize_t buflen = bufinfo.len;
 
      if ( buf && check == kTRUE ) {
      // determine buffer compatibility (use "buf" as a status flag)
         PyObject* pytc = PyObject_GetAttrString( pyobject, "typecode");
         if ( pytc != 0 ) {     // for array objects
            const char* s = PyUnicode_AsUTF8AndSize( pytc, nullptr );
            if ( s && s[0] != tc )
               buf = 0;         // no match
            Py_DECREF( pytc );
         } else if ( seqmeths->sq_length &&
                     (int)(buflen / (*(seqmeths->sq_length))( pyobject )) == size ) {
         // this is a gamble ... may or may not be ok, but that's for the user
            PyErr_Clear();
         } else if ( buflen == size ) {
         // also a gamble, but at least 1 item will fit into the buffer, so very likely ok ...
            PyErr_Clear();
         } else {
            buf = 0;                      // not compatible
 
         // clarify error message
            PyObject* pytype = 0, *pyvalue = 0, *pytrace = 0;
            PyErr_Fetch( &pytype, &pyvalue, &pytrace );
            const char* s = PyUnicode_AsUTF8AndSize( pyvalue, nullptr );
            if (!s) s = "(null)";
            PyObject* pyvalue2 = PyUnicode_FromFormat(
               (char*)"%s and given element size (%ld) do not match needed (%d)",
               s,
               seqmeths->sq_length ? (Long_t)(buflen / (*(seqmeths->sq_length))( pyobject )) : (Long_t)buflen,
               size );
            Py_DECREF( pyvalue );
            PyErr_Restore( pytype, pyvalue2, pytrace );
         }
      }
 
      return buflen;
   }
 
   return 0;
}

getRootModule()

PyObject* RootUtils::getRootModule

(

)

Definition at line 89 of file Utility.cxx.

{
  return PyImport_ImportModule ("ROOT");
}

getSetOwnershipFunc()

PyObject* RootUtils::getSetOwnershipFunc

(

)

Definition at line 126 of file Utility.cxx.

{
  PyObject* root = rootModule();
  PyObject* ret = PyObject_GetAttrString (root, "SetOwnership");
  Py_DECREF (root);
  return ret;
}

installMethod()

void RootUtils::installMethod	(	PyObject *	pyclass,
		PyMethodDef &	pdef,
		const char *	name,
		PyCFunction	cfunc
	)

Helper to install a method in a Python class.

Parameters

pyclass	The Python class.
pdef	A PyMethodDef object.
name	The method name.
cfunc	The C function to install.

Definition at line 320 of file PyROOTTTreePatch.cxx.

{
  pdef.ml_name = const_cast<char*> (name);
  pdef.ml_meth = cfunc;
  pdef.ml_flags = METH_VARARGS;
  pdef.ml_doc = 0;
 
  PyObject* func = PyCFunction_New (&pdef, 0);
  PyObject* method = PyInstanceMethod_New (func);
  Bool_t isOK = PyObject_SetAttrString (pyclass, pdef.ml_name, method) == 0;
 
  if (PyErr_Occurred())
    fprintf (stderr, "Py error");
  else if (!isOK) {
    fprintf (stderr, "Could not add method %s\n", name);
  }
}

objectIsA()

TClass * RootUtils::objectIsA

(

PyObject *

obj

)

Definition at line 103 of file Utility.cxx.

{
  TClass* cls = nullptr;
  PyObject* attr = PyObject_GetAttrString ((PyObject*)Py_TYPE(obj), "__cpp_name__");
  if (attr) {
    PyObject* buf = PyUnicode_AsASCIIString (attr);
    if (buf) {
      char* s = PyBytes_AsString (buf);
      if (*s == '<') ++s;
      if (strncmp (s, "ROOT.", 5) == 0)
        s += 5;
      if (strncmp (s, "cppyy.gbl.", 10) == 0)
        s += 10;
      cls = TClass::GetClass (s);
      Py_DECREF(buf);
    }
    Py_DECREF(attr);
  }
  PyErr_Clear();
  return cls;
}

PyGetString()

std::pair<std::string, bool> RootUtils::PyGetString ( PyObject *  s )

inline

Convert python string -> C++ string for py2 and py3.

Returns a pair (string, bool); the second element is true of the conversion succeeded.

This should be kept as an inline function to avoid having to have direct dependencies on python where it's not really needed.

Definition at line 40 of file PyGetString.h.

{
  const char* cstr = PyUnicode_AsUTF8AndSize (s, nullptr);
  if (!cstr && PyBytes_Check (s)) {
    PyErr_Clear();
    cstr = PyBytes_AsString (s);
  }
  if (cstr) {
    return std::make_pair (std::string (cstr), true);
  }
  return std::make_pair (std::string(), false);
}

rootModule()

PyObject* RootUtils::rootModule

(

)

Definition at line 95 of file Utility.cxx.

{
  static PyObject* const rootModule = getRootModule();
  Py_INCREF (rootModule);
  return rootModule;
}

setOwnership()

bool RootUtils::setOwnership	(	PyObject *	obj,
		bool	flag
	)

Definition at line 141 of file Utility.cxx.

{
  PyObject* func = setOwnershipFunc();
  PyObject* ret = PyObject_CallFunction (func, const_cast<char*>("OI"),
                                         obj,
                                         static_cast<unsigned int>(flag));
  Py_DECREF (func);
  if (ret) {
    Py_DECREF (ret);
    return true;
  }
  return false;
}

setOwnershipFunc()

PyObject* RootUtils::setOwnershipFunc

(

)

Definition at line 134 of file Utility.cxx.

{
  static PyObject* const func = getSetOwnershipFunc();
  Py_INCREF (func);
  return func;
}

treeGetNotify()

PyObject* RootUtils::treeGetNotify	(	PyObject *	,
		PyObject *	args
	)

Implementation for pythonization of TTree::SetNotify.

Parameters

args	The Python arguments.

Definition at line 241 of file PyROOTTTreePatch.cxx.

{
  // Decode the objects --- the tree.
  PyObject* self = 0;
  if ( ! PyArg_ParseTuple( args, const_cast< char* >( "O:SetNotify" ),
                           &self ) )
    return 0;
 
  // Intern string if needed.
  if (pynotify_str == 0)
    pynotify_str = PyUnicode_InternFromString("__pynotify__");
 
  // Retrieve the notifier.
  PyObject* ret = PyObject_GetAttr (self, pynotify_str);
  if (!ret) {
    PyErr_Clear();
    Py_INCREF (Py_None);
    ret = Py_None;
  }
  return ret;
}

treeSetNotify()

PyObject* RootUtils::treeSetNotify	(	PyObject *	,
		PyObject *	args
	)

Implementation for pythonization of TTree::SetNotify.

Parameters

args	The Python arguments.

Definition at line 190 of file PyROOTTTreePatch.cxx.

{
  // Decode the objects --- the tree and the notifier object.
  PyObject* self = 0;
  PyObject* obj = 0;
  if ( ! PyArg_ParseTuple( args, const_cast< char* >( "OO:SetNotify" ),
                           &self, &obj ) )
    return 0;
 
  // Intern strings if needed.
  if (pynotify_str == 0) {
    pynotify_str = PyUnicode_InternFromString("__pynotify__");
  }
  if (notifier_str == 0) {
    notifier_str = PyUnicode_InternFromString("__notifier__");
  }
 
  // Set up notifier.
  if (!PyObject_HasAttr (self, notifier_str)) {
    // get hold of actual tree
    void* vp = TPython::CPPInstance_AsVoidPtr (self);
    TTree* tree =
      (TTree*)objectIsA(self)->DynamicCast ( TTree::Class(), vp );
 
    PyObject* treeobj_ref = PyWeakref_NewRef (self, 0);
    if (!treeobj_ref)
      return 0;
    TObject* notifier = new TreeNotifier (tree, treeobj_ref);
    PyObject* notobj = TPython::CPPInstance_FromVoidPtr (notifier, "TObject");
    setOwnership (notobj, true);
    int stat = PyObject_SetAttr (self, notifier_str, notobj);
    Py_XDECREF (notobj);
    if (stat < 0)
      return 0;
    tree->SetNotify (notifier);
  }
 
  // Install the object.
  int stat = PyObject_SetAttr (self, pynotify_str, obj);
  if (stat < 0)
    return 0;
 
  Py_INCREF (Py_None);
  return Py_None;
}