silenced after commit 466e5825

silenced after commit 466e5825

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.

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).

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

NULL conversion warnings appearing with gcc 7 and 8.

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

Cppyy does not automatically add to a class the method overloads that
come from a 'using' statement. For this reason, a pythonisation is
needed for RooDataHist to see the overloads it is using from
RooAbsData.

TClass::DynamicCast returns a void* that the user still has to cast.
This pythonisation provides the requested binding if the cast succeeded.

This feature is able to adopt memory from PyObjects defining an
__array_interface__ as RVecs.

The new interface in Converters deals with multi-dimensional arrays.

TPython::CPPOverload_Check does an additional check for the
initialization of the Python interpreter that we don't need.