Mailman 3 May 2007 - Cplusplus-sig

How to import a boost::python dll in windows?
by ichijoji Aug. 5, 2011

Aug. 5, 2011

I'm trying to port some research code that uses boost::python to expose a library to python to windows, but I'm having trouble importing the dll into python. I'm compiling using msvc 2005 and using python 2.5, but when I try to import the module I get this: Traceback (most recent call last): File "main.py", line 1, in <module> import object File "c:\code\sge\code\scripts\object.py", line 1, in <module> import sge ImportError: No module named sge My module is named sge and I'm compiling to sge.dll. Is there some obvious reason why python wouldn't be able to find my dll? When I compile on linux into an so this code works fine. -- View this message in context: http://www.nabble.com/How-to-import-a-boost%3A%3Apython-dll-in-windows--tf3… Sent from the Python - c++-sig mailing list archive at Nabble.com.

4 4

Base class defined in other header file not included in bp::bases<>
by Haridev, Meghana Sept. 14, 2008

Sept. 14, 2008

Hi Folks, I'm having some trouble generating boost-python wrapper code using pyplusplus for a derived class which has one of its base classes defined in another file. Simple scenario: mydir/ other.hpp: class baseB{ }; hierarchy.hpp: #include "other.hpp" class baseA{ }; class derivedC: public baseA, public baseB{ }; generate_code.py: import os from pyplusplus import module_builder mb = module_builder.module_builder_t( files=['hierarchy.hpp'] ) mb.build_code_creator( module_name='inherit' ) mb.code_creator.user_defined_directories.append( os.path.abspath('.') ) mb.write_module('boost_hierarchy.cpp') ------------------------------------------------------------------------ ------------------------------------------------- Generated code (boost_hierarchy.cpp) looks like this: // This file has been generated by pyplusplus. #include "boost/python.hpp" #include "hierarchy.hpp" namespace bp = boost::python; BOOST_PYTHON_MODULE(inherit){ bp::class_< baseA >( "baseA" ); bp::class_< derivedC, bp::bases< baseA > >( "derivedC" ); } How can I get pyplusplus to add 'baseB' to bp::bases<> for 'derivedC' class when 'baseB' class is defined in another file (present in the same directory or different directory)? When I move the definition of 'baseB' class to hierarchy.hpp, boost wrapper for 'derivedC' is correctly generated as: bp::class_< derivedC, bp::bases< baseA, baseB > >( "derivedC" ); Thanks, -Meghana.

3 9

'iteritems', 'iterkeys' and 'itervalues' in dict
by Nindi Singh April 11, 2008

April 11, 2008

Apolgies for not putting the subject line in my last email. In the Boost.Python dict class there are methods 'iteritems', 'iterkeys' and 'itervalues' all returning objects. How exactly are you supposed to use these objects (iterators) ? ___________________________________________________________ Inbox full of spam? Get leading spam protection and 1GB storage with All New Yahoo! Mail. http://uk.docs.yahoo.com/nowyoucan.html

2 1

Custom smart pointer with same behaviour as shared_ptr
by Francis Moreau Jan. 23, 2008

Jan. 23, 2008

Hi, I am passing Python objects to C++ through a shared_ptr smart pointer and it's work well. However I need to have the same behaviour as shared_ptr but with my own version of smart pointer. I try to register and expose my custom smart pointer but I have this compilation error: boost/python/pointee.hpp(28) : error C2039: 'element_type': is not a member of 'CountedObjPtr<T>' with [ T=PyCallEngineState ] boost/python/pointee.hpp(38) : see reference to class template instantiation 'boost::python::detail::pointee_impl<false>::apply<T>' being compiled with [ T=CountedObjPtr<PyCallEngineState> ] boost/python/register_ptr_to_python.hpp(17) : see reference to class template instantiation 'boost::python::pointee<T>' being compiled with [ T=CountedObjPtr<PyCallEngineState> ] PythonModules.cpp(113) : see reference to function template instantiation 'void boost::python::register_ptr_to_python<CountedObjPtr<T>>(void)'being compiled with [ T=PyCallEngineState ] Here is the content of the from_python file for my smart pointer: template <class T> struct CountedObjPtr_from_python { CountedObjPtr_from_python() { converter::registry::insert(&convertible, &construct, type_id<CountedObjPtr<T> >()); } static void* convertible(PyObject* p) { if (p == Py_None) { return p; } return converter::get_lvalue_from_python( p, python::converter::registered<T>::converters); } static void construct(PyObject* source, python::converter::rvalue_from_python_stage1_data* data) { void* const storage = ((python::converter::rvalue_from_python_storage<CountedObjPtr<T> >*)data)->storage.bytes; // Deal with the "None" case. if (data->convertible == source) { new (storage) CountedObjPtr<T>(); } else { new (storage) CountedObjPtr<T>(static_cast<T*>(data->convertible)); } data->convertible = storage; } }; And here is the code where I register the smart pointer: namespace boost{ namespace python{ template <class T> struct pointee< CountedObjPtr<const T> > { typedef T type; }; template <class T> inline T* get_pointer(CountedObjPtr<const T> const& p) { return const_cast<T*>(p.get()); } }} template <typename T> void register_CountedObjPtr_conversions() { boost::python::converter::registry::insert( &CountedObjPtr_from_python<T>::convertible, &CountedObjPtr_from_python<T>::construct, boost::python::type_id<CountedObjPtr<T> >()); } BOOST_PYTHON_MODULE(CallEngineExtending) { python::class_<PyCallEngineState, PyCallEngineState_Wrapped, boost::noncopyable>("PyCallEngineState") ; //register_ptr_to_python<boost::shared_ptr<PyCallEngineState> >(); python::register_ptr_to_python<CountedObjPtr<PyCallEngineState> >(); register_CountedObjPtr_conversions<PyCallEngineState>(); } Is anyone knows what is missing or wrong with this code? Also, I am not sure this code manages the ref counting properly since there is no call to borrowed or something like this? Any help would be appreciated, Francis

4 13

std::tr1::shared_ptr as boost::shared_ptr
by Piotr Jaroszynski Jan. 16, 2008

Jan. 16, 2008

Hello, I am exposing a C++ app, which makes heavy use of tr1::shared_ptr, which seems to be exactly(?) the same as boost::shared_ptr. I have managed to make most of the stuff work just as it would be boost::shared_ptr ( additionally adding support for shared_ptr<const T> - thanks to [1] ): namespace my_app_namespace { //Make Boost.Python work with std::tr1::shared_ptr<> template<typename T_> inline T_ * get_pointer(std::tr1::shared_ptr<T_> const & p) { return p.get(); } //Make Boost.Python work with std::tr1::shared_ptr<const> template<typename T_> inline T_ * get_pointer(std::tr1::shared_ptr<const T_> const & p) { return const_cast<T_*>(p.get()); } } namespace boost { namespace python { //Make Boost.Python work with std::tr1::shared_ptr<> template<typename T_> struct pointee<std::tr1::shared_ptr<T_> > { typedef T_ type; }; //Make Boost.Python work with std::tr1::shared_ptr<const> template<typename T_> struct pointee<std::tr1::shared_ptr<const T_> > { typedef T_ type; }; } } What is still not working is the implicit conversion of Foo and Derived for functions taking std::tr1::shared_ptr<Foo>. With boost::shared_ptr it just works when you add the bp::bases<Foo> to the Derived: func(boost::shared_ptr<Foo>) ... bp::class_<Foo> ... bp::class_<Derived, bp::bases<Foo> > ... and func can take both Foo and Derived. But with std::tr1::shared_ptr I have to use: func(std::tr1::shared_ptr<Foo>) ... bp::class_<Foo, std::tr1::shared_ptr<Foo> > ... bp::class_<Derived, std::tr1::shared_ptr<Derived>, bp::bases<Foo> > ... bp::implicitly_convertible<std::tr1::shared_ptr<Foo>, std::tr1::shared_ptr<Derived> >(); How can I make it working just as with boost::shared_ptr? Btw. I have seen [2] already, but it doesn't seem to cover that. [1] - http://language-binding.net/pyplusplus/troubleshooting_guide/shared_ptr/sha… [2] - http://language-binding.net/pyplusplus/troubleshooting_guide/smart_ptrs/sma… -- Best Regards, Piotr Jaroszynski

3 5

C++ singleton
by Emmanuel Taurel Oct. 31, 2007

Oct. 31, 2007

Hello everybody, I am actually writing an interface to python for an existing C++ library using Boost. This library has a C++ singleton class. This class has only one constructor (with arguments) which is "protected" because it's a singleton. I am not able to build a Boost interface to this class because the compiler complains that the constructor I have given to Boost in the class_xxx constructor argument is not public (which is true) ! Therefore, my question is simple : How is it possible to interface such a class with only one constructor which is protected and a static method to create/access the object ? Thank's very much for your answer. Sincerely Emmanuel Taurel (etaurel(a)cells.es) PS : By the way, is there a searchable archive of this mailing list ?

4 3

Moving "decorator" into C++ part of module
by Albert Strasheim July 12, 2007

July 12, 2007

Hello all I have a class with various methods that return uBLAS matrices. I've wrapped various instantiations of these matrices with: template<typename T> struct matrix_wrapper { static void wrap(const char* python_name) { py::class_<T, boost::noncopyable>(python_name, py::no_init) .add_property("__array_struct__", array_struct__) ; } static void cleanup(void* obj) { PyArrayInterface* ai = (PyArrayInterface*) obj; delete [] ai->shape; delete [] ai->strides; delete ai; } static PyObject* array_struct__(T const& self) { // http://numpy.scipy.org/array_interface.shtml PyArrayInterface* ai = new PyArrayInterface; // ... more code here ... ai->data = (void*) self.data().begin(); return PyCObject_FromVoidPtr(ai, cleanup); } } In Python this allows me to do: foo = WrappedClass() cmatrix = foo.somefunc() numpyarr = numpy.asarray(cmatrix) without a copy of cmatrix's contents having to be made. Now I'd just like to get rid of the asarray bit so that it looks like my wrapped functions return NumPy arrays. In Python I can "decorate" this function like so: def return_asarray(func): from numpy import asarray def call(*args, **kwargs): return asarray(func(*args, **kwargs)) return call WrappedClass.somefunc = return_asarray(WrappedClass.somefunc) but I would like to move this "decoration" into the C++ code, so that my module doesn't need to have the extra Python bits. Any thoughts on how this could be done? I looked at the documentation for class_, but nothing jumped out at me. Regards, Albert

5 12

Boost.Python std::cerr segfault when built with -lGL
by Gazihan Alankus June 3, 2007

June 3, 2007

Hello, I'm using Boost.Python to create a python library. When I use -lGL in my linker flags, the first string I send to std::cerr results in an exception. When I leave -lGL out, everything is fine and std::cerr works with no problems. I get this problem when I add -lGL to the simplest Boost.Python sample program that has nothing to do with OpenGL. Any ideas? Does anybody else see this behavior? I'm on Gentoo Linux, using gcc 4.1.1, Python 2.4 and Boost 1.33. I tried Python 2.3 too and it's the same. -Gazi

2 10

Extract
by Sean Ross-Ross May 30, 2007

May 30, 2007

I have a templated class PatameterList that mimics a c++ map or a python dict. it has a method template<class T> void set( string name, T item ) how can I add a method in that will extract any c++ class from python and put it into the PatameterList I was thinking along the lines of adding a method void my_set( PatameterList const& self,string, name, boost::python::object o) { self.set(name , extract< whatever > ( o ) ); } ... class_< PatameterList > ( ... ... .def( "set" , &my_set ) ... where I don't know how to implement the "whatever" arg. ~Sean

2 3

sp_counted_impl_pd with shared_ptr_deleter
by Gabriel Becedillas May 29, 2007

May 29, 2007

I have the following problem: 1_) A boost::shared_ptr<T> is converted to python. 2_) The PyObject holding the boost::shared_ptr<T> is converted back from python, (apparently) yielding the same boost::shared_ptr<T>. 3_) The boost::shared_ptr<T> hits refcount 0 somewhere else in C++Land without holding the Python GIL. 4_) Python's API gets called without holding the GIL because a sp_counted_impl_pd with a shared_ptr_deleter modifies the PyObject's refcount and Py_Dealloc gets called (check shared_ptr_deleter::operator()). This is wrong because you shouldn't use Python's API without holding the GIL. In my particular case I don't know when or where a boost::shared_ptr<T> will hit refcount 0 (thats the funny part of using smart pointers). I took a look around and found that: 1_) shared_ptr_from_python is putting the shared_ptr_deleter. 2_) shared_ptr_to_python is checking if the boost::shared_ptr<T> holds a shared_ptr_deleter to get the PyObject inside. Is there a way to make shared_ptr_from_python return the original boost::shared_ptr<T> without changing the sp_counted_impl_pd/shared_ptr_deleter ? Thanks.

1 0