silenced after commit 466e5825

silenced after commit 466e5825

The new cmake option `dataframe` enables building the ROOTDataFrame
library and takes care of implication on the build system. The option is
enabled by default unless a 32bit system is detected.

[Exp PyROOT] Implemented the possibility to call a namespace inside cppyy.gbl.ROOT by typing simply ROOT.namespace instead of ROOT.ROOT.namespace

We add __radd__, __rsub__, __rmul__ and __rtruediv__/__rdiv__

The warnings are triggered by the use of the Py_RETURN_TRUE and
Py_RETURN_FALSE macros of the Python C API. The use of such macros
is necessary and cannot be worked around.

The option is disabled on Windows since it does not exist.

The Python C API already provides these convenience macros.

The equality and inequality operators are better implemented in C++,
since we need to need to rely on Cppyy's rich comparison if the object
we are comparing ourselves with is not a Python proxy or if it contains
a null pointer. For example, we need to support the comparison to None.

The rest of comparison operators (i.e. those that define order)
can be implemented in Python, throwing a NotImplemented exception
if we are not comparing two proxies to TObject or derivate.

When drawing a TPad, it gets added to the list of primititves of its
mother TPad (fMother) with kCanDelete == 1. This means that, when
fMother is destructed, it will attempt to destroy its child TPad too.
To prevent a double delete, here we instruct the Python proxy of the
child C++ TPad being drawn not to destroy the latter (ROOT-10060).

A similar principle is applied to TButton, TColorWheel, TPolyLine3D,
TPolyMarker and TPolyMarker3D, whose kCanDelete bit is set in one of
their constructors. Later, when being drawn, they are appended to
the list of primitives of gPad.

TSlider is a special case, since it is appended to gPad already
in one of its constructors, after setting kCanDelete.
Therefore, we need to set the ownership when constructing the
object and not in Draw (TSlider does not need to be drawn).
This is ROOT-10095.

By default, PyROOT will send sys.argv to TApplication for the
arguments to be parsed. User arguments for the Python script
can be passed after a "-" or "--" in the command line and
they will be ignored by PyROOT.

The user can disable the aforementioned argument parsing by
adding a configuration option before any lookup in the ROOT module:
> import ROOT
> ROOT.PyConfig.IgnoreCommandLineOptions = True

This commit introduces the logic to display ROOT graphics when
using Python interactively. For that purpose, hooks are installed
to process the GUI events and to update the display.

Note that the threading approach is not used anymore: no thread
is explicitly created to process the events. The code based on
hooks should work on all the platforms, but it needs to be
tested. For the same reason, some code that handled the
threading case on Windows has been removed for now, and will be
restored only if necessary.

Most of the code has been picked from several parts of the
current ROOT.py and put together in the configuration of the
PyROOT TApplication.

The activation of the graphics is triggered only if ROOT is not
in batch mode. Such mode can be set by the user right after
importing ROOT.

The RPyROOTApplication is a TApplication that sets up the nuts
and bolts for interactive ROOT use from Python, closely
following TRint.

Variables are detected as used initialized if initialization is done via
a call to the interpreter.

The warning is introduced starting with gcc8 (cast-function-type).

Register keyword is deprecated since C++11. Observed with Python 2.7
installation and AppleClang/gcc7 in combination with C++17.

Set missing initializer in list, warning seen with gcc 7 and 8.

NULL conversion warnings appearing with gcc 7 and 8.

These tests will work again once this PR is merged:
https://github.com/root-project/root/pull/3640

The feature implemented by the PR consists in automatically adding
using declarations of methods from a base class to the derived
class. After the PR is merged, the feature will be provided by
the bindings.

In its last update (CPyCppyy 1.6.4), Cppyy automatically adds to
a derived class the overloads of a base class that come from
using declarations.

Therefore, that makes the pythonisation for plotOn redundant,
since everything will be handled at the bindings level.

[PyROOT exp] long does not exist anymore in Python3, map to int

[PyROOT exp] Clear error indicator for fallback (enforced since py3.6)

[PyROOT] Use Python/C API utility for warnings

[PyROOT exp] Dont set error indicator during fetching keyword

[PyROOT exp] Move implementation of DeclareGenericCallable to separate source file

[PyROOT exp] Add feature to jit Python callable using numba

So far, the jitting is only supported for basic types.

[PyROOT exp] Add proxy class to switch between numba and generic impl

[PyROOT exp] Ensure no leaking PyObject if stepping out early in callable proxy

[PyROOT exp] Allow user to pass optional name of wrapper function

[PyROOT exp] Add test for dispatcher of wrapper functions

[PyROOT exp] Put in first round of comment

 - numba_only, generic_only and verbose flag
 - put only one decorator
 - change namespace of C++ side functions
 - modularize code
 - adapt tests

[PyROOT exp] Add missing DECREFs when stepping out due to an exception

[PyROOT exp] Remove unnecessary import of headers

[PyROOT exp] Make verbose=True to new default

Instead of specifying the location of the PCH, we can just use
the magic word 'none' to tell cppyy not to check the PCH.
In both cases, the objective is to avoid a warning from cppyy
when importing it.

This is a pythonisation for TGraph, TGraph2D and their error
subclasses. In particular, it pythonises their getter methods
of the X,Y,Z coordinate and error arrays, which in C++ return
a pointer to a double.

The pythonization consists in setting the size of the array
that the getter method returns, so that it is known in Python
and the array is fully usable (its length can be obtained,
it is iterable).