callback_python.h

Go to the documentation of this file.

/*
 * *** ATTENTION!  DO NOT MODIFY THIS FILE DIRECTLY! ***
 * 
 * It has automatically been generated from callback_python.tmpl.h
 * by param_expander.py on Fri Aug 14 16:06:13 2026.
 */
 
/** @file
 *  @author Bram de Greve (bram@cocamware.com)
 *  @author Tom De Muer (tom@cocamware.com)
 *
 *  *** BEGIN LICENSE INFORMATION ***
 *  
 *  The contents of this file are subject to the Common Public Attribution License 
 *  Version 1.0 (the "License"); you may not use this file except in compliance with 
 *  the License. You may obtain a copy of the License at 
 *  http://lass.sourceforge.net/cpal-license. The License is based on the 
 *  Mozilla Public License Version 1.1 but Sections 14 and 15 have been added to cover 
 *  use of software over a computer network and provide for limited attribution for 
 *  the Original Developer. In addition, Exhibit A has been modified to be consistent 
 *  with Exhibit B.
 *  
 *  Software distributed under the License is distributed on an "AS IS" basis, WITHOUT 
 *  WARRANTY OF ANY KIND, either express or implied. See the License for the specific 
 *  language governing rights and limitations under the License.
 *  
 *  The Original Code is LASS - Library of Assembled Shared Sources.
 *  
 *  The Initial Developer of the Original Code is Bram de Greve and Tom De Muer.
 *  The Original Developer is the Initial Developer.
 *  
 *  All portions of the code written by the Initial Developer are:
 *  Copyright (C) 2004-2026 the Initial Developer.
 *  All Rights Reserved.
 *  
 *  Contributor(s):
 *
 *  Alternatively, the contents of this file may be used under the terms of the 
 *  GNU General Public License Version 2 or later (the GPL), in which case the 
 *  provisions of GPL are applicable instead of those above.  If you wish to allow use
 *  of your version of this file only under the terms of the GPL and not to allow 
 *  others to use your version of this file under the CPAL, indicate your decision by 
 *  deleting the provisions above and replace them with the notice and other 
 *  provisions required by the GPL License. If you do not delete the provisions above,
 *  a recipient may use your version of this file under either the CPAL or the GPL.
 *  
 *  *** END LICENSE INFORMATION ***
 */
 
 
#ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H
#define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H
 
#include "python_common.h"
#include "pyobject_plus.h"
#include "py_tuple.h"
#include "pyobject_call.inl"
#include "exception.h"
#include "_lass_module.h"
 
namespace lass
{
namespace python
{
namespace impl
{
    /** Common implementation of a dispatcher to an python callback with void return type
     *  @internal
     *  @author Bramz
     */
    class FunctorPythonBase
    {
    public:
        FunctorPythonBase(const TPyObjPtr& callable): callable_(callable) {}
        bool operator==(const FunctorPythonBase& other) const
        {
            return callable_.get() == other.callable_.get();
        }
        bool operator!() const
        {
            return !callable_;
        }
        const TPyObjPtr& callable() const
        {
            return callable_;
        }
    protected:
        void call(const TPyObjPtr& args) const
        {
            LockGIL lock;
            LASS_ASSERT(callable_);
            const TPyObjPtr result(PyObject_CallObject(callable_.get(), args.get()));
            if (!result)
            {
                fetchAndThrowPythonException(LASS_PRETTY_FUNCTION);
            }
        }
    private:
        TPyObjPtr callable_;
    };
 
    /** Common implementation of a dispatcher to an python callback with non-void return type.
     *  @internal
     *  @author Bramz
     */
    template <typename R>
    class FunctorPythonRBase
    {
    public:
        FunctorPythonRBase(const TPyObjPtr& callable): callable_(callable) {}
        bool operator==(const FunctorPythonRBase<R>& other) const
        {
            return callable_.get() == other.callable_.get();
        }
        bool operator!() const
        {
            return !callable_;
        }
        const TPyObjPtr& callable() const
        {
            return callable_;
        }
    protected:
        R call(const TPyObjPtr& args) const
        {
            static_assert(!std::is_reference_v<R> && !std::is_pointer_v<R>, "Python callbacks must return by value, not by reference or pointer");
            LockGIL lock;
            LASS_ASSERT(callable_);
            const TPyObjPtr result(PyObject_CallObject(callable_.get(), args.get()));
            if (!result)
            {
                fetchAndThrowPythonException(LASS_PRETTY_FUNCTION);
            }
            typedef ArgumentTraits<R> TraitsR;
            typename TraitsR::TStorage temp;
            if (pyGetSimpleObject(result.get(), temp) != 0)
            {
                fetchAndThrowPythonException(LASS_PRETTY_FUNCTION);
            }
            return TraitsR::arg(temp);
        }
    private:
        TPyObjPtr callable_;
    };
 
    class PyCallbackImplBase
    {
    public:
        virtual ~PyCallbackImplBase() = default;
        virtual PyObject* call(PyObject* args) const = 0;
    };
 
    class LASS_PYTHON_DLL PyCallback: public PyObjectPlus
    {
        PY_HEADER(PyObjectPlus)
    public:
        using TPimpl = std::unique_ptr<PyCallbackImplBase>;
 
        PyCallback(TPimpl impl);
 
        template <typename PyCallbackImplType>
        bool get(typename PyCallbackImplType::TCallback& v) const
        {
            PyCallbackImplBase* p = pimpl_.get();
            if (p && typeid(*p) == typeid(PyCallbackImplType))
            {
                v = static_cast<PyCallbackImplType*>(p)->callable();
                return true;
            }
            return false;
        }
 
        static PyObject* _tp_call(PyObject* self, PyObject* args, PyObject* kwargs);
    private:
        TPimpl pimpl_;
    };
}
 
/** Helper class to implement PyExportTraits for Callback types
 * 
 *  Only the `get()` method is implemented, which allows you to use callbacks as
 *  C++ function parameters, but not als return values. Returning a callback from C++
 *  to Python is not supported.
 * 
 *  For full bidirectional support, use std::function instead.
 *
 *  @ingroup PyExportTraits
 */
template <typename CallbackType, typename PyCallbackImplType, typename ExportTraits>
struct PyExportTraitsCallback
{
    static int get(PyObject* value, CallbackType& callback)
    {
        if (value == Py_None)
        {
            callback.reset();
            return 0;
        }
        impl::initLassModule(); // ensure the module is initialized
        if (PyType_IsSubtype(Py_TYPE(value), impl::PyCallback::_lassPyClassDef.type()))
        {
            if (static_cast<impl::PyCallback*>(value)->get<PyCallbackImplType>(callback))
            {
                return 0;
            }
        }
        TPyObjPtr callable;
        if (pyGetSimpleObject(value, callable) != 0)
        {
            impl::addMessageHeader(ExportTraits::className());
            return 1;
        }
        if (!callable) // null pointer
        {
            callback.reset();
            return 0;
        }
        if (!PyCallable_Check(callable.get()))
        {
            std::ostringstream buffer;
            buffer << ExportTraits::className() << ": not callable";
            PyErr_SetString(PyExc_TypeError, buffer.str().c_str());
            return 1;
        }
        using TFunctor = typename PyCallbackImplType::TFunctor;
        callback = TFunctor(callable);
        return 0;
    }
    static PyObject* build(const CallbackType& callback)
    {
        if (!callback)
        {
            Py_RETURN_NONE;
        }
 
        using TDispatcher = typename PyCallbackImplType::TDispatcher;
        auto dispatcher = callback.dispatcher().get();
        if (dispatcher && typeid(*dispatcher) == typeid(TDispatcher))
        {
            // already a FunctorType, return the original callable
            return fromSharedPtrToNakedCast(static_cast<TDispatcher*>(dispatcher)->function().callable());
        }
        // wrap in a PyCallback object
        impl::PyCallback::TPimpl pimpl(new PyCallbackImplType(callback));
        return new impl::PyCallback(std::move(pimpl));
    }
};
 
}
}
 
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_0)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_0
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_0
 
namespace lass
{
namespace python
{
namespace impl
{
    class Functor0Python: public FunctorPythonBase
    {
    public:
        Functor0Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()() const
        {
            LockGIL lock;
            this->call(python::TPyObjPtr());
        }
    };
 
    class PyCallback0Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback0;
        using TFunctor = Functor0Python;
        using TDispatcher = util::impl::Dispatcher0Function<TFunctor>;
 
        PyCallback0Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            if ( decodeTuple(args) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::callFunction<const TCallback&>(callback_);
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback0 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback0 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback0 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback0 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback0, *and* this util::Callback0 matches the correct signature, then
 *  the util::Callback0 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback0 will be wrapped in a new util::Callback0 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <>
struct PyExportTraits< util::Callback0 >:
    public PyExportTraitsCallback<
        util::Callback0,
        impl::PyCallback0Impl,
        PyExportTraits< util::Callback0 >
    >
{
    static constexpr const char* py_typing = "Callable[[], None]";
 
    static const char* className() { return "Callback0"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_1)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_1
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_1
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1>
    class Functor1Python: public FunctorPythonBase
    {
    public:
        Functor1Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1) const
        {
            LockGIL lock;
            this->call(makeTuple(p1));
        }
    };
 
    template <typename P1>
    class PyCallback1Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback1<P1>;
        using TFunctor = Functor1Python<P1>;
        using TDispatcher = util::impl::Dispatcher1Function<P1, TFunctor>;
 
        PyCallback1Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            
            if ( decodeTuple<S1>(args, p1) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback1 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback1 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback1 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback1 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback1, *and* this util::Callback1 matches the correct signature, then
 *  the util::Callback1 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback1 will be wrapped in a new util::Callback1 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1>
struct PyExportTraits< util::Callback1<P1> >:
    public PyExportTraitsCallback<
        util::Callback1<P1>,
        impl::PyCallback1Impl<P1>,
        PyExportTraits< util::Callback1<P1> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!], None]";
 
    static const char* className() { return "Callback1"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_2)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_2
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_2
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2>
    class Functor2Python: public FunctorPythonBase
    {
    public:
        Functor2Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2));
        }
    };
 
    template <typename P1, typename P2>
    class PyCallback2Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback2<P1, P2>;
        using TFunctor = Functor2Python<P1, P2>;
        using TDispatcher = util::impl::Dispatcher2Function<P1, P2, TFunctor>;
 
        PyCallback2Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            
            if ( decodeTuple<S1, S2>(args, p1, p2) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback2 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback2 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback2 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback2 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback2, *and* this util::Callback2 matches the correct signature, then
 *  the util::Callback2 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback2 will be wrapped in a new util::Callback2 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2>
struct PyExportTraits< util::Callback2<P1, P2> >:
    public PyExportTraitsCallback<
        util::Callback2<P1, P2>,
        impl::PyCallback2Impl<P1, P2>,
        PyExportTraits< util::Callback2<P1, P2> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!], None]";
 
    static const char* className() { return "Callback2"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_3)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_3
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_3
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3>
    class Functor3Python: public FunctorPythonBase
    {
    public:
        Functor3Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3));
        }
    };
 
    template <typename P1, typename P2, typename P3>
    class PyCallback3Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback3<P1, P2, P3>;
        using TFunctor = Functor3Python<P1, P2, P3>;
        using TDispatcher = util::impl::Dispatcher3Function<P1, P2, P3, TFunctor>;
 
        PyCallback3Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            
            if ( decodeTuple<S1, S2, S3>(args, p1, p2, p3) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback3 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback3 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback3 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback3 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback3, *and* this util::Callback3 matches the correct signature, then
 *  the util::Callback3 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback3 will be wrapped in a new util::Callback3 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3>
struct PyExportTraits< util::Callback3<P1, P2, P3> >:
    public PyExportTraitsCallback<
        util::Callback3<P1, P2, P3>,
        impl::PyCallback3Impl<P1, P2, P3>,
        PyExportTraits< util::Callback3<P1, P2, P3> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!], None]";
 
    static const char* className() { return "Callback3"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_4)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_4
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_4
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4>
    class Functor4Python: public FunctorPythonBase
    {
    public:
        Functor4Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4>
    class PyCallback4Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback4<P1, P2, P3, P4>;
        using TFunctor = Functor4Python<P1, P2, P3, P4>;
        using TDispatcher = util::impl::Dispatcher4Function<P1, P2, P3, P4, TFunctor>;
 
        PyCallback4Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            
            if ( decodeTuple<S1, S2, S3, S4>(args, p1, p2, p3, p4) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback4 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback4 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback4 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback4 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback4, *and* this util::Callback4 matches the correct signature, then
 *  the util::Callback4 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback4 will be wrapped in a new util::Callback4 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4>
struct PyExportTraits< util::Callback4<P1, P2, P3, P4> >:
    public PyExportTraitsCallback<
        util::Callback4<P1, P2, P3, P4>,
        impl::PyCallback4Impl<P1, P2, P3, P4>,
        PyExportTraits< util::Callback4<P1, P2, P3, P4> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!], None]";
 
    static const char* className() { return "Callback4"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_5)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_5
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_5
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5>
    class Functor5Python: public FunctorPythonBase
    {
    public:
        Functor5Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5>
    class PyCallback5Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback5<P1, P2, P3, P4, P5>;
        using TFunctor = Functor5Python<P1, P2, P3, P4, P5>;
        using TDispatcher = util::impl::Dispatcher5Function<P1, P2, P3, P4, P5, TFunctor>;
 
        PyCallback5Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            
            if ( decodeTuple<S1, S2, S3, S4, S5>(args, p1, p2, p3, p4, p5) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback5 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback5 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback5 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback5 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback5, *and* this util::Callback5 matches the correct signature, then
 *  the util::Callback5 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback5 will be wrapped in a new util::Callback5 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5>
struct PyExportTraits< util::Callback5<P1, P2, P3, P4, P5> >:
    public PyExportTraitsCallback<
        util::Callback5<P1, P2, P3, P4, P5>,
        impl::PyCallback5Impl<P1, P2, P3, P4, P5>,
        PyExportTraits< util::Callback5<P1, P2, P3, P4, P5> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!], None]";
 
    static const char* className() { return "Callback5"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_6)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_6
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_6
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    class Functor6Python: public FunctorPythonBase
    {
    public:
        Functor6Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    class PyCallback6Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback6<P1, P2, P3, P4, P5, P6>;
        using TFunctor = Functor6Python<P1, P2, P3, P4, P5, P6>;
        using TDispatcher = util::impl::Dispatcher6Function<P1, P2, P3, P4, P5, P6, TFunctor>;
 
        PyCallback6Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6>(args, p1, p2, p3, p4, p5, p6) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback6 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback6 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback6 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback6 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback6, *and* this util::Callback6 matches the correct signature, then
 *  the util::Callback6 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback6 will be wrapped in a new util::Callback6 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
struct PyExportTraits< util::Callback6<P1, P2, P3, P4, P5, P6> >:
    public PyExportTraitsCallback<
        util::Callback6<P1, P2, P3, P4, P5, P6>,
        impl::PyCallback6Impl<P1, P2, P3, P4, P5, P6>,
        PyExportTraits< util::Callback6<P1, P2, P3, P4, P5, P6> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!], None]";
 
    static const char* className() { return "Callback6"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_7)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_7
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_7
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    class Functor7Python: public FunctorPythonBase
    {
    public:
        Functor7Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    class PyCallback7Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback7<P1, P2, P3, P4, P5, P6, P7>;
        using TFunctor = Functor7Python<P1, P2, P3, P4, P5, P6, P7>;
        using TDispatcher = util::impl::Dispatcher7Function<P1, P2, P3, P4, P5, P6, P7, TFunctor>;
 
        PyCallback7Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7>(args, p1, p2, p3, p4, p5, p6, p7) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback7 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback7 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback7 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback7 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback7, *and* this util::Callback7 matches the correct signature, then
 *  the util::Callback7 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback7 will be wrapped in a new util::Callback7 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
struct PyExportTraits< util::Callback7<P1, P2, P3, P4, P5, P6, P7> >:
    public PyExportTraitsCallback<
        util::Callback7<P1, P2, P3, P4, P5, P6, P7>,
        impl::PyCallback7Impl<P1, P2, P3, P4, P5, P6, P7>,
        PyExportTraits< util::Callback7<P1, P2, P3, P4, P5, P6, P7> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!], None]";
 
    static const char* className() { return "Callback7"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_8)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_8
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_8
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    class Functor8Python: public FunctorPythonBase
    {
    public:
        Functor8Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    class PyCallback8Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback8<P1, P2, P3, P4, P5, P6, P7, P8>;
        using TFunctor = Functor8Python<P1, P2, P3, P4, P5, P6, P7, P8>;
        using TDispatcher = util::impl::Dispatcher8Function<P1, P2, P3, P4, P5, P6, P7, P8, TFunctor>;
 
        PyCallback8Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>(args, p1, p2, p3, p4, p5, p6, p7, p8) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback8 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback8 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback8 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback8 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback8, *and* this util::Callback8 matches the correct signature, then
 *  the util::Callback8 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback8 will be wrapped in a new util::Callback8 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
struct PyExportTraits< util::Callback8<P1, P2, P3, P4, P5, P6, P7, P8> >:
    public PyExportTraitsCallback<
        util::Callback8<P1, P2, P3, P4, P5, P6, P7, P8>,
        impl::PyCallback8Impl<P1, P2, P3, P4, P5, P6, P7, P8>,
        PyExportTraits< util::Callback8<P1, P2, P3, P4, P5, P6, P7, P8> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!], None]";
 
    static const char* className() { return "Callback8"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_9)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_9
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_9
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    class Functor9Python: public FunctorPythonBase
    {
    public:
        Functor9Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    class PyCallback9Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9>;
        using TFunctor = Functor9Python<P1, P2, P3, P4, P5, P6, P7, P8, P9>;
        using TDispatcher = util::impl::Dispatcher9Function<P1, P2, P3, P4, P5, P6, P7, P8, P9, TFunctor>;
 
        PyCallback9Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback9 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback9 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback9 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback9 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback9, *and* this util::Callback9 matches the correct signature, then
 *  the util::Callback9 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback9 will be wrapped in a new util::Callback9 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
struct PyExportTraits< util::Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9> >:
    public PyExportTraitsCallback<
        util::Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9>,
        impl::PyCallback9Impl<P1, P2, P3, P4, P5, P6, P7, P8, P9>,
        PyExportTraits< util::Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!], None]";
 
    static const char* className() { return "Callback9"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_10)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_10
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_10
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    class Functor10Python: public FunctorPythonBase
    {
    public:
        Functor10Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    class PyCallback10Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>;
        using TFunctor = Functor10Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>;
        using TDispatcher = util::impl::Dispatcher10Function<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, TFunctor>;
 
        PyCallback10Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback10 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback10 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback10 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback10 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback10, *and* this util::Callback10 matches the correct signature, then
 *  the util::Callback10 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback10 will be wrapped in a new util::Callback10 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
struct PyExportTraits< util::Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >:
    public PyExportTraitsCallback<
        util::Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>,
        impl::PyCallback10Impl<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>,
        PyExportTraits< util::Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!], None]";
 
    static const char* className() { return "Callback10"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_11)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_11
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_11
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    class Functor11Python: public FunctorPythonBase
    {
    public:
        Functor11Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    class PyCallback11Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>;
        using TFunctor = Functor11Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>;
        using TDispatcher = util::impl::Dispatcher11Function<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, TFunctor>;
 
        PyCallback11Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback11 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback11 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback11 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback11 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback11, *and* this util::Callback11 matches the correct signature, then
 *  the util::Callback11 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback11 will be wrapped in a new util::Callback11 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
struct PyExportTraits< util::Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >:
    public PyExportTraitsCallback<
        util::Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>,
        impl::PyCallback11Impl<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>,
        PyExportTraits< util::Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!], None]";
 
    static const char* className() { return "Callback11"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_12)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_12
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_12
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
    class Functor12Python: public FunctorPythonBase
    {
    public:
        Functor12Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
    class PyCallback12Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>;
        using TFunctor = Functor12Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>;
        using TDispatcher = util::impl::Dispatcher12Function<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, TFunctor>;
 
        PyCallback12Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback12 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback12 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback12 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback12 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback12, *and* this util::Callback12 matches the correct signature, then
 *  the util::Callback12 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback12 will be wrapped in a new util::Callback12 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
struct PyExportTraits< util::Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >:
    public PyExportTraitsCallback<
        util::Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>,
        impl::PyCallback12Impl<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>,
        PyExportTraits< util::Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!, P12!], None]";
 
    static const char* className() { return "Callback12"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_13)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_13
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_13
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
    class Functor13Python: public FunctorPythonBase
    {
    public:
        Functor13Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
    class PyCallback13Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>;
        using TFunctor = Functor13Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>;
        using TDispatcher = util::impl::Dispatcher13Function<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, TFunctor>;
 
        PyCallback13Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
            typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback13 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback13 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback13 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback13 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback13, *and* this util::Callback13 matches the correct signature, then
 *  the util::Callback13 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback13 will be wrapped in a new util::Callback13 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
struct PyExportTraits< util::Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >:
    public PyExportTraitsCallback<
        util::Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>,
        impl::PyCallback13Impl<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>,
        PyExportTraits< util::Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!, P12!, P13!], None]";
 
    static const char* className() { return "Callback13"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_14)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_14
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_14
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
    class Functor14Python: public FunctorPythonBase
    {
    public:
        Functor14Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13, typename util::CallTraits<P14>::TParam p14) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
    class PyCallback14Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>;
        using TFunctor = Functor14Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>;
        using TDispatcher = util::impl::Dispatcher14Function<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, TFunctor>;
 
        PyCallback14Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
            typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
            typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback14 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback14 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback14 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback14 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback14, *and* this util::Callback14 matches the correct signature, then
 *  the util::Callback14 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback14 will be wrapped in a new util::Callback14 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
struct PyExportTraits< util::Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >:
    public PyExportTraitsCallback<
        util::Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>,
        impl::PyCallback14Impl<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>,
        PyExportTraits< util::Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!, P12!, P13!, P14!], None]";
 
    static const char* className() { return "Callback14"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_15)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_15
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_15
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
    class Functor15Python: public FunctorPythonBase
    {
    public:
        Functor15Python(const TPyObjPtr& callable): FunctorPythonBase(callable) {}
        void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13, typename util::CallTraits<P14>::TParam p14, typename util::CallTraits<P15>::TParam p15) const
        {
            LockGIL lock;
            this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15));
        }
    };
 
    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
    class PyCallback15Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>;
        using TFunctor = Functor15Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>;
        using TDispatcher = util::impl::Dispatcher15Function<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, TFunctor>;
 
        PyCallback15Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
            typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
            typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
            typedef ArgumentTraits<P15> TArg15; typedef typename TArg15::TStorage S15; S15 p15 = S15();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) != 0 )
            {
                return nullptr;
            }
            return Caller<void>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15));
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::Callback15 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::Callback15 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::Callback15 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::Callback15 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::Callback15, *and* this util::Callback15 matches the correct signature, then
 *  the util::Callback15 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::Callback15 will be wrapped in a new util::Callback15 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct PyExportTraits< util::Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >:
    public PyExportTraitsCallback<
        util::Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>,
        impl::PyCallback15Impl<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>,
        PyExportTraits< util::Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!, P12!, P13!, P14!, P15!], None]";
 
    static const char* className() { return "Callback15"; }
};
 
}
}
 
#   endif
#endif
 
 
 
 
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R0)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R0
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R0
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R>
    class FunctorPythonR0: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR0(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()() const
        {
            LockGIL lock;
            return this->call(TPyObjPtr());
        }
    };
 
    template <typename R>
    class PyCallbackR0Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR0<R>;
        using TFunctor = FunctorPythonR0<R>;
        using TDispatcher = util::impl::DispatcherR0Function<R, TFunctor>;
 
        PyCallbackR0Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            if ( decodeTuple(args) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_);
        }
    private:
        TCallback callback_;
    };
}
 
/** Bidirectional mapping between util::CallbackR0 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR0 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR0 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR0 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR0, *and* this util::CallbackR0 matches the correct signature, then
 *  the util::CallbackR0 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR0 will be wrapped in a new util::CallbackR0 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R>
struct PyExportTraits< util::CallbackR0<R> >:
    public PyExportTraitsCallback<
        util::CallbackR0<R>,
        impl::PyCallbackR0Impl<R>,
        PyExportTraits< util::CallbackR0<R> >
    >
{
    static constexpr const char* py_typing = "Callable[[], R!]";
    
    static const char* className() { return "CallbackR0"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R1)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R1
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R1
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1>
    class FunctorPythonR1: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR1(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1));
        }
    };
 
    template <typename R, typename P1>
    class PyCallbackR1Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR1<R, P1>;
        using TFunctor = FunctorPythonR1<R, P1>;
        using TDispatcher = util::impl::DispatcherR1Function<R, P1, TFunctor>;
 
        PyCallbackR1Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            
            if ( decodeTuple<S1>(args, p1) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR1 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR1 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR1 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR1 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR1, *and* this util::CallbackR1 matches the correct signature, then
 *  the util::CallbackR1 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR1 will be wrapped in a new util::CallbackR1 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1>
struct PyExportTraits< util::CallbackR1<R, P1> >:
    public PyExportTraitsCallback<
        util::CallbackR1<R, P1>,
        impl::PyCallbackR1Impl<R, P1>,
        PyExportTraits< util::CallbackR1<R, P1> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!], R!]";
    
    static const char* className() { return "CallbackR1"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R2)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R2
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R2
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2>
    class FunctorPythonR2: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR2(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2));
        }
    };
 
    template <typename R, typename P1, typename P2>
    class PyCallbackR2Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR2<R, P1, P2>;
        using TFunctor = FunctorPythonR2<R, P1, P2>;
        using TDispatcher = util::impl::DispatcherR2Function<R, P1, P2, TFunctor>;
 
        PyCallbackR2Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            
            if ( decodeTuple<S1, S2>(args, p1, p2) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR2 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR2 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR2 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR2 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR2, *and* this util::CallbackR2 matches the correct signature, then
 *  the util::CallbackR2 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR2 will be wrapped in a new util::CallbackR2 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2>
struct PyExportTraits< util::CallbackR2<R, P1, P2> >:
    public PyExportTraitsCallback<
        util::CallbackR2<R, P1, P2>,
        impl::PyCallbackR2Impl<R, P1, P2>,
        PyExportTraits< util::CallbackR2<R, P1, P2> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!], R!]";
    
    static const char* className() { return "CallbackR2"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R3)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R3
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R3
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3>
    class FunctorPythonR3: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR3(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3>
    class PyCallbackR3Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR3<R, P1, P2, P3>;
        using TFunctor = FunctorPythonR3<R, P1, P2, P3>;
        using TDispatcher = util::impl::DispatcherR3Function<R, P1, P2, P3, TFunctor>;
 
        PyCallbackR3Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            
            if ( decodeTuple<S1, S2, S3>(args, p1, p2, p3) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR3 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR3 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR3 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR3 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR3, *and* this util::CallbackR3 matches the correct signature, then
 *  the util::CallbackR3 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR3 will be wrapped in a new util::CallbackR3 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3>
struct PyExportTraits< util::CallbackR3<R, P1, P2, P3> >:
    public PyExportTraitsCallback<
        util::CallbackR3<R, P1, P2, P3>,
        impl::PyCallbackR3Impl<R, P1, P2, P3>,
        PyExportTraits< util::CallbackR3<R, P1, P2, P3> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!], R!]";
    
    static const char* className() { return "CallbackR3"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R4)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R4
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R4
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4>
    class FunctorPythonR4: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR4(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4>
    class PyCallbackR4Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR4<R, P1, P2, P3, P4>;
        using TFunctor = FunctorPythonR4<R, P1, P2, P3, P4>;
        using TDispatcher = util::impl::DispatcherR4Function<R, P1, P2, P3, P4, TFunctor>;
 
        PyCallbackR4Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            
            if ( decodeTuple<S1, S2, S3, S4>(args, p1, p2, p3, p4) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR4 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR4 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR4 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR4 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR4, *and* this util::CallbackR4 matches the correct signature, then
 *  the util::CallbackR4 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR4 will be wrapped in a new util::CallbackR4 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4>
struct PyExportTraits< util::CallbackR4<R, P1, P2, P3, P4> >:
    public PyExportTraitsCallback<
        util::CallbackR4<R, P1, P2, P3, P4>,
        impl::PyCallbackR4Impl<R, P1, P2, P3, P4>,
        PyExportTraits< util::CallbackR4<R, P1, P2, P3, P4> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!], R!]";
    
    static const char* className() { return "CallbackR4"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R5)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R5
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R5
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    class FunctorPythonR5: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR5(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    class PyCallbackR5Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR5<R, P1, P2, P3, P4, P5>;
        using TFunctor = FunctorPythonR5<R, P1, P2, P3, P4, P5>;
        using TDispatcher = util::impl::DispatcherR5Function<R, P1, P2, P3, P4, P5, TFunctor>;
 
        PyCallbackR5Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            
            if ( decodeTuple<S1, S2, S3, S4, S5>(args, p1, p2, p3, p4, p5) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR5 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR5 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR5 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR5 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR5, *and* this util::CallbackR5 matches the correct signature, then
 *  the util::CallbackR5 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR5 will be wrapped in a new util::CallbackR5 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
struct PyExportTraits< util::CallbackR5<R, P1, P2, P3, P4, P5> >:
    public PyExportTraitsCallback<
        util::CallbackR5<R, P1, P2, P3, P4, P5>,
        impl::PyCallbackR5Impl<R, P1, P2, P3, P4, P5>,
        PyExportTraits< util::CallbackR5<R, P1, P2, P3, P4, P5> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!], R!]";
    
    static const char* className() { return "CallbackR5"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R6)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R6
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R6
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    class FunctorPythonR6: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR6(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    class PyCallbackR6Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR6<R, P1, P2, P3, P4, P5, P6>;
        using TFunctor = FunctorPythonR6<R, P1, P2, P3, P4, P5, P6>;
        using TDispatcher = util::impl::DispatcherR6Function<R, P1, P2, P3, P4, P5, P6, TFunctor>;
 
        PyCallbackR6Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6>(args, p1, p2, p3, p4, p5, p6) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR6 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR6 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR6 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR6 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR6, *and* this util::CallbackR6 matches the correct signature, then
 *  the util::CallbackR6 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR6 will be wrapped in a new util::CallbackR6 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
struct PyExportTraits< util::CallbackR6<R, P1, P2, P3, P4, P5, P6> >:
    public PyExportTraitsCallback<
        util::CallbackR6<R, P1, P2, P3, P4, P5, P6>,
        impl::PyCallbackR6Impl<R, P1, P2, P3, P4, P5, P6>,
        PyExportTraits< util::CallbackR6<R, P1, P2, P3, P4, P5, P6> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!], R!]";
    
    static const char* className() { return "CallbackR6"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R7)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R7
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R7
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    class FunctorPythonR7: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR7(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    class PyCallbackR7Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR7<R, P1, P2, P3, P4, P5, P6, P7>;
        using TFunctor = FunctorPythonR7<R, P1, P2, P3, P4, P5, P6, P7>;
        using TDispatcher = util::impl::DispatcherR7Function<R, P1, P2, P3, P4, P5, P6, P7, TFunctor>;
 
        PyCallbackR7Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7>(args, p1, p2, p3, p4, p5, p6, p7) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR7 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR7 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR7 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR7 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR7, *and* this util::CallbackR7 matches the correct signature, then
 *  the util::CallbackR7 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR7 will be wrapped in a new util::CallbackR7 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
struct PyExportTraits< util::CallbackR7<R, P1, P2, P3, P4, P5, P6, P7> >:
    public PyExportTraitsCallback<
        util::CallbackR7<R, P1, P2, P3, P4, P5, P6, P7>,
        impl::PyCallbackR7Impl<R, P1, P2, P3, P4, P5, P6, P7>,
        PyExportTraits< util::CallbackR7<R, P1, P2, P3, P4, P5, P6, P7> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!], R!]";
    
    static const char* className() { return "CallbackR7"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R8)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R8
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R8
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    class FunctorPythonR8: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR8(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    class PyCallbackR8Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8>;
        using TFunctor = FunctorPythonR8<R, P1, P2, P3, P4, P5, P6, P7, P8>;
        using TDispatcher = util::impl::DispatcherR8Function<R, P1, P2, P3, P4, P5, P6, P7, P8, TFunctor>;
 
        PyCallbackR8Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>(args, p1, p2, p3, p4, p5, p6, p7, p8) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR8 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR8 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR8 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR8 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR8, *and* this util::CallbackR8 matches the correct signature, then
 *  the util::CallbackR8 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR8 will be wrapped in a new util::CallbackR8 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
struct PyExportTraits< util::CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8> >:
    public PyExportTraitsCallback<
        util::CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8>,
        impl::PyCallbackR8Impl<R, P1, P2, P3, P4, P5, P6, P7, P8>,
        PyExportTraits< util::CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!], R!]";
    
    static const char* className() { return "CallbackR8"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R9)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R9
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R9
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    class FunctorPythonR9: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR9(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    class PyCallbackR9Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9>;
        using TFunctor = FunctorPythonR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9>;
        using TDispatcher = util::impl::DispatcherR9Function<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, TFunctor>;
 
        PyCallbackR9Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR9 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR9 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR9 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR9 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR9, *and* this util::CallbackR9 matches the correct signature, then
 *  the util::CallbackR9 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR9 will be wrapped in a new util::CallbackR9 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
struct PyExportTraits< util::CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9> >:
    public PyExportTraitsCallback<
        util::CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9>,
        impl::PyCallbackR9Impl<R, P1, P2, P3, P4, P5, P6, P7, P8, P9>,
        PyExportTraits< util::CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!], R!]";
    
    static const char* className() { return "CallbackR9"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R10)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R10
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R10
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    class FunctorPythonR10: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR10(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    class PyCallbackR10Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>;
        using TFunctor = FunctorPythonR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>;
        using TDispatcher = util::impl::DispatcherR10Function<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, TFunctor>;
 
        PyCallbackR10Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR10 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR10 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR10 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR10 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR10, *and* this util::CallbackR10 matches the correct signature, then
 *  the util::CallbackR10 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR10 will be wrapped in a new util::CallbackR10 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
struct PyExportTraits< util::CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >:
    public PyExportTraitsCallback<
        util::CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>,
        impl::PyCallbackR10Impl<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>,
        PyExportTraits< util::CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!], R!]";
    
    static const char* className() { return "CallbackR10"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R11)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R11
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R11
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    class FunctorPythonR11: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR11(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    class PyCallbackR11Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>;
        using TFunctor = FunctorPythonR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>;
        using TDispatcher = util::impl::DispatcherR11Function<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, TFunctor>;
 
        PyCallbackR11Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR11 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR11 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR11 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR11 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR11, *and* this util::CallbackR11 matches the correct signature, then
 *  the util::CallbackR11 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR11 will be wrapped in a new util::CallbackR11 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
struct PyExportTraits< util::CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >:
    public PyExportTraitsCallback<
        util::CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>,
        impl::PyCallbackR11Impl<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>,
        PyExportTraits< util::CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!], R!]";
    
    static const char* className() { return "CallbackR11"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R12)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R12
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R12
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
    class FunctorPythonR12: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR12(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
    class PyCallbackR12Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>;
        using TFunctor = FunctorPythonR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>;
        using TDispatcher = util::impl::DispatcherR12Function<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, TFunctor>;
 
        PyCallbackR12Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR12 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR12 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR12 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR12 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR12, *and* this util::CallbackR12 matches the correct signature, then
 *  the util::CallbackR12 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR12 will be wrapped in a new util::CallbackR12 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
struct PyExportTraits< util::CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >:
    public PyExportTraitsCallback<
        util::CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>,
        impl::PyCallbackR12Impl<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>,
        PyExportTraits< util::CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!, P12!], R!]";
    
    static const char* className() { return "CallbackR12"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R13)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R13
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R13
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
    class FunctorPythonR13: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR13(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
    class PyCallbackR13Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>;
        using TFunctor = FunctorPythonR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>;
        using TDispatcher = util::impl::DispatcherR13Function<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, TFunctor>;
 
        PyCallbackR13Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
            typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR13 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR13 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR13 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR13 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR13, *and* this util::CallbackR13 matches the correct signature, then
 *  the util::CallbackR13 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR13 will be wrapped in a new util::CallbackR13 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13>
struct PyExportTraits< util::CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >:
    public PyExportTraitsCallback<
        util::CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>,
        impl::PyCallbackR13Impl<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>,
        PyExportTraits< util::CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!, P12!, P13!], R!]";
    
    static const char* className() { return "CallbackR13"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R14)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R14
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R14
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
    class FunctorPythonR14: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR14(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13, typename util::CallTraits<P14>::TParam p14) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
    class PyCallbackR14Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>;
        using TFunctor = FunctorPythonR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>;
        using TDispatcher = util::impl::DispatcherR14Function<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, TFunctor>;
 
        PyCallbackR14Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
            typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
            typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR14 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR14 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR14 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR14 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR14, *and* this util::CallbackR14 matches the correct signature, then
 *  the util::CallbackR14 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR14 will be wrapped in a new util::CallbackR14 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14>
struct PyExportTraits< util::CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >:
    public PyExportTraitsCallback<
        util::CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>,
        impl::PyCallbackR14Impl<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>,
        PyExportTraits< util::CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!, P12!, P13!, P14!], R!]";
    
    static const char* className() { return "CallbackR14"; }
};
 
}
}
 
#   endif
#endif
 
#if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R15)
#   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R15
#   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R15
 
namespace lass
{
namespace python
{
namespace impl
{
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
    class FunctorPythonR15: public FunctorPythonRBase<R>
    {
    public:
        FunctorPythonR15(const TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
        R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13, typename util::CallTraits<P14>::TParam p14, typename util::CallTraits<P15>::TParam p15) const
        {
            LockGIL lock;
            return this->call(makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15));
        }
    };
 
    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
    class PyCallbackR15Impl: public PyCallbackImplBase
    {
    public:
        using TCallback = util::CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>;
        using TFunctor = FunctorPythonR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>;
        using TDispatcher = util::impl::DispatcherR15Function<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, TFunctor>;
 
        PyCallbackR15Impl(TCallback callback): callback_(std::move(callback)) {}
        const TCallback& callable() const { return callback_; }
        
        PyObject* call(PyObject* args) const override
        {
            typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
            typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
            typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
            typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
            typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
            typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
            typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
            typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
            typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
            typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
            typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
            typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
            typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
            typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
            typedef ArgumentTraits<P15> TArg15; typedef typename TArg15::TStorage S15; S15 p15 = S15();
            
            if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) != 0 )
            {
                return nullptr;
            }
            return Caller<R>::template callFunction<const TCallback&>(callback_, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15));
        }
    private:
        TCallback callback_;
    };
 
}
 
/** Bidirectional mapping between util::CallbackR15 and a Python callable object
 *
 *  Accepts Callable objects and wraps them in a util::CallbackR15 without checking the
 *  parameter types or return type, allowing to call them from C++. The parameters
 *  and return type are only checked when the function is called, and an exception will
 *  be raised if the types do not match.
 *
 *  From C++ to Python, the util::CallbackR15 is converted to a Callable object, so that
 *  it can be called from Python. Again, the parameter types and return type will be
 *  checked when the function is called.
 *
 *  In both directions, unwrapping a previously wrapped function will be attempted.
 *  I.e. if the util::CallbackR15 passed to Python already wraps a Callable Python
 *  object, this will be unwrapped and the Callable object will be passed back to Python.
 *  In the other direction, if a Callable object that was passed to C++ already wraps a
 *  util::CallbackR15, *and* this util::CallbackR15 matches the correct signature, then
 *  the util::CallbackR15 will be unwrapped and passed to C++. In other words, both
 *  directions will guarantee a perfect round trip if possible. In all other cases, the
 *  Callable or util::CallbackR15 will be wrapped in a new util::CallbackR15 or Callable
 *  object.
 *
 *  @ingroup PyExportTraits
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15>
struct PyExportTraits< util::CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >:
    public PyExportTraitsCallback<
        util::CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>,
        impl::PyCallbackR15Impl<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>,
        PyExportTraits< util::CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >
    >
{
    static constexpr const char* py_typing = "Callable[[P1!, P2!, P3!, P4!, P5!, P6!, P7!, P8!, P9!, P10!, P11!, P12!, P13!, P14!, P15!], R!]";
    
    static const char* className() { return "CallbackR15"; }
};
 
}
}
 
#   endif
#endif
 
 
// EOF