[PyROOT][ROOT-10294] Reuse TEnum to get its underlying type

README/ReleaseNotes/v620/index.md

@@ -75,6 +75,17 @@ or in `TBrowser` by opening `Browser Help → About ROOT`.
 ## I/O Libraries
 
 * TMemFile: Apply customization of minimal block size also to the first block.
+* TFile: A new bit `TFile::kReproducible` was introduced. It can be enabled by
+  specifying the `"reproducible"` url option when creating the file:
+   ```{.cpp}
+      TFile *f = TFile::Open("name.root?reproducible","RECREATE","File title");
+   ```{.cpp}
+   Unlike regular `TFile`s, the content of such file has reproducible binary
+   content when writing exactly same data. This achieved by writing pre-defined
+   values for creation and modification date of TKey/TDirectory objects and null
+   value for TUUID objects inside TFile. As drawback, TRef objects stored in such
+   file cannot be read correctly.
+
 
 ## TTree Libraries
 

bindings/pyroot/src/Cppyy.cxx

@@ -12,7 +12,6 @@
 #include "TCollection.h"
 #include "TDataMember.h"
 #include "TDataType.h"
-#include "TEnum.h"
 #include "TEnumConstant.h"
 #include "TError.h"
 #include "TFunction.h"
@@ -175,9 +174,8 @@ std::string Cppyy::ResolveName( const std::string& cppitem_name )
    return TClassEdit::ResolveTypedef( tclean.c_str(), true );
 }
 
-std::string Cppyy::ResolveEnum(const std::string& enum_type)
+std::string Cppyy::ResolveEnum(const TEnum* en)
 {
-   auto en = TEnum::GetEnum(enum_type.c_str());
    if (en) {
       auto ut = en->GetUnderlyingType();
       if (ut != EDataType::kNumDataTypes)
@@ -187,6 +185,11 @@ std::string Cppyy::ResolveEnum(const std::string& enum_type)
    return "int";
 }
 
+std::string Cppyy::ResolveEnum(const std::string& enum_type)
+{
+   return ResolveEnum(TEnum::GetEnum(enum_type.c_str()));
+}
+
 Cppyy::TCppScope_t Cppyy::GetScope( const std::string& sname )
 {
    std::string scope_name;

bindings/pyroot/src/Cppyy.h

@@ -1,6 +1,9 @@
 #ifndef PYROOT_CPPYY_H
 #define PYROOT_CPPYY_H
 
+// ROOT
+#include "TEnum.h"
+
 // Standard
 #include <string>
 #include <vector>
@@ -22,6 +25,7 @@ namespace Cppyy {
    TCppIndex_t GetNumScopes( TCppScope_t parent );
    std::string GetScopeName( TCppScope_t parent, TCppIndex_t iscope );
    std::string ResolveName( const std::string& cppitem_name );
+   std::string ResolveEnum(const TEnum* en);
    std::string ResolveEnum(const std::string& enum_type);
    TCppScope_t GetScope( const std::string& scope_name );
    std::string GetName( const std::string& scope_name );

bindings/pyroot/src/PropertyProxy.cxx

@@ -214,10 +214,9 @@ void PyROOT::PropertyProxy::Set( Cppyy::TCppScope_t scope, Cppyy::TCppIndex_t id
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void PyROOT::PropertyProxy::Set( Cppyy::TCppScope_t scope, const std::string& name, void* address )
+void PyROOT::PropertyProxy::Set( Cppyy::TCppScope_t scope, const std::string& name, void* address, TEnum* en )
 {
-   Cppyy::TCppIndex_t idata = Cppyy::GetDatamemberIndex(scope, name);
-   std::string cppType = Cppyy::ResolveEnum(Cppyy::GetDatamemberType(scope, idata));
+   std::string cppType = Cppyy::ResolveEnum(en);
 
    fEnclosingScope = scope;
    fName           = name;

bindings/pyroot/src/PropertyProxy.h

@@ -25,7 +25,7 @@ namespace PyROOT {
    class PropertyProxy {
    public:
       void Set( Cppyy::TCppScope_t scope, Cppyy::TCppIndex_t idata );
-      void Set( Cppyy::TCppScope_t scope, const std::string& name, void* address );
+      void Set( Cppyy::TCppScope_t scope, const std::string& name, void* address, TEnum* en );
 
       std::string GetName() { return fName; }
       void* GetAddress( ObjectProxy* pyobj /* owner */ );
@@ -70,12 +70,12 @@ namespace PyROOT {
    }
 
    inline PropertyProxy* PropertyProxy_NewConstant(
-      Cppyy::TCppScope_t scope, const std::string& name, void* address )
+      Cppyy::TCppScope_t scope, const std::string& name, void* address, TEnum* en )
    {
    // Create an initialize a new property descriptor, given the C++ datum.
       PropertyProxy* pyprop =
          (PropertyProxy*)PropertyProxy_Type.tp_new( &PropertyProxy_Type, 0, 0 );
-      pyprop->Set( scope, name, address );
+      pyprop->Set( scope, name, address, en );
       return pyprop;
    }
 

bindings/pyroot/src/RootWrapper.cxx

@@ -121,11 +121,11 @@ namespace {
       Py_DECREF( property );
    }
 
-   void AddPropertyToClass( PyObject* pyclass,
-         Cppyy::TCppScope_t scope, const std::string& name, void* address )
+   void AddConstantPropertyToClass( PyObject* pyclass,
+         Cppyy::TCppScope_t scope, const std::string& name, void* address, TEnum* en )
    {
       PyROOT::PropertyProxy* property =
-         PyROOT::PropertyProxy_NewConstant( scope, name, address );
+         PyROOT::PropertyProxy_NewConstant( scope, name, address, en );
       AddPropertyToClass1( pyclass, property, kTRUE );
       Py_DECREF( property );
    }
@@ -366,7 +366,7 @@ static int BuildScopeProxyDict( Cppyy::TCppScope_t scope, PyObject* pyclass ) {
       if (isScoped) continue; // scoped enum: do not add constants as properties of the enum's scope
       for ( Int_t i = 0; i < seq->GetSize(); i++ ) {
          TEnumConstant* ec = (TEnumConstant*)seq->At( i );
-         AddPropertyToClass( pyclass, scope, ec->GetName(), ec->GetAddress() );
+         AddConstantPropertyToClass( pyclass, scope, ec->GetName(), ec->GetAddress(), e );
       }
    }
 

bindings/pyroot_experimental/PyROOT/CMakeLists.txt

@@ -26,6 +26,7 @@ set(py_sources
   ROOT/pythonization/_drawables.py
   ROOT/pythonization/_generic.py
   ROOT/pythonization/_rooabscollection.py
+  ROOT/pythonization/_roodatahist.py
   ROOT/pythonization/_rvec.py
   ROOT/pythonization/_stl_vector.py
   ROOT/pythonization/_tarray.py

bindings/pyroot_experimental/PyROOT/python/ROOT/__init__.py

@@ -22,6 +22,9 @@
 # Prevent cppyy's check for extra header directory
 environ['CPPYY_API_PATH'] = 'none'
 
+# Prevent cppyy from filtering ROOT libraries
+environ['CPPYY_NO_ROOT_FILTER'] = '1'
+
 import cppyy
 import ROOT.pythonization as pyz
 

bindings/pyroot_experimental/PyROOT/python/ROOT/_facade.py

@@ -97,6 +97,11 @@ def _finalSetup(self):
         if not self.gROOT.IsBatch():
             self.app.init_graphics()
 
+        # Set memory policy to kUseHeuristics.
+        # This restores the default in PyROOT which was changed
+        # by new Cppyy
+        self.SetMemoryPolicy(self.kMemoryHeuristics)
+
         # Redirect lookups to cppyy's global namespace
         self.__dict__['ROOT_ns'] = gbl_namespace.ROOT
         self.__class__.__getattr__ = self._fallback_getattr

bindings/pyroot_experimental/PyROOT/python/ROOT/pythonization/_roodatahist.py

@@ -0,0 +1,26 @@
+# Author: Enric Tejedor CERN  08/2019
+
+################################################################################
+# Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.                      #
+# All rights reserved.                                                         #
+#                                                                              #
+# For the licensing terms see $ROOTSYS/LICENSE.                                #
+# For the list of contributors see $ROOTSYS/README/CREDITS.                    #
+################################################################################
+
+from ROOT import pythonization
+
+from libROOTPython import AddUsingToClass
+
+
+@pythonization()
+def pythonize_roodatahist(klass, name):
+    # Parameters:
+    # klass: class to be pythonized
+    # name: string containing the name of the class
+
+    if name == 'RooDataHist':
+        # Add 'using' overloads for plotOn from RooAbsData
+        AddUsingToClass(klass, 'plotOn')
+
+    return True

bindings/pyroot_experimental/PyROOT/python/ROOT/pythonization/_tcollection.py

@@ -75,8 +75,10 @@ def _imul_pyz(self, n):
     # - n: factor to multiply the collection by
     # Returns:
     # - self *= n
+    c = self.__class__()
+    c.AddAll(self)
     for _ in range(n - 1):
-        _extend_pyz(self, self)
+        _extend_pyz(self, c)
     return self
 
 # Python iteration

bindings/pyroot_experimental/PyROOT/python/ROOT/pythonization/_tseqcollection.py

@@ -70,6 +70,15 @@ def _getitem_pyz(self, idx):
 
     return res
 
+def _remove_at(self, idx):
+    # Parameters:
+    # - self: collection to remove the item from
+    # - idx: index of the item, always positive
+    lnk = self.FirstLink()
+    for i in range(idx):
+        lnk = lnk.Next()
+    return self.Remove(lnk)
+
 def _setitem_pyz(self, idx, val):
     # Parameters:
     # - self: collection where to set item/s
@@ -97,10 +106,20 @@ def _setitem_pyz(self, idx, val):
             except StopIteration:
                 # No more indices in range, just append
                 self.append(elem)
+
+        # If range is longer than the number of elements in val,
+        # we need to remove the remaining elements of the range
+        try:
+            for i in it:
+                del self[i]
+        except StopIteration:
+            # No more indices in range, we are done
+            pass
+
     # Number
     else:
         idx = _check_index(self, idx)
-        self.RemoveAt(idx)
+        _remove_at(self, idx)
         self.AddAt(val, idx)
 
 def _delitem_pyz(self, idx):
@@ -119,11 +138,11 @@ def _delitem_pyz(self, idx):
             rg = reversed(rg)
 
         for i in rg:
-            self.RemoveAt(i)
+            _remove_at(self, i)
     # Number
     else:
         idx = _check_index(self, idx)
-        self.RemoveAt(idx)
+        _remove_at(self, idx)
 
 # Python-list-like methods
 
@@ -177,7 +196,7 @@ def _pop_pyz(self, *args):
     if idx < 0 or idx >= lcol:
         raise IndexError('pop index out of range')
 
-    return self.RemoveAt(idx)
+    return _remove_at(self, idx)
 
 def _reverse_pyz(self):
     # Parameters: