/*

** Copyright (C) 2020 SoftBank Robotics Europe

** See COPYING for the license

*/

#include <utility>

#include <tuple>

#include <iterator>

#include <qi/type/typedispatcher.hpp>

#include <qi/type/typeinterface.hpp>

#include <qi/numeric.hpp>

#include <qi/assert.hpp>

#include <qipython/common.hpp>

#include <qipython/pyguard.hpp>

#include <qipython/pytypes.hpp>

#include <qipython/pyfuture.hpp>

#include <qipython/pyobject.hpp>

#include <pybind11/pybind11.h>

#include <boost/thread/synchronized_value.hpp>

namespace py = pybind11;

namespace qi

{

namespace py

{

namespace

{

template<typename T>

boost::optional<::py::object> tryToCastObjectTo(ObjectTypeInterface* type,

void* ptr)

{

if (type != typeOf<T>())

return {};

return castToPyObject(reinterpret_cast<T*>(ptr), ::py::return_value_policy::copy);

}

struct ValueToPyObject

{

// @pre: The GIL is locked.

ValueToPyObject(::py::object& result)

: result(result)

{

}

void visitUnknown(AnyReference value)

{

GILAcquire lock;

// Encapsulate the value in Capsule.

result = ::py::capsule(value.rawValue());

}

void visitVoid()

{

GILAcquire lock;

result = ::py::none();

}

void visitInt(int64_t value, bool isSigned, int byteSize)

{

GILAcquire lock;

// byteSize is 0 when the value is a boolean.

if (byteSize == 0)

result = ::py::bool_(static_cast<bool>(value));

else

result = isSigned ? ::py::int_(value)

: ::py::int_(static_cast<std::uint64_t>(value));

}

void visitFloat(double value, int /*byteSize*/)

{

GILAcquire lock;

result = ::py::float_(value);

}

void visitString(char* data, size_t len)

{

GILAcquire lock;

if (!data)

{

result = ::py::str("");

return;

}

// Python strings are Unicode, and trying to construct one with a characters

// sequence that is not valid UTF-8 data results in an exception in

// pybind11. So if we can't create a Python `string` due to an exception, we

// try to create a Python `bytes` instead.

const auto toUnicode = [&] {

const auto obj = ::py::reinterpret_steal<::py::str>(

PyUnicode_FromStringAndSize(data, static_cast<ssize_t>(len)));

// When it fails, the conversion may set a Python error. We need to handle

// it by throwing `error_already_set`.

if (!obj)

{

if (PyErr_Occurred())

throw ::py::error_already_set();

else

throw std::runtime_error("failed to construct a Python string from data");

}

return obj;

};

const auto toBytes = [&] { return ::py::bytes(data, len); };

using namespace ka::functional_ops;

const auto thenToBytes = ka::constant_function() | toBytes;

result = ka::invoke_catch(thenToBytes, toUnicode);

}

void visitList(AnyIterator it, AnyIterator end)

{

GILAcquire lock;

::py::list l;

for (; it != end; ++it)

l.append(unwrapValue(*it));

result = l;

}

void visitVarArgs(AnyIterator it, AnyIterator end)

{

visitList(it, end);

}

void visitMap(AnyIterator it, AnyIterator end)

{

GILAcquire lock;

::py::dict d;

for (; it != end; ++it)

d[unwrapValue((*it)[0])] = (*it)[1];

result = d;

}

void visitObject(GenericObject go)

{

if (!go.isValid())

throw std::runtime_error("cannot convert an invalid generic object");

const auto type = go.type;

const auto ptr = type->ptrFromStorage(&go.value);

GILAcquire lock;

if (auto obj = tryToCastObjectTo<Future>(type, ptr))

{

result = *obj;

return;

}

if (auto obj = tryToCastObjectTo<Promise>(type, ptr))

{

result = *obj;

return;

}

throw std::runtime_error("cannot convert a generic object without refcount to a Python object");

}

void visitAnyObject(AnyObject& obj)

{

GILAcquire lock;

result = py::toPyObject(obj);

}

void visitPointer(AnyReference)

{

throw std::runtime_error("cannot convert a pointer to a Python object");

}

void visitTuple(const std::string& /*name*/,

const std::vector<AnyReference>& tuple,

const std::vector<std::string>& annotations)

{

const auto len = tuple.size();

GILAcquire lock;

if (annotations.empty())

{

// Unnamed tuple

::py::tuple t(len);

for (std::size_t i = 0; i < len; ++i)

t[i] = tuple[i];

result = t;

}

else

{

QI_ASSERT_TRUE(annotations.size() <= tuple.size());

::py::dict d;

for (std::size_t i = 0; i < annotations.size(); ++i)

d[annotations.at(i).c_str()] = tuple[i];

result = d;

}

}

void visitDynamic(AnyReference pointee)

{

GILAcquire lock;

result = unwrapValue(pointee);

}

void visitRaw(AnyReference value)

{

/* TODO: zerocopy, sub-buffers... */

const auto dataWithSize = value.asRaw();

GILAcquire lock;

result = ::py::reinterpret_steal<::py::object>(

PyByteArray_FromStringAndSize(dataWithSize.first, dataWithSize.second));

}

void visitIterator(AnyReference v)

{

visitUnknown(v);

}

void visitOptional(AnyReference v)

{

GILAcquire lock;

result = unwrapValue(v.content());

}

::py::object& result;

};

/// Singleton for a default constructible type.

template<typename T>

T* instance()

{

static T instance;

return &instance;

}

/// Singleton for a non-default constructible type.

template<typename T, typename... Args>

T* instance(Args&&... args)

{

static boost::synchronized_value<std::map<std::tuple<ka::Decay<Args>...>, T>>

instances;

auto syncInstances = instances.synchronize();

auto it = syncInstances->find(std::forward_as_tuple(args...));

if (it == syncInstances->end())

{

std::tie(it, std::ignore) =

syncInstances->emplace(std::piecewise_construct,

std::forward_as_tuple(args...),

std::forward_as_tuple(args...));

}

return &it->second;

}

/// A 'disowned' reference would be a reference that is not expected to be automatically destroyed,

/// meaning we would have to manually call destroy on it. Such a storage enables us to associate

/// such references to a type-erased value so that we can later retrieve them and destroy them

/// manually.

using DisownedReferencesStorage =

boost::synchronized_value<std::map<void*, std::vector<AnyReference>>>;

void storeDisownedReference(void* context, AnyReference ref) noexcept

{

auto* storage = instance<DisownedReferencesStorage>();

auto syncStorage = storage->synchronize();

(*syncStorage)[context].push_back(ref);

}

std::vector<AnyReference> unstoreDisownedReferences(void* context) noexcept

{

auto* storage = instance<DisownedReferencesStorage>();

auto syncStorage = storage->synchronize();

auto it = syncStorage->find(context);

if (it == syncStorage->end())

return {};

std::vector<AnyReference> res;

swap(it->second, res);

syncStorage->erase(it);

return res;

}

std::size_t destroyDisownedReferences(void* context) noexcept

{

const auto refs = unstoreDisownedReferences(context);

for (auto ref : refs)

ref.destroy();

return refs.size();

}

/// Associates a value to a Python object, so that it shares its lifetime.

template<typename T>

AnyReference associateValueToObj(::py::object& obj, T value)

{

const auto res = AnyValue::from(std::move(value)).release();

auto pybindObjPtr = &obj;

storeDisownedReference(pybindObjPtr, res);

// Create a weak reference to the target Python object that will track its lifetime and execute a

// callback once it is destroyed.

//

// The callback ensures that all the references associated to the target object are destroyed, so

// that we can leak them here and still ensure that they will be properly destroyed once needed.

//

// The callback also takes a handle to the weakref Python object itself. We need to make sure that

// this weakref object lives as long as the target Python object so that the callback stays

// attached to the lifetime of the target object. To do that, we leak the weakref Python object

// by releasing it, and we manually decrement the reference count in the callback.

auto weakref = ::py::weakref(obj, ::py::cpp_function([=](::py::handle weakref) {

destroyDisownedReferences(pybindObjPtr);

weakref.dec_ref();

}));

weakref.release();

return res;

}

} // namespace

::py::object unwrapValue(AnyReference val)

{

GILAcquire lock;

::py::object result;

ValueToPyObject tpo(result);

typeDispatch(tpo, val);

return result;

}

namespace types

{

template<typename Storage, typename Interface>

class ObjectInterfaceBase : public Interface

{

public:

static_assert(std::is_base_of<::py::object, ka::RemoveCvRef<Storage>>::value, "");

Storage* asObjectPtr(void** storage)

{

return static_cast<Storage*>(ptrFromStorage(storage));

}

Storage& asObject(void** storage)

{

return *asObjectPtr(storage);

}

void* initializeStorage(void* ptr) override

{

if (ptr)

return ptr;

GILAcquire lock;

return new Storage;

}

void* clone(void* storage) override

{

GILAcquire lock;

return new Storage(asObject(&storage));

}

void destroy(void* storage) override

{

destroyDisownedReferences(storage);

GILAcquire lock;

delete asObjectPtr(&storage);

}

using DefaultImpl = DefaultTypeImplMethods<Storage>;

void* ptrFromStorage(void** storage) override { return DefaultImpl::ptrFromStorage(storage); }

const TypeInfo& info() override { return DefaultImpl::info(); }

bool less(void* a, void* b) override

{

GILAcquire lock;

const auto& objA = asObject(&a);

const auto& objB = asObject(&b);

return objA < objB;

}

};

template<typename Storage = ::py::object>

class DynamicInterface : public ObjectInterfaceBase<Storage, qi::DynamicTypeInterface>

{

AnyReference get(void* storage) override

{

GILAcquire lock;

const auto obj = this->asObjectPtr(&storage);

return unwrapAsRef(*obj);

}

void set(void** storage, AnyReference src) override

{

GILAcquire lock;

this->asObject(storage) = unwrapValue(src);

}

};

template<typename Storage = ::py::int_>

class IntInterface : public ObjectInterfaceBase<Storage, qi::IntTypeInterface>

{

using Repr = long long;

std::int64_t get(void* storage) override

{

GILAcquire lock;

const auto& obj = this->asObject(&storage);

return numericConvertBound<std::int64_t>(::py::cast<Repr>(obj));

}

void set(void** storage, std::int64_t val) override

{

QI_ASSERT_NOT_NULL(storage);

GILAcquire lock;

this->asObject(storage) = ::py::int_(static_cast<Repr>(val));

}

unsigned int size() override { return sizeof(Repr); }

bool isSigned() override { return std::is_signed<Repr>::value; }

};

template<typename Storage = ::py::float_>

class FloatInterface : public ObjectInterfaceBase<Storage, qi::FloatTypeInterface>

{

public:

using Repr = double;

double get(void* storage) override

{

GILAcquire lock;

const auto& obj = this->asObject(&storage);

return numericConvertBound<double>(::py::cast<Repr>(obj));

}

void set(void** storage, double val) override

{

QI_ASSERT_NOT_NULL(storage);

GILAcquire lock;

this->asObject(storage) = ::py::float_(static_cast<Repr>(val));

}

unsigned int size() override { return sizeof(Repr); }

};

template<typename Storage = ::py::bool_>

class BoolInterface : public ObjectInterfaceBase<Storage, qi::IntTypeInterface>

{

public:

int64_t get(void* storage) override

{

GILAcquire lock;

const auto& obj = this->asObject(&storage);

return static_cast<int64_t>(::py::cast<bool>(obj));

}

void set(void** storage, int64_t val) override

{

QI_ASSERT_NOT_NULL(storage);

GILAcquire lock;

this->asObject(storage) = ::py::bool_(static_cast<bool>(val));

}

unsigned int size() override { return 0; }

bool isSigned() override { return false; }

};

template<typename Storage = ::py::str>

class StrInterface : public ObjectInterfaceBase<Storage, qi::StringTypeInterface>

{

public:

StringTypeInterface::ManagedRawString get(void* storage) override

{

GILAcquire lock;

::py::str obj = this->asObject(&storage);

return makeManagedString(std::string(obj));

}

void set(void** storage, const char* ptr, size_t sz) override

{

GILAcquire lock;

this->asObject(storage) = ::py::str(ptr, sz);

}

};

template<typename Storage = ::py::bytes, typename BufferType = ::py::bytes>

class StringBufferInterface : public ObjectInterfaceBase<Storage,

qi::StringTypeInterface>

{

public:

StringTypeInterface::ManagedRawString get(void* storage) override

{

GILAcquire lock;

::py::buffer obj = this->asObject(&storage);

const auto info = obj.request();

QI_ASSERT_TRUE(info.ndim == 1);

QI_ASSERT_TRUE(info.itemsize == sizeof(char));

return makeManagedString(std::string(static_cast<char*>(info.ptr), info.size));

}

void set(void** storage, const char* ptr, size_t sz) override

{

GILAcquire lock;

this->asObject(storage) = ::py::bytes(ptr, sz);

}

};

template<typename Storage>

class StructuredIterableInterface

: public ObjectInterfaceBase<Storage, qi::StructTypeInterface>

{

public:

StructuredIterableInterface(std::size_t size)

: _size(size)

{}

std::vector<TypeInterface*> memberTypes() override

{

return std::vector<TypeInterface*>(_size, typeOf<::py::object>());

}

std::vector<void*> get(void* storage) override

{

GILAcquire lock;

const auto& obj = this->asObject(&storage);

std::vector<void*> res;

res.reserve(_size);

for (const ::py::handle itemHandle : obj)

{

const auto item = ::py::reinterpret_borrow<::py::object>(itemHandle);

const auto itemRef = AnyValue::from(item).release();

storeDisownedReference(storage, itemRef);

res.push_back(itemRef.rawValue());

}

return res;

}

void* get(void* storage, unsigned int index) override

{

QI_ASSERT_TRUE(index < _size);

GILAcquire lock;

const auto& obj = this->asObject(&storage);

// AppleClang 8 wrongly requires a ForwardIterator on `std::next`, which

// `pybind11::iterator` is not. We use advance instead.

auto it = obj.begin();

std::advance(it, index);

const auto item = ::py::reinterpret_borrow<::py::object>(*it);

const auto itemRef = AnyValue::from(item).release();

storeDisownedReference(storage, itemRef);

return itemRef.rawValue();

}

void set(void** /*storage*/, const std::vector<void*>&) override

{

throw std::runtime_error("set a python structured iterable object is unimplemented");

}

void set(void** /*storage*/, unsigned int /*index*/, void* /*valStorage*/) override

{

throw std::runtime_error("set a python structured iterable object is unimplemented");

}

private:

std::size_t _size;

};

template<typename Storage = ::py::list, typename ListType = ::py::list>

class ListInterface : public ObjectInterfaceBase<Storage, qi::ListTypeInterface>

{

public:

using Iterator = std::pair<void* /*list storage*/, unsigned int /*element*/>;

class IteratorInterface : public qi::IteratorTypeInterface

{

public:

AnyReference dereference(void* storage) override

{

const auto& iter = asIter(&storage);

auto* const listType = instance<ListInterface>();

auto* listStorage = iter.first;

const auto index = iter.second;

GILAcquire lock;

ListType list = listType->asObject(&listStorage);

const ::py::object element = list[index];

auto ref = AnyReference::from(element).clone();

// Store the disowned reference with the list as a context instead of the

// iterator because the reference might outlive the iterator.

storeDisownedReference(listStorage, ref);

return ref;

}

void next(void** storage) override { ++asIter(storage).second; }

bool equals(void* s1, void* s2) override { return asIter(&s1) == asIter(&s2); }

using DefaultImpl = DefaultTypeImplMethods<Iterator, TypeByPointerPOD<Iterator>>;

void* initializeStorage(void* ptr = nullptr) override { return DefaultImpl::initializeStorage(ptr); }

void* clone(void* storage) override { return DefaultImpl::clone(storage); }

void destroy(void* storage) override { return DefaultImpl::destroy(storage); }

const TypeInfo& info() override { return DefaultImpl::info(); }

void* ptrFromStorage(void** s) override { return DefaultImpl::ptrFromStorage(s); }

bool less(void* a, void* b) override { return DefaultImpl::less(a, b); }

Iterator* asIterPtr(void** storage) { return static_cast<Iterator*>(ptrFromStorage(storage)); }

Iterator& asIter(void** storage) { return *asIterPtr(storage); }

};

DynamicInterface<::py::object>* elementType() override

{

return instance<DynamicInterface<::py::object>>();

}

size_t size(void* storage) override

{

GILAcquire lock;

ListType list = this->asObject(&storage);

return list.size();

}

void pushBack(void** storage, void* valueStorage) override

{

GILAcquire lock;

::py::object obj = this->asObject(storage);

if (::py::isinstance<::py::list>(obj))

{

::py::list list = obj;

list.append(elementType()->asObject(&valueStorage));

}

else

throw std::runtime_error("cannot append an element on a object that is not a list");

}

AnyIterator begin(void* storage) override

{

return AnyValue(AnyReference(instance<IteratorInterface>(), new Iterator(storage, 0)),

// Do not copy, but free the value, so basically the AnyValue

// takes ownership of the object.

false, true);

}

AnyIterator end(void* storage) override

{

return AnyValue(AnyReference(instance<IteratorInterface>(),

new Iterator(storage, size(storage))),

// Do not copy, but free the value, so basically the AnyValue

// takes ownership of the object.

false, true);

}

};

template<typename Storage>

class DictInterface: public ObjectInterfaceBase<Storage, qi::MapTypeInterface>

{

public:

using Iterator = std::pair<void* /*dict storage*/, unsigned int /*element*/>;

class IteratorInterface : public qi::IteratorTypeInterface

{

public:

AnyReference dereference(void* storage) override

{

const auto& iter = asIter(&storage);

auto* const dictType = instance<DictInterface>();

auto* dictStorage = iter.first;

const auto index = iter.second;

GILAcquire lock;

::py::dict dict = dictType->asObject(&dictStorage);

// AppleClang 8 wrongly requires a ForwardIterator on `std::next`, which

// `pybind11::iterator` is not. We use advance instead.

auto it = dict.begin();

std::advance(it, index);

const auto key = ::py::reinterpret_borrow<::py::object>(it->first);

const auto element = ::py::reinterpret_borrow<::py::object>(it->second);

auto keyRef = AnyReference::from(key);

auto elementRef = AnyReference::from(element);

auto pairRef = makeGenericTuple({keyRef, elementRef});

// Store the disowned reference with the list as a context instead of the

// iterator because the reference might outlive the iterator.

storeDisownedReference(dictStorage, pairRef);

return pairRef;

}

void next(void** storage) override { ++asIter(storage).second; }

bool equals(void* s1, void* s2) override { return asIter(&s1) == asIter(&s2); }

using DefaultImpl = DefaultTypeImplMethods<Iterator, TypeByPointerPOD<Iterator>>;

void* initializeStorage(void* ptr = nullptr) override { return DefaultImpl::initializeStorage(ptr); }

void* clone(void* storage) override { return DefaultImpl::clone(storage); }

void destroy(void* storage) override { return DefaultImpl::destroy(storage); }

const TypeInfo& info() override { return DefaultImpl::info(); }

void* ptrFromStorage(void** s) override { return DefaultImpl::ptrFromStorage(s); }

bool less(void* a, void* b) override { return DefaultImpl::less(a, b); }

Iterator* asIterPtr(void** storage) { return static_cast<Iterator*>(ptrFromStorage(storage)); }

Iterator& asIter(void** storage) { return *asIterPtr(storage); }

};

DynamicInterface<::py::object>* elementType() override

{

return instance<DynamicInterface<::py::object>>();

}

DynamicInterface<::py::object>* keyType() override

{

return instance<DynamicInterface<::py::object>>();

}

size_t size(void* storage) override

{

GILAcquire lock;

::py::dict dict = this->asObject(&storage);

return dict.size();

}

AnyIterator begin(void* storage) override

{

GILAcquire lock;

::py::dict dict = this->asObject(&storage);

return AnyValue(AnyReference(instance<IteratorInterface>(), new Iterator(storage, 0)),

// Do not copy, but free the value, so basically the AnyValue

// takes ownership of the object.

false, true);

}

AnyIterator end(void* storage) override

{

return AnyValue(AnyReference(instance<IteratorInterface>(),

new Iterator(storage, size(storage))),

// Do not copy, but free the value, so basically the AnyValue

// takes ownership of the object.

false, true);

}

void insert(void** storage, void* keyStorage, void* valueStorage) override

{

GILAcquire lock;

::py::dict dict = this->asObject(storage);

::py::object key = keyType()->asObject(&keyStorage);

::py::object value = elementType()->asObject(&valueStorage);

dict[key] = value;

}

AnyReference element(void** storage, void* keyStorage, bool autoInsert) override

{

GILAcquire lock;

::py::dict dict = this->asObject(storage);

::py::object key = keyType()->asObject(&keyStorage);

::py::object value;

if (dict.contains(key))

value = dict[key];

else

{

if (!autoInsert)

return AnyReference();

dict[key] = ::py::none();

}

auto ref = AnyReference::from(value).clone();

// Store the disowned reference with the list as a context instead of the

// iterator because the reference might outlive the iterator.

storeDisownedReference(storage, ref);

return ref;

}

};

} // namespace types

AnyReference unwrapAsRef(pybind11::object& obj)

{

QI_ASSERT_TRUE(obj);

GILAcquire lock;

if (obj.is_none())

// The "void" value in AnyValue has no storage, so we can just release it

// without risk of a leak.

return AnyValue::makeVoid().release();

if ( ::py::isinstance<::py::ellipsis>(*obj)

|| PyComplex_CheckExact(obj.ptr())

|| ::py::isinstance<::py::memoryview>(*obj)

|| ::py::isinstance<::py::slice>(*obj)

|| ::py::isinstance<::py::module>(*obj))

{

throw std::runtime_error("The Python type " +

std::string(::py::str(obj.get_type())) +

" is not handled");

}

// Pointer to the libpython C library python object.

const auto pyObjPtr = obj.ptr();

// Pointer to the pybind C++ library python object.

const auto pybindObjPtr = &obj;

if (PyLong_CheckExact(pyObjPtr))

return AnyReference(instance<types::IntInterface<::py::object>>(), pybindObjPtr);

if (PyFloat_CheckExact(pyObjPtr))

return AnyReference(instance<types::FloatInterface<::py::object>>(), pybindObjPtr);

if (PyBool_Check(pyObjPtr))

return AnyReference(instance<types::BoolInterface<::py::object>>(), pybindObjPtr);

if (PyUnicode_CheckExact(pyObjPtr))

return AnyReference(instance<types::StrInterface<::py::object>>(), pybindObjPtr);

if (PyBytes_CheckExact(pyObjPtr) || PyByteArray_CheckExact(pyObjPtr))

return AnyReference(instance<types::StringBufferInterface<::py::object>>(), pybindObjPtr);

if (PyTuple_CheckExact(pyObjPtr))

return AnyReference(instance<types::StructuredIterableInterface<::py::object>>(

::py::tuple(obj).size()),

pybindObjPtr);

// Checks if it is AnySet, meaning it can be a set or a frozenset.

if (PyAnySet_CheckExact(pyObjPtr))

return AnyReference(instance<types::StructuredIterableInterface<::py::object>>(

::py::set(obj).size()),

pybindObjPtr);

if (PyList_CheckExact(pyObjPtr) || PyDictViewSet_Check(pyObjPtr) || PyDictValues_Check(pyObjPtr))

return AnyReference(instance<types::ListInterface<::py::object, ::py::list>>(), pybindObjPtr);

if (PyDict_CheckExact(pyObjPtr))

return AnyReference(instance<types::DictInterface<::py::object>>(), pybindObjPtr);

// At the moment in libqi, the `LogLevel` type is not registered in the qi type system. If we use

// `AnyValue::from` with a `LogLevel` value, we get a value with a dummy type that cannot be set

// or read. Furthermore, when registered with the `QI_TYPE_ENUM` macro, enumeration types are

// treated as `int` values. This forces us to cast it here as an `int` to try to stay compatible.

if (::py::isinstance<LogLevel>(obj))

{

const auto logLevel = obj.cast<LogLevel>();

const auto logLevelValue = static_cast<int>(logLevel);

return associateValueToObj(obj, logLevelValue);

}

return associateValueToObj(obj, py::toObject(obj));

}

void registerTypes()

{

// This list of types is just the most used types and is therefore not

// exhaustive. At this point these are the only default conversions we need.

// It doesn't mean these are the only types we support, they're just the only

// types that will be supported by `qi::typeOf` and automatically by

// `qi::AnyValue` (for instance through functions like `qi::AnyValue::from`).

// Other types might be supported by `qi::AnyValue` but their interface will

// have to be provided manually at construction.

qi::registerType(qi::typeId<::py::object>(),

instance<types::DynamicInterface<::py::object>>());

qi::registerType(qi::typeId<::py::int_>(),

instance<types::IntInterface<::py::int_>>());

qi::registerType(qi::typeId<::py::float_>(),

instance<types::FloatInterface<::py::float_>>());

qi::registerType(qi::typeId<::py::bool_>(),

instance<types::BoolInterface<::py::bool_>>());

qi::registerType(qi::typeId<::py::str>(),

instance<types::StrInterface<::py::str>>());

qi::registerType(qi::typeId<::py::bytes>(),

instance<types::StringBufferInterface<::py::bytes>>());

// The default type interface for the following types is "dynamic" because

// we cannot give them a proper interface without an instance of an object

// from which to get its size.

qi::registerType(qi::typeId<::py::list>(),

instance<types::DynamicInterface<::py::list>>());

qi::registerType(qi::typeId<::py::dict>(),

instance<types::DynamicInterface<::py::dict>>());

qi::registerType(qi::typeId<::py::kwargs>(),

instance<types::DynamicInterface<::py::kwargs>>());

qi::registerType(qi::typeId<::py::tuple>(),

instance<types::DynamicInterface<::py::tuple>>());

qi::registerType(qi::typeId<::py::args>(),

instance<types::DynamicInterface<::py::args>>());

}

} // py

} // qi