From tegan at gnometank.net  Sun Sep  2 01:07:47 2007
From: tegan at gnometank.net (Matt Holmes)
Date: Sat, 01 Sep 2007 18:07:47 -0500
Subject: [C++-sig] Object lifetime issue
Message-ID: <fbcrbs$m8u$1@sea.gmane.org>

I am trying to expose one of the classes in my engine as an abstract 
class that is used as the base for a series of Python classes.

That class is called InputCommand and is defined as such:
namespace Stasis {
	class InputCommand {
	public:
		virtual bool execute() = 0;
	};
}

To expose that class, I created the following wrapper:

class InputCommandWrapper : public Stasis::InputCommand, public 
wrapper<Stasis::InputCommand> {
public:
	bool execute() {
		return this->get_override("execute")();
	}
};

And added it to my Boost.Python module like so:

class_<InputCommandWrapper, boost::noncopyable>("InputCommand")
	.def("execute", pure_virtual(&InputCommand::execute));

Everything seems okay so far, but then I have another class called 
InputManager. This class exposes a function, registerCommand, that takes 
a const std::string& and an InputCommand*. That classes partial 
defintion is:

class InputManager : public Singleton<InputManager>
public:
	static InputManager& getSingleton() { return *ms_Singleton; }
	static InputManager* getSingletonPtr() { return ms_Singleton; }

	InputManager();
	~InputManager();
		
	void executeCommand(const string& cmdName);
	void registerCommand(const string& cmdName, InputCommand* cmd);
}

It is defined in the Boost.Python module as such:

class_<InputManager>("InputManager")
	.def("registerCommand", &InputManager::registerCommand, 
with_custodian_and_ward_postcall<1, 3>())
	.def("getSingleton", &InputManager::getSingleton, 
return_value_policy<reference_existing_object>()).staticmethod("getSingleton");

I am executing the follwing Python script, which should create an 
instance of the QuitCommand object, pass it to the 
InputManagers::registerCommand method, which will store that command 
object and use it to execute the given command later (which is 
implemented in Python). The issue is that when I call the execute() 
method of my store InputCommand*, my program crashes. From what I can 
tell it's because Python is destroying the object I created in the 
Python script below to pass to registerCommand. I thought 
with_custodian_and_ward<1, 3> (the custodian should be 'this', the 
InputManader, and the ward should be the InputCommand sub-class object) 
would stop the Python GC from destroying it, but I guess I was wrong.

Here is the Python script:

from engine import *

class QuitCommand(InputCommand):
     def execute(self):
         Kernel.getSingleton().shutdown()

if __name__ == "__main__":
     InputManager.getSingleton().registerCommand("Quit", QuitCommand())

What am I doing wrong here? What do I need to do to tell Python "The 
QuitCommand() object I just created, don't destroy it, something else is 
holding a reference to it"?



From lloyd at fusion.net.nz  Mon Sep  3 03:21:58 2007
From: lloyd at fusion.net.nz (Lloyd Weehuizen)
Date: Mon, 3 Sep 2007 13:21:58 +1200
Subject: [C++-sig] Strange problem with boost::python::scope
Message-ID: <7170F7DD-582F-4930-8992-04B71FC37D08@fusion.net.nz>

Hi There

I've run into an issue with the scope object that I don't understand.

I'm trying to defined class Y under class X similar to the scoping  
examples as follows:

// No code, just a place holder class for scoping
class ElementNamespace {};

// Class with implementation
class DataGrid
{

};

python::scope element_scope( python::class_< ElementNamespace,  
boost::noncopyable >( "element", python::no_init ) );

python::class_< DataGrid, ElementWrapper< DataGrid >,  
boost::noncopyable, python::bases< Element > >("DataGrid",  
python::init< const char* >())
  ...
;

I then try to inherit from DataGrid in python code as follows:

class CustomDataGrid(testmodule.element.DataGrid):
     def __init__(self, tag):
         testmodule.element.DataGrid.__init__(self, tag)

And I get the following error:
  Traceback (most recent call last):
File "c:\projects\testmodule\datagrid.py", line 6, in __init__
   testmodule.element.DataGrid.__init__(self, tag)
AttributeError: 'module' object has no attribute 'DataGrid'

Strangely enough the CustomDataGrid class inheritance finds the  
object correctly, but calling the base  initializer fails.

Any ideas?

Thanks,
Lloyd


From achim-bpl at mol-net.com  Mon Sep  3 11:02:04 2007
From: achim-bpl at mol-net.com (Achim H.)
Date: Mon, 3 Sep 2007 11:02:04 +0200
Subject: [C++-sig] Object lifetime issue
In-Reply-To: <fbcrbs$m8u$1@sea.gmane.org>
References: <fbcrbs$m8u$1@sea.gmane.org>
Message-ID: <200709031102.05246.achim-bpl@mol-net.com>

Hi,

I had a similar problem and all I could come up with was this memory-leaking 
approach using Py_INCREF(). Please note that I don't use the copy ctor but a 
special duplicate() function that creates a new object and does not make a 
copy:

template <class T> boost::python::object getOwner(T* tp)
{
	using namespace boost::python;
	// see http://article.gmane.org/gmane.comp.python.c++/9530
	return object ( handle<> ( borrowed ( 
detail::wrapper_base_::get_owner(*tp))));
}

/* virtual */ Base* BaseWrapper::duplicate() const
{
	BaseWrapper* orig = const_cast<BaseWrapper*>(this);
	object self = getOwner(orig);
	object OBJ = self.attr("__class__");
	object o = OBJ(); // ctor call
	BaseWrapper& obj = extract<BaseWrapper&>(o);
	BaseWrapper* dup = &obj;
	Py_INCREF(o.ptr());
	return dup;
}

It is still a kludge - maybe somebody else can propose a cleaner solution.
I'd be very interested.

Achim.

Am Sonntag 02 September 2007 schrieb Matt Holmes:
> I am trying to expose one of the classes in my engine as an abstract
> class that is used as the base for a series of Python classes.
>
> That class is called InputCommand and is defined as such:
> namespace Stasis {
> 	class InputCommand {
> 	public:
> 		virtual bool execute() = 0;
> 	};
> }
>
> To expose that class, I created the following wrapper:
>
> class InputCommandWrapper : public Stasis::InputCommand, public
> wrapper<Stasis::InputCommand> {
> public:
> 	bool execute() {
> 		return this->get_override("execute")();
> 	}
> };
>
> And added it to my Boost.Python module like so:
>
> class_<InputCommandWrapper, boost::noncopyable>("InputCommand")
> 	.def("execute", pure_virtual(&InputCommand::execute));
>
> Everything seems okay so far, but then I have another class called
> InputManager. This class exposes a function, registerCommand, that takes
> a const std::string& and an InputCommand*. That classes partial
> defintion is:
>
> class InputManager : public Singleton<InputManager>
> public:
> 	static InputManager& getSingleton() { return *ms_Singleton; }
> 	static InputManager* getSingletonPtr() { return ms_Singleton; }
>
> 	InputManager();
> 	~InputManager();
>
> 	void executeCommand(const string& cmdName);
> 	void registerCommand(const string& cmdName, InputCommand* cmd);
> }
>
> It is defined in the Boost.Python module as such:
>
> class_<InputManager>("InputManager")
> 	.def("registerCommand", &InputManager::registerCommand,
> with_custodian_and_ward_postcall<1, 3>())
> 	.def("getSingleton", &InputManager::getSingleton,
> return_value_policy<reference_existing_object>()).staticmethod("getSingleto
>n");
>
> I am executing the follwing Python script, which should create an
> instance of the QuitCommand object, pass it to the
> InputManagers::registerCommand method, which will store that command
> object and use it to execute the given command later (which is
> implemented in Python). The issue is that when I call the execute()
> method of my store InputCommand*, my program crashes. From what I can
> tell it's because Python is destroying the object I created in the
> Python script below to pass to registerCommand. I thought
> with_custodian_and_ward<1, 3> (the custodian should be 'this', the
> InputManader, and the ward should be the InputCommand sub-class object)
> would stop the Python GC from destroying it, but I guess I was wrong.
>
> Here is the Python script:
>
> from engine import *
>
> class QuitCommand(InputCommand):
>      def execute(self):
>          Kernel.getSingleton().shutdown()
>
> if __name__ == "__main__":
>      InputManager.getSingleton().registerCommand("Quit", QuitCommand())
>
> What am I doing wrong here? What do I need to do to tell Python "The
> QuitCommand() object I just created, don't destroy it, something else is
> holding a reference to it"?
>
> _______________________________________________
> C++-sig mailing list
> C++-sig at python.org
> http://mail.python.org/mailman/listinfo/c++-sig




From meine at informatik.uni-hamburg.de  Mon Sep  3 11:51:00 2007
From: meine at informatik.uni-hamburg.de (Hans Meine)
Date: Mon, 3 Sep 2007 11:51:00 +0200
Subject: [C++-sig] Object lifetime issue
In-Reply-To: <fbcrbs$m8u$1@sea.gmane.org>
References: <fbcrbs$m8u$1@sea.gmane.org>
Message-ID: <200709031151.01513.meine@informatik.uni-hamburg.de>

Am Sonntag, 02. September 2007 01:07:47 schrieb Matt Holmes:
> I am trying to expose one of the classes in my engine as an abstract
> class that is used as the base for a series of Python classes.
>
> That class is called InputCommand and is defined as such:
> namespace Stasis {
> 	class InputCommand {
> 	public:
> 		virtual bool execute() = 0;
> 	};
> }

My compiler warns me in such cases that you have a virtual function, but no 
virtual destructor (IIRC Scott Meyers' effective C++ has a section on that).  
Don't know if that's related, but note that no destructor of derived classes 
can be guaranteed to be called from C++.

Ciao, /  /
     /--/
    /  / ANS


From Mark.English at rbccm.com  Mon Sep  3 11:55:40 2007
From: Mark.English at rbccm.com (English, Mark)
Date: Mon, 3 Sep 2007 10:55:40 +0100
Subject: [C++-sig] Object lifetime issue
Message-ID: <EE7D40281B517A41AF5A90847A61F27930CAE4D3@SEW39051.oak.fg.rbc.com>

> -----Original Message-----
> From: c++-sig-bounces at python.org [mailto:c++-sig-bounces at python.org]On
> Behalf Of Matt Holmes
> Sent: 02 September 2007 00:08
> To: c++-sig at python.org
> Subject: [C++-sig] Object lifetime issue
> 
> 
> I am trying to expose one of the classes in my engine as an abstract 
> class that is used as the base for a series of Python classes.
> 
> <snip>
> 
> I am executing the follwing Python script, which should create an 
> instance of the QuitCommand object, pass it to the 
> InputManagers::registerCommand method, which will store that command 
> object and use it to execute the given command later (which is 
> implemented in Python). The issue is that when I call the execute() 
> method of my store InputCommand*, my program crashes. From what I can 
> tell it's because Python is destroying the object I created in the 
> Python script below to pass to registerCommand. I thought 
> with_custodian_and_ward<1, 3> (the custodian should be 'this', the 
> InputManader, and the ward should be the InputCommand 
> sub-class object) 
> would stop the Python GC from destroying it, but I guess I was wrong.
> 

Would any of the other return policies be of any use either directly or as example code ? For example "return_internal_reference" which inherits from "with_custodian_and_ward_postcall" ?

Also, sys.getrefcount() may help you if you haven't seen it already, and also various debug build options for the python interpreter.

MarkE
________________________________________

This E-Mail (including any attachments) may contain privileged or confidential information.  It is intended only for the addressee(s) indicated above.

The sender does not waive any of its rights, privileges or other protections respecting this information.  

Any distribution, copying or other use of this E-Mail or the information it contains, by other than an intended recipient, is not sanctioned and is prohibited.

If you received this E-Mail in error, please delete it and advise the sender (by return E-Mail or otherwise) immediately. 

This E-Mail (including any attachments) has been scanned for viruses. 

It is believed to be free of any virus or other defect that might affect any computer system into which it is received and opened. 

However, it is the responsibility of the recipient to ensure that it is virus free. 

The sender accepts no responsibility for any loss or damage arising in any way from its use.

E-Mail received by or sent from RBC Capital Markets is subject to review by Supervisory personnel. 

Such communications are retained and may be produced to regulatory authorities or others with legal rights to the information.

IRS CIRCULAR 230 NOTICE:  TO COMPLY WITH U.S. TREASURY REGULATIONS, WE ADVISE YOU THAT ANY U.S. FEDERAL TAX ADVISE INCLUDED IN THIS COMMUNICATION IS NOT INTENDED OR WRITTEN TO BE USED, AND CANNOT BE USED, TO AVOID ANY U.S. FEDERAL TAX PENALTIES OR TO PROMOTE, MARKET, OR RECOMMEND TO ANOTHER PARTY ANY TRANSACTION OR MATTER.


From roman.yakovenko at gmail.com  Tue Sep  4 09:06:06 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Tue, 4 Sep 2007 10:06:06 +0300
Subject: [C++-sig] Object lifetime issue
In-Reply-To: <fbcrbs$m8u$1@sea.gmane.org>
References: <fbcrbs$m8u$1@sea.gmane.org>
Message-ID: <7465b6170709040006s19609effgc0c7bceb86f770ac@mail.gmail.com>

On 9/2/07, Matt Holmes <tegan at gnometank.net> wrote:
>
> I am trying to expose one of the classes in my engine as an abstract
> class that is used as the base for a series of Python classes.
>
> That class is called InputCommand and is defined as such:
> namespace Stasis {
>         class InputCommand {
>         public:
>                 virtual bool execute() = 0;
>         };
> }
>
> To expose that class, I created the following wrapper:
>
> class InputCommandWrapper : public Stasis::InputCommand, public
> wrapper<Stasis::InputCommand> {
> public:
>         bool execute() {
>                 return this->get_override("execute")();
>         }
> };
>
> And added it to my Boost.Python module like so:
>
> class_<InputCommandWrapper, boost::noncopyable>("InputCommand")
>         .def("execute", pure_virtual(&InputCommand::execute));
>
> Everything seems okay so far, but then I have another class called
> InputManager. This class exposes a function, registerCommand, that takes
> a const std::string& and an InputCommand*. That classes partial
> defintion is:
>
> class InputManager : public Singleton<InputManager>
> public:
>         static InputManager& getSingleton() { return *ms_Singleton; }
>         static InputManager* getSingletonPtr() { return ms_Singleton; }
>
>         InputManager();
>         ~InputManager();
>
>         void executeCommand(const string& cmdName);
>         void registerCommand(const string& cmdName, InputCommand* cmd);
> }



Who is responsible for cmd lifetime, InputManager or somebody else? This
answer is a key for correct solution.

I attached 2 files that contains solution for your problem

P.S. The code is not minimal, because I extracted it from Py++ unittests

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070904/9ccbf8f9/attachment.htm>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: transfer_ownership.cpp
Type: text/x-c++src
Size: 4836 bytes
Desc: not available
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070904/9ccbf8f9/attachment.cpp>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: transfer_ownership_to_be_exported.hpp
Type: text/x-c++hdr
Size: 690 bytes
Desc: not available
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070904/9ccbf8f9/attachment.hpp>

From capak at inputwish.com  Tue Sep  4 12:14:48 2007
From: capak at inputwish.com (Libor Capak)
Date: Tue, 4 Sep 2007 12:14:48 +0200
Subject: [C++-sig] py++ na namespace
Message-ID: <20070904101448.GA21592@inputwish.com>

Hi,

i'm learning py++ and i have following problem:

c++:

namespace A { void foo(); }

generated file by py++ contains something like that:

bp::def("foo", &A::foo);

but py++ doesn't create "sub-module" A and function foo() is at
"basic level". What about handle this situation this way: ?

bp::handle<> m(PyModule_New("A"));
bp::scope().attr("A") = m;
bp::scope s = bp::object(m);
def("foo", &A::foo);

or did i overpass some simple solution in documentation?
thanks

Libor Capak


From furkankuru at gmail.com  Tue Sep  4 13:44:41 2007
From: furkankuru at gmail.com (Furkan Kuru)
Date: Tue, 4 Sep 2007 14:44:41 +0300
Subject: [C++-sig] exposing pointers using boost
Message-ID: <3a4a8f930709040444r68b8ef1dx2c688382f866b1c7@mail.gmail.com>

Hello,

Is there a way to expose structs containing pointers of their types?

Let's say, I have a very simple doubly-linked list.

struct Node {
        Node* next;
        Node* prev;
        int value;
};

I expose it like this:

class_<Node>("Node")
	.def_readwrite("value", &Node::value)
	.def_readwrite("next", &Node::next)
	.def_readwrite("prev", &Node::prev);

When I try to access the next and prev attributes of a Node instance in python,
I get this error:

TypeError: No to_python (by-value) converter found for C++ type: struct Node *


Thanks in advance.

-- 
Furkan Kuru


From roman.yakovenko at gmail.com  Tue Sep  4 13:54:52 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Tue, 4 Sep 2007 14:54:52 +0300
Subject: [C++-sig] py++ na namespace
In-Reply-To: <20070904101448.GA21592@inputwish.com>
References: <20070904101448.GA21592@inputwish.com>
Message-ID: <7465b6170709040454n2ad9fba6ufda015286f363313@mail.gmail.com>

On 9/4/07, Libor Capak <capak at inputwish.com> wrote:
>
> Hi,
>
> i'm learning py++ and i have following problem:
>
> c++:
>
> namespace A { void foo(); }
>
> generated file by py++ contains something like that:
>
> bp::def("foo", &A::foo);
>
> but py++ doesn't create "sub-module" A and function foo() is at
> "basic level". What about handle this situation this way: ?
>
> bp::handle<> m(PyModule_New("A"));
> bp::scope().attr("A") = m;
> bp::scope s = bp::object(m);
> def("foo", &A::foo);
>
> or did i overpass some simple solution in documentation?



Basically Boost.Python doesn't provide this functionality, so Py++. I
remember there were some problems to expose namespaces, this way. Take a
look on next link:
http://www.boost.org/libs/python/doc/tutorial/doc/html/python/techniques.html#python.creating_packages


-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070904/ea7e398b/attachment.htm>

From roman.yakovenko at gmail.com  Tue Sep  4 14:03:58 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Tue, 4 Sep 2007 15:03:58 +0300
Subject: [C++-sig] exposing pointers using boost
In-Reply-To: <3a4a8f930709040444r68b8ef1dx2c688382f866b1c7@mail.gmail.com>
References: <3a4a8f930709040444r68b8ef1dx2c688382f866b1c7@mail.gmail.com>
Message-ID: <7465b6170709040503s5b93b0dbsf285a5bbb096d8b5@mail.gmail.com>

On 9/4/07, Furkan Kuru <furkankuru at gmail.com> wrote:
>
> Hello,
>
> Is there a way to expose structs containing pointers of their types?


There is another problem here

Let's say, I have a very simple doubly-linked list.
>
> struct Node {
>         Node* next;
>         Node* prev;
>         int value;
> };
>
> I expose it like this:
>
> class_<Node>("Node")
>         .def_readwrite("value", &Node::value)
>         .def_readwrite("next", &Node::next)
>         .def_readwrite("prev", &Node::prev);
>
> When I try to access the next and prev attributes of a Node instance in
> python,
> I get this error:
>
> TypeError: No to_python (by-value) converter found for C++ type: struct
> Node *



If you would have access to Py++, it would generate the right code for you.


Here is cut and paste of the relevant code from the unittests:


struct tree_node_t{
    ...
    tree_node_t *left;
    ...
};

struct tree_node_t_wrapper : tree_node_t, bp::wrapper< tree_node_t > {
   ...

    static tree_node_t * get_right(tree_node_t const & inst ){
        return inst.right;
    }

    static void set_right( tree_node_t & inst, tree_node_t * new_value ){
        inst.right = new_value;
    }

};


   { //::tree_node_t
        typedef bp::class_< tree_node_t_wrapper > tree_node_t_exposer_t;
        tree_node_t_exposer_t tree_node_t_exposer = tree_node_t_exposer_t(
"tree_node_t", "documentation", bp::init< bp::optional<
member_variables::pointers::tree_node_t const * > >((
bp::arg("parent")=bp::object() ), "documentation") );
        bp::scope tree_node_t_scope( tree_node_t_exposer );
        tree_node_t_exposer.add_property( "right"
                    , bp::make_function( (::tree_node_t * (*)( ::tree_node_t
const & ))(&tree_node_t_wrapper::get_right), bp::return_internal_reference<
>() )
                    , bp::make_function( (void (*)( ::tree_node_t
&,::tree_node_t * ))(&tree_node_t_wrapper::set_right),
bp::with_custodian_and_ward_postcall< 1, 2 >() ));
    }

Pay attention to used call policies. They are very important.

HTH

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070904/82c6b682/attachment.htm>

From meine at informatik.uni-hamburg.de  Tue Sep  4 14:12:29 2007
From: meine at informatik.uni-hamburg.de (Hans Meine)
Date: Tue, 4 Sep 2007 14:12:29 +0200
Subject: [C++-sig] py++ na namespace
In-Reply-To: <20070904101448.GA21592@inputwish.com>
References: <20070904101448.GA21592@inputwish.com>
Message-ID: <200709041412.30075.meine@informatik.uni-hamburg.de>

Am Dienstag, 04. September 2007 12:14:48 schrieb Libor Capak:
> but py++ doesn't create "sub-module" A and function foo() is at
> "basic level". What about handle this situation this way: ?
>
> bp::handle<> m(PyModule_New("A"));
> bp::scope().attr("A") = m;
> bp::scope s = bp::object(m);
> def("foo", &A::foo);

What about pickling?  Does that work or do you get "XY is not found as 'foo'" 
or similar?

-- 
Ciao, /  /
     /--/
    /  / ANS


From roberto.delfiore at srlabs.it  Tue Sep  4 16:01:45 2007
From: roberto.delfiore at srlabs.it (Roberto Delfiore)
Date: Tue, 04 Sep 2007 16:01:45 +0200
Subject: [C++-sig] Problems building boost.python with python-debugging
Message-ID: <46DD6549.90900@srlabs.it>

I'm developing a C++ Windows Application using VC++ 2005, I need to have 
a version of boost.python that uses only debug runtime environment. 
Python25.dll needs msvcrt.dll release runtime environment.
Being a big project, in debug build I've problems mixing debug and 
release dlls runtime environments.

- I've rebuild python in debug (python_d) using Visual Studio.

- I've created "user-config.jam" file in my home dir, the file content is:
using python : 2.5 : F:\\src\\custom_python-vc80-2_5
  : # includes
  : # libs
  : <python-debugging>on ;

- I've rebuild boost-python using bjam toolset=msvc --debug-configuration
        This generates a link error:
        "undefined symbol Py_InitModule4"

In python 2.5 sources Include/modsupport.h
- I've commented out:
#define Py_InitModule4 Py_InitModule4TraceRefs

Why boost.python build doesn't know that using "python debugging", 
Py_InitModule4 is renamed????

- I've rebuild boost-python
Linking OK!!

- In my Application I've used preprocessor define BOOST_DEBUG_PYTHON

Always looking to run correctly but first time I call:
Py_Initialize();
I've an assert error:
assert((op->_ob_prev == NULL) == (op->_ob_next == NULL));
 in In python 2.5 sources Objects/object.c:
void _Py_AddToAllObjects(PyObject *op, int force)

I guess that the op->_ob_next is not correctly initialized!!

In release the application run correctly!!

How can I solve this problem?
Is it possible to use boost python without python_d Py_TRACE_REFS? (Now 
if I disable Py_TRACE_REFS I get undefined symbols, linking my 
application that use boost-python with python debug and BOOST_DEBUG_PYTHON)
My only need is to use boost.python without release runtime environments 
dll in my debug application mode.
Thanks
Regards,
Roberto Delfiore


From dave at boost-consulting.com  Tue Sep  4 19:02:39 2007
From: dave at boost-consulting.com (David Abrahams)
Date: Tue, 04 Sep 2007 13:02:39 -0400
Subject: [C++-sig] Strange problem with boost::python::scope
References: <7170F7DD-582F-4930-8992-04B71FC37D08@fusion.net.nz>
Message-ID: <87tzqaxt1s.fsf@grogan.peloton>


on Sun Sep 02 2007, Lloyd Weehuizen <lloyd-AT-fusion.net.nz> wrote:

> I then try to inherit from DataGrid in python code as follows:
>
> class CustomDataGrid(testmodule.element.DataGrid):
>      def __init__(self, tag):
>          testmodule.element.DataGrid.__init__(self, tag)
>
> And I get the following error:
>   Traceback (most recent call last):
> File "c:\projects\testmodule\datagrid.py", line 6, in __init__
>    testmodule.element.DataGrid.__init__(self, tag)
> AttributeError: 'module' object has no attribute 'DataGrid'
>
> Strangely enough the CustomDataGrid class inheritance finds the  
> object correctly, but calling the base  initializer fails.
>
> Any ideas?

I'm afraid not.  Your best bet is to debug python itself in Visual
Studio (I'm assuming you're on VC++) and find out where the exception
is being thrown.

-- 
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com

The Astoria Seminar ==> http://www.astoriaseminar.com



From dave at boost-consulting.com  Tue Sep  4 19:05:57 2007
From: dave at boost-consulting.com (David Abrahams)
Date: Tue, 04 Sep 2007 13:05:57 -0400
Subject: [C++-sig] Problems building boost.python with python-debugging
References: <46DD6549.90900@srlabs.it>
Message-ID: <87odgixswa.fsf@grogan.peloton>


on Tue Sep 04 2007, Roberto Delfiore <roberto.delfiore-AT-srlabs.it> wrote:

> I'm developing a C++ Windows Application using VC++ 2005, I need to have 
> a version of boost.python that uses only debug runtime environment. 
> Python25.dll needs msvcrt.dll release runtime environment.
> Being a big project, in debug build I've problems mixing debug and 
> release dlls runtime environments.
>
> - I've rebuild python in debug (python_d) using Visual Studio.
>
> - I've created "user-config.jam" file in my home dir, the file content is:
> using python : 2.5 : F:\\src\\custom_python-vc80-2_5
>   : # includes
>   : # libs
>   : <python-debugging>on ;
>
> - I've rebuild boost-python using bjam toolset=msvc --debug-configuration
>         This generates a link error:
>         "undefined symbol Py_InitModule4"

That's because you didn't turn python-debugging on for that build.
Try

     bjam toolset=msvc python-debugging=on --debug-configuration

       
> In python 2.5 sources Include/modsupport.h
> - I've commented out:
> #define Py_InitModule4 Py_InitModule4TraceRefs

Whoa, never modify the Python sources.

> Why boost.python build doesn't know that using "python debugging", 
> Py_InitModule4 is renamed????
>
> - I've rebuild boost-python
> Linking OK!!

You broke modsupport.h, and you shouldn't expect anything to work from
here on, even if linking succeeds.

-- 
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com

The Astoria Seminar ==> http://www.astoriaseminar.com



From ndbecker2 at gmail.com  Tue Sep  4 19:11:55 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Tue, 04 Sep 2007 13:11:55 -0400
Subject: [C++-sig] signature indentation breaks epydoc
Message-ID: <fbk3ks$4pj$1@sea.gmane.org>

C++ signature generation has incorrect indentation.  This breaks epydoc.  Here is an example:

    perm_corr(...)
        correlate a permuted input.
        @param in: input.
        @type in: vector_Complex
        @param perm: permutation mapping of input
        @type perm: vector_int
        @param coef: reference pattern
        @type coef: vector_Complex
        @param size: size of the output desired
        @type size: int
        @param stride: stride for input (def=1)
        @type stride: int
        
        C++ signature:
            perm_corr(boost::numeric::ublas::vector<std::complex<double>, boost::numeric::ublas::unbounded_array<std::complex<double>, std::allocator<std::complex<double> > > > in, boost::numeric::ublas::vector<int, boost::numeric::ublas::unbounded_array<int, std::allocator<int> > > perm, boost::numeric::ublas::vector<std::complex<double>, boost::numeric::ublas::unbounded_array<std::complex<double>, std::allocator<std::complex<double> > > > coef, int size, int stride=1) -> boost::numeric::ublas::vector<std::complex<double>, boost::numeric::ublas::unbounded_array<std::complex<double>, std::allocator<std::complex<double> > > >

The indentation on that last line screws up epydoc.  Can we fix this?



From meine at informatik.uni-hamburg.de  Wed Sep  5 11:14:18 2007
From: meine at informatik.uni-hamburg.de (Hans Meine)
Date: Wed, 5 Sep 2007 11:14:18 +0200
Subject: [C++-sig] signature indentation breaks epydoc
In-Reply-To: <fbk3ks$4pj$1@sea.gmane.org>
References: <fbk3ks$4pj$1@sea.gmane.org>
Message-ID: <200709051114.19199.meine@informatik.uni-hamburg.de>

Am Dienstag, 04. September 2007 19:11:55 schrieb Neal Becker:
> C++ signature generation has incorrect indentation.  This breaks epydoc. 
Why, what is the error?

I am using epydoc with reST and it gets nicely recognized as a description 
this way.  (After changing BPL to prepend a \n.)

If you need changes for epytext support, they should not break reST / should 
be made optional via docstring_options.

(In the end, it would be best anyhow to have a proper API for introspection 
from Python, e.g. http://www.python.org/dev/peps/pep-0362/ )

-- 
Ciao, /  /
     /--/
    /  / ANS


From roberto.delfiore at srlabs.it  Wed Sep  5 11:20:39 2007
From: roberto.delfiore at srlabs.it (Roberto Delfiore)
Date: Wed, 05 Sep 2007 11:20:39 +0200
Subject: [C++-sig] Problems building boost.python with python-debugging
In-Reply-To: <87odgixswa.fsf@grogan.peloton>
References: <46DD6549.90900@srlabs.it> <87odgixswa.fsf@grogan.peloton>
Message-ID: <46DE74E7.9030709@srlabs.it>

David Abrahams wrote:
> on Tue Sep 04 2007, Roberto Delfiore <roberto.delfiore-AT-srlabs.it> wrote:
>
>   
>> I'm developing a C++ Windows Application using VC++ 2005, I need to have 
>> a version of boost.python that uses only debug runtime environment. 
>> Python25.dll needs msvcrt.dll release runtime environment.
>> Being a big project, in debug build I've problems mixing debug and 
>> release dlls runtime environments.
>>
>> - I've rebuild python in debug (python_d) using Visual Studio.
>>
>> - I've created "user-config.jam" file in my home dir, the file content is:
>> using python : 2.5 : F:\\src\\custom_python-vc80-2_5
>>   : # includes
>>   : # libs
>>   : <python-debugging>on ;
>>
>> - I've rebuild boost-python using bjam toolset=msvc --debug-configuration
>>         This generates a link error:
>>         "undefined symbol Py_InitModule4"
>>     
>
> That's because you didn't turn python-debugging on for that build.
> Try
>
>      bjam toolset=msvc python-debugging=on --debug-configuration
>   

Everything run correctly now.
I've thought reading documentation that specifying <python-debugging>on 
in user-config.jam and watching during build:
        notice: [python-cfg]   user-specified condition: 
"<python-debugging>on"
configured the build to python-debugging. Ok, bjam Boost.python build is 
independent by its Python configuration.
Thanks a lot.


From ndbecker2 at gmail.com  Wed Sep  5 12:53:04 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Wed, 05 Sep 2007 06:53:04 -0400
Subject: [C++-sig] signature indentation breaks epydoc
References: <fbk3ks$4pj$1@sea.gmane.org>
	<200709051114.19199.meine@informatik.uni-hamburg.de>
Message-ID: <fbm1qj$hrp$1@sea.gmane.org>

Hans Meine wrote:

> Am Dienstag, 04. September 2007 19:11:55 schrieb Neal Becker:
>> C++ signature generation has incorrect indentation.  This breaks epydoc.
> Why, what is the error?
> 
> I am using epydoc with reST and it gets nicely recognized as a description
> this way.  (After changing BPL to prepend a \n.)
> 

What change did you make?  Can you send a patch?

Do you have an example of using epydoc with reST with boost::python code?



From meine at informatik.uni-hamburg.de  Wed Sep  5 13:09:58 2007
From: meine at informatik.uni-hamburg.de (Hans Meine)
Date: Wed, 5 Sep 2007 13:09:58 +0200
Subject: [C++-sig] signature indentation breaks epydoc
In-Reply-To: <fbm1qj$hrp$1@sea.gmane.org>
References: <fbk3ks$4pj$1@sea.gmane.org>
	<200709051114.19199.meine@informatik.uni-hamburg.de>
	<fbm1qj$hrp$1@sea.gmane.org>
Message-ID: <200709051309.58570.meine@informatik.uni-hamburg.de>

Am Mittwoch, 05. September 2007 12:53:04 schrieb Neal Becker:
> Hans Meine wrote:
> > Am Dienstag, 04. September 2007 19:11:55 schrieb Neal Becker:
> >> C++ signature generation has incorrect indentation.  This breaks epydoc.
> >
> > Why, what is the error?
> >
> > I am using epydoc with reST and it gets nicely recognized as a
> > description this way.  (After changing BPL to prepend a \n.)
>
> What change did you make?
Prepending \n before the "C++ signature:"

> Can you send a patch? 
It was integrated by Ralf (see the "Better introspection/apidoc extraction 
support?" thread).

-- 
Ciao, /  /
     /--/
    /  / ANS


From furkankuru at gmail.com  Wed Sep  5 15:00:17 2007
From: furkankuru at gmail.com (Furkan Kuru)
Date: Wed, 5 Sep 2007 16:00:17 +0300
Subject: [C++-sig] exposing pointers using boost
In-Reply-To: <7465b6170709040503s5b93b0dbsf285a5bbb096d8b5@mail.gmail.com>
References: <3a4a8f930709040444r68b8ef1dx2c688382f866b1c7@mail.gmail.com>
	<7465b6170709040503s5b93b0dbsf285a5bbb096d8b5@mail.gmail.com>
Message-ID: <3a4a8f930709050600v1d7b7ba4s22a46943046b4c54@mail.gmail.com>

My team-mate offered a shorter way
adding Node* while exposing the class Node:

class_<Node, Node*>("Node")
              .def_readwrite("value", &Node::value)
              .def_readwrite("next", &Node::next)
              .def_readwrite("prev", &Node::prev);

On 9/4/07, Roman Yakovenko <roman.yakovenko at gmail.com> wrote:
> On 9/4/07, Furkan Kuru <furkankuru at gmail.com> wrote:
> > Hello,
> >
> > Is there a way to expose structs containing pointers of their types?
>
> There is another problem here
>
> > Let's say, I have a very simple doubly-linked list.
> >
> > struct Node {
> >         Node* next;
> >         Node* prev;
> >         int value;
> > };
> >
> > I expose it like this:
> >
> > class_<Node>("Node")
> >         .def_readwrite("value", &Node::value)
> >         .def_readwrite("next", &Node::next)
> >         .def_readwrite("prev", &Node::prev);
> >
> > When I try to access the next and prev attributes of a Node instance in
> python,
> > I get this error:
> >
> > TypeError: No to_python (by-value) converter found for C++ type: struct
> Node *
>
>
> If you would have access to Py++, it would generate the right code for you.
>
> Here is cut and paste of the relevant code from the unittests:
>
>
> struct tree_node_t{
>     ...
>     tree_node_t *left;
>     ...
> };
>
> struct tree_node_t_wrapper : tree_node_t, bp::wrapper< tree_node_t > {
>    ...
>
>     static tree_node_t * get_right(tree_node_t const & inst ){
>         return inst.right;
>     }
>
>     static void set_right( tree_node_t & inst, tree_node_t * new_value ){
>         inst.right = new_value;
>     }
>
> };
>
>
>    { //::tree_node_t
>         typedef bp::class_< tree_node_t_wrapper > tree_node_t_exposer_t;
>         tree_node_t_exposer_t tree_node_t_exposer = tree_node_t_exposer_t(
> "tree_node_t", "documentation", bp::init< bp::optional<
> member_variables::pointers::tree_node_t const * > >((
> bp::arg("parent")=bp::object() ), "documentation") );
>         bp::scope tree_node_t_scope( tree_node_t_exposer );
>         tree_node_t_exposer.add_property( "right"
>                     , bp::make_function( (::tree_node_t * (*)( ::tree_node_t
> const & ))(&tree_node_t_wrapper::get_right),
> bp::return_internal_reference< >() )
>                     , bp::make_function( (void (*)( ::tree_node_t
> &,::tree_node_t * ))(&tree_node_t_wrapper::set_right),
> bp::with_custodian_and_ward_postcall< 1, 2 >() ));
>     }
>
> Pay attention to used call policies. They are very important.
>
> HTH
>
> --
> Roman Yakovenko
> C++ Python language binding
> http://www.language-binding.net/
> _______________________________________________
> C++-sig mailing list
> C++-sig at python.org
> http://mail.python.org/mailman/listinfo/c++-sig
>
>


-- 
Furkan Kuru


From ndbecker2 at gmail.com  Thu Sep  6 14:30:05 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Thu, 06 Sep 2007 08:30:05 -0400
Subject: [C++-sig] python-3k
Message-ID: <fbort3$9pu$1@sea.gmane.org>

Anyone looking at the impact of python-3k?



From rwgk at yahoo.com  Thu Sep  6 23:20:44 2007
From: rwgk at yahoo.com (Ralf W. Grosse-Kunstleve)
Date: Thu, 6 Sep 2007 14:20:44 -0700 (PDT)
Subject: [C++-sig] python-3k
Message-ID: <236878.80863.qm@web31104.mail.mud.yahoo.com>

I didn't get very far because even

print "hello world"

doesn't work anymore in Python 3. Therefore I cannot use our build system and all the Boost.Python unit tests will also be broken.

I decided it is best to wait for Python 2.6 and to follow the transition path as outlined here:

http://www.python.org/dev/peps/pep-3000/#compatibility-and-transition

Also, it may take a while before it is worth the effort. I couldn't find anything new in Python 3 that would be worth giving up backward compatibility, or maintaining two versions of everything. Python 3 mainly seems to be a big cleanup at this stage.

Ralf





       
____________________________________________________________________________________
Be a better Globetrotter. Get better travel answers from someone who knows. Yahoo! Answers - Check it out.
http://answers.yahoo.com/dir/?link=list&sid=396545469
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070906/9eda1f90/attachment.htm>

From ndbecker2 at gmail.com  Fri Sep  7 12:56:50 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Fri, 07 Sep 2007 06:56:50 -0400
Subject: [C++-sig] PEP-362 (function signature)
Message-ID: <fbrapv$noe$1@sea.gmane.org>

FYI, Brett Cannon has a post on python-dev regarding moving forward on
pep-362.



From martin.rosekeit at freenet.de  Fri Sep  7 15:16:55 2007
From: martin.rosekeit at freenet.de (Martin Rosekeit)
Date: Fri, 07 Sep 2007 15:16:55 +0200
Subject: [C++-sig] Problems with compiling with 'Hello World' from
	Boost::python
Message-ID: <46E14F47.7000104@freenet.de>

Moin, moin, group,

I have problems to compile the 'Hello World' from Boost::python (http://www.boost.org/libs/python/doc/tutorial/doc/html/index.html).

When I start bjam I get the following error message:
   $ bjam
   error: Could not find parent for project at '.'
   error: Did not find Jamfile or project-root.jam in any parent directory.

My test-folder:
   ~/temp$ ls
   hellp.cpp  Jamfile  Jamrules

My Jamfile:
   # This is the top of our own project tree
   project-root ;

   import python ;

   extension hello                     # Declare a Python extension called hello
   :   hello.cpp                       # source
       # requirements and dependencies for Boost.Python extensions
       <template>@boost/libs/python/build/extension
       ;

I am a little irritated, where this last line points to?


My Jamrules:
   # Boost.Build top level Jamrules

   # Set some important global variables if they haven't already been set by the
   # user on the command-line or in the environment
   path-global PYTHON_ROOT : /usr ;
   path-global PYTHON_VERSION : 2.5 ;

   # Establish this as the root of the boost installation. Most targets will want
   # $(BOOST_ROOT) in their #include path.
   path-global BOOST_ROOT : /usr/include ;

   # The current version of Boost.
   BOOST_VERSION ?= 1.33.1 ;


My ~/user-config.jam
   # Compiler configuration
   using gcc ;

   # Python configuration
   using python : 2.5 ;


Installed packets (with apt-get):
boost-build, libboost-dev, libboost-python1.33.1, libboost-python-dev, python, python2.5, python2.5-dev

cu
  Martin


-- 
<<Experience is what you get, when you don't get what you want.>>


From Matthew.Scouten at tradingtechnologies.com  Fri Sep  7 17:58:32 2007
From: Matthew.Scouten at tradingtechnologies.com (Matthew Scouten (TT))
Date: Fri, 7 Sep 2007 10:58:32 -0500
Subject: [C++-sig] Boost Python wrapper<> causing a compile error C2664 in
	vc++ 8.0
Message-ID: <32490DFF7774554A85D65D23A9F0F9380613E551@chiex01>

I am trying to wrap a class with virtual functions in c++, to be over
loaded in Python, and called from c++.

 

I have been working up to full functionality gradually but I have hit a
road block.

 

My code (trimmed to only relevant parts, with the identifiers changed to
protect the guilty): 

 

class CProofOfConcept {

public:

                int x;

 

                CProofOfConcept(void);

                //CProofOfConcept(float f);

                std::string conceptProven(std::string = "My kingdom for
a valid arg!");

                virtual std::string reality(void) const;

                std::string ProofOfCallback();

                virtual std::string sureality(void);

                virtual ~CProofOfConcept(void);

 

private:

                float y;

};

 

CProofOfConcept::CProofOfConcept()

{

                std::cout << "Creation of Information!" <<std::endl;

}

 

std::string CProofOfConcept::reality(void) const

{

                return "this is the real thing, baby!!";

}

 

std::string CProofOfConcept::ProofOfCallback()

{

                return this->reality();

}

 

class CProofOfConceptWrapper: public CProofOfConcept, public
wrapper<CProofOfConcept>

{

};

 

BOOST_PYTHON_MODULE(poc)

{

                class_<CProofOfConceptWrapper>("CPOC")

                                .def("reality",
&CProofOfConceptWrapper::reality)

                                .def_readwrite("x",
&CProofOfConceptWrapper::x)

                                .def("ProofOfCallback" ,
&CProofOfConceptWrapper::ProofOfCallback)

                                ;

}

 

And my error:

boost/python/object/value_holder.hpp(133) : error C2664:
'CProofOfConceptWrapper::CProofOfConceptWrapper(const
CProofOfConceptWrapper &)' : cannot convert parameter 1 from 'const
CProofOfConcept' to 'const CProofOfConceptWrapper &'

 

if I change:

class CProofOfConceptWrapper: public CProofOfConcept, public
wrapper<CProofOfConcept>

 

to :

                class CProofOfConceptWrapper: public CProofOfConcept //,
public wrapper<CProofOfConcept>

 

it compiles just fine.

 

In case it is relevant:

Boost version: 1.32.0

Python version: 2.5

Compiler: vc++ 8.0

 

If this is a dumb question, apologies in advance. I just learned Python
a few weeks ago, my C++ is rusty, and all I know about boost::python is
what I can find in online docs. 

 

Thanks in advance for any help you can give me.

 

 

 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070907/a248729c/attachment.htm>

From meine at informatik.uni-hamburg.de  Fri Sep  7 18:23:22 2007
From: meine at informatik.uni-hamburg.de (Hans Meine)
Date: Fri, 7 Sep 2007 18:23:22 +0200
Subject: [C++-sig] unused parameter warning in 1.34.1
Message-ID: <200709071823.22321.meine@informatik.uni-hamburg.de>

Hi!

I suspect that this is already fixed in SVN, but if not, here it is:

--- boost/python/converter/implicit.hpp~	2007-09-06 21:58:01.141553000 +0200
+++ boost/python/converter/implicit.hpp	2007-09-07 18:19:09.529179000 +0200
@@ -31,8 +31,7 @@
         void* storage = 
((rvalue_from_python_storage<Target>*)data)->storage.bytes;
 
         arg_from_python<Source> get_source(obj);
-        bool convertible = get_source.convertible();
-        BOOST_ASSERT(convertible);
+        BOOST_ASSERT(get_source.convertible());
         
         new (storage) Target(get_source());
         
-- 
Ciao, /  /
     /--/
    /  / ANS
-------------- next part --------------
A non-text attachment was scrubbed...
Name: boost_unused_parameter.diff
Type: text/x-diff
Size: 512 bytes
Desc: not available
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070907/dab26afc/attachment.diff>

From matthew.scouten at gmail.com  Fri Sep  7 18:43:21 2007
From: matthew.scouten at gmail.com (Matthew Scouten)
Date: Fri, 7 Sep 2007 11:43:21 -0500
Subject: [C++-sig] Boost Python wrapper<> causing a compile error C2664 in
	vc++ 8.0
Message-ID: <3dc9bcf00709070943s911af88vaa244e93e6cb9c00@mail.gmail.com>

I am trying to wrap a class with virtual functions in c++, to be over
loaded in Python, and called from c++.

I have been working up to full functionality gradually but I have hit
a road block.

 My code (trimmed to only relevant parts, with the identifiers changed
to protect the guilty):

 class CProofOfConcept {
public:
                int x;
                CProofOfConcept(void);
                virtual std::string reality(void) const;
                std::string ProofOfCallback();
private:
                float y;
};

CProofOfConcept::CProofOfConcept()
{
                std::cout << "Creation of Information!" <<std::endl;
}

std::string CProofOfConcept::reality(void) const
{
                return "this is the real thing, baby!!";
}

std::string CProofOfConcept::ProofOfCallback()
{
                return this->reality();
}

class CProofOfConceptWrapper: public CProofOfConcept, public
wrapper<CProofOfConcept>
{

};

BOOST_PYTHON_MODULE(poc)
{
                class_<CProofOfConceptWrapper>("CPOC")
                                .def("reality",
&CProofOfConceptWrapper::reality)
                                .def_readwrite("x", &CProofOfConceptWrapper::x)
                                .def("ProofOfCallback" ,
&CProofOfConceptWrapper::ProofOfCallback)
                                ;

}

And my error:

boost/python/object/value_holder.hpp(133) : error C2664:
'CProofOfConceptWrapper::CProofOfConceptWrapper(const
CProofOfConceptWrapper &)' : cannot convert parameter 1 from 'const
CProofOfConcept' to 'const CProofOfConceptWrapper &'

if I change:

class CProofOfConceptWrapper: public CProofOfConcept, public
wrapper<CProofOfConcept>

to :
                class CProofOfConceptWrapper: public CProofOfConcept
//, public wrapper<CProofOfConcept>

 it compiles just fine.

In case it is relevant:
Boost version: 1.32.0
Python version: 2.5
Compiler: vc++ 8.0

If this is a dumb question, apologies in advance. I just learned
Python a few weeks ago, my C++ is rusty, and all I know about
boost::python is what I can find in online docs.

Thanks in advance for any help you can give me.


From rwgk at yahoo.com  Fri Sep  7 21:37:01 2007
From: rwgk at yahoo.com (Ralf W. Grosse-Kunstleve)
Date: Fri, 7 Sep 2007 12:37:01 -0700 (PDT)
Subject: [C++-sig] signature indentation breaks epydoc
Message-ID: <824926.30328.qm@web31108.mail.mud.yahoo.com>

Nikolay Mladenov has implemented automatic generation of pythonic signatures. For example:

    fact(...)
        fact( (int)n) -> int : compute the factorial
        C++ signature:
            unsigned long fact(unsigned long)

We are planning to commit the changes next week. I don't know how this plays with epydoc. If someone is interested to try this out early, the code to be committed is here (base on svn head from this morning PDT):

http://cci.lbl.gov/~rwgk/tmp/boost_39153M.tar.gz

For related docs start here:

http://cci.lbl.gov/~rwgk/shortcuts/boost_hot/libs/python/doc/news.html

Ralf





       
____________________________________________________________________________________
Pinpoint customers who are looking for what you sell. 
http://searchmarketing.yahoo.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070907/f9b89634/attachment.htm>

From roman.yakovenko at gmail.com  Fri Sep  7 21:43:53 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Fri, 7 Sep 2007 22:43:53 +0300
Subject: [C++-sig] Problems with compiling with 'Hello World' from
	Boost::python
In-Reply-To: <46E14F47.7000104@freenet.de>
References: <46E14F47.7000104@freenet.de>
Message-ID: <7465b6170709071243t24f335eehacc4f1b4ddc946e3@mail.gmail.com>

On 9/7/07, Martin Rosekeit <martin.rosekeit at freenet.de> wrote:
>
> Moin, moin, group,
>
> I have problems to compile the 'Hello World' from Boost::python (
> http://www.boost.org/libs/python/doc/tutorial/doc/html/index.html).



It is a must to build Boost.Python using bjam, but after this you can switch
to your favorite build environment.

Here is my SCONS build script for very simple use case (one cpp file):

SharedLibrary( target=r'enums'
    , source=[
r'/home/roman/language-binding/sources/pyplusplus_dev/unittests/temp/enums.cpp'
]
    , LIBS=[ r"boost_python" ]
    , LIBPATH=[ r"",r"/home/roman/boost_cvs/libs/python/build/bin-stage" ]
    , CPPPATH=[
r"/home/roman/boost_cvs",r"/usr/include/python2.4",r"/home/roman/language-binding/sources/pyplusplus_dev/unittests/data"
]
    , CCFLAGS=[  ]
    , SHLIBPREFIX=''
    , SHLIBSUFFIX='.so'
)



-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070907/3d935274/attachment.htm>

From roman.yakovenko at gmail.com  Fri Sep  7 21:54:10 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Fri, 7 Sep 2007 22:54:10 +0300
Subject: [C++-sig] Boost Python wrapper<> causing a compile error C2664
	in vc++ 8.0
In-Reply-To: <32490DFF7774554A85D65D23A9F0F9380613E551@chiex01>
References: <32490DFF7774554A85D65D23A9F0F9380613E551@chiex01>
Message-ID: <7465b6170709071254q685cba8dt4fd0e02cf45b8568@mail.gmail.com>

On 9/7/07, Matthew Scouten (TT) <Matthew.Scouten at tradingtechnologies.com>
wrote:
>
>  I am trying to wrap a class with virtual functions in c++, to be over
> loaded in Python, and called from c++.
> I have been working up to full functionality gradually but I have hit a
> road block.
> My code (trimmed to only relevant parts, with the identifiers changed to
> protect the guilty):
>
>  class CProofOfConcept {
>
> public:
>
>                 int x;
>
>
>
>                 CProofOfConcept(void);
>
>                 //CProofOfConcept(float f);
>
>                 std::string conceptProven(std::string = "My kingdom for a
> valid arg!");
>
>                 virtual std::string reality(void) const;
>
>                 std::string ProofOfCallback();
>
>                 virtual std::string sureality(void);
>
>                 virtual ~CProofOfConcept(void);
>
>
>
> private:
>
>                 float y;
>
> };
>
>
>
> class CProofOfConceptWrapper: public CProofOfConcept, public
> wrapper<CProofOfConcept>
>
> {
>
> };
>
>
>
> BOOST_PYTHON_MODULE(poc)
>
> {
>
>                 class_<CProofOfConceptWrapper>("CPOC")
>
>                                 .def("reality",
> &CProofOfConceptWrapper::reality)
>
>                                 .def_readwrite("x",
> &CProofOfConceptWrapper::x)
>
>                                 .def("ProofOfCallback" ,
> &CProofOfConceptWrapper::ProofOfCallback)
>
>                                 ;
>
> }
>


Here is the code Py++ generated:


struct CProofOfConcept_wrapper : CProofOfConcept, bp::wrapper<
CProofOfConcept > {

    CProofOfConcept_wrapper(CProofOfConcept const & arg )
    : CProofOfConcept( arg )
      , bp::wrapper< CProofOfConcept >(){
        // copy constructor

    }

    CProofOfConcept_wrapper( )
    : CProofOfConcept( )
      , bp::wrapper< CProofOfConcept >(){
        // null constructor

    }

....

};

BOOST_PYTHON_MODULE(pyplusplus){
    bp::class_< CProofOfConcept_wrapper >( "CProofOfConcept" )
        .def( bp::init< >() )
        ....
}

P.S. If you just start with Boost.Python I suggest you to try Py++ (
http://language-binding.net/pyplusplus/documentation/tutorials/pyplusplus_gui.html).
I think you will not be disappointed.

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070907/30d1b1f7/attachment.htm>

From Matthew.Scouten at tradingtechnologies.com  Fri Sep  7 22:53:56 2007
From: Matthew.Scouten at tradingtechnologies.com (Matthew Scouten (TT))
Date: Fri, 7 Sep 2007 15:53:56 -0500
Subject: [C++-sig] Boost Python wrapper<> causing a compile error
	C2664in vc++ 8.0
In-Reply-To: <7465b6170709071254q685cba8dt4fd0e02cf45b8568@mail.gmail.com>
References: <32490DFF7774554A85D65D23A9F0F9380613E551@chiex01>
	<7465b6170709071254q685cba8dt4fd0e02cf45b8568@mail.gmail.com>
Message-ID: <32490DFF7774554A85D65D23A9F0F9380613E789@chiex01>

I looked at Py++ but it seemed to require gcc. I cannot use that because
the company uses vc++ and the binary package I am wrapping was compiled
by vc++. Was I wrong? Can I use it with vc++? If I could use a gui that
would be fantastic. I have been finding boost::python to be under
documented.    

 

Also, how automated is that gui? If py++ is just a matter of writing the
same code in  python instead of c++ templates, I am more familiar with
c++ than python. 

 

The final lib to wrap is huge and problematic. There are pointers
returned and passed to python, vectors of pointers, virtual function
callbacks to be overloaded in python, overloaded functions,  functions
with default parameters, and all of the above in all combinations. 

 

From: c++-sig-bounces at python.org [mailto:c++-sig-bounces at python.org] On
Behalf Of Roman Yakovenko
Sent: Friday, September 07, 2007 2:54 PM
To: Development of Python/C++ integration
Subject: Re: [C++-sig] Boost Python wrapper<> causing a compile error
C2664in vc++ 8.0

 

 

On 9/7/07, Matthew Scouten (TT)
<Matthew.Scouten at tradingtechnologies.com> wrote:

I am trying to wrap a class with virtual functions in c++, to be over
loaded in Python, and called from c++.
I have been working up to full functionality gradually but I have hit a
road block.
My code (trimmed to only relevant parts, with the identifiers changed to
protect the guilty): 

 class CProofOfConcept {

public:

                int x;

 

                CProofOfConcept(void);

                //CProofOfConcept(float f);

                std::string conceptProven(std::string = "My kingdom for
a valid arg!");

                virtual std::string reality(void) const;

                std::string ProofOfCallback();

                virtual std::string sureality(void);

                virtual ~CProofOfConcept(void);

 

private:

                float y;

};

 

class CProofOfConceptWrapper: public CProofOfConcept, public
wrapper<CProofOfConcept>

{

};

 

BOOST_PYTHON_MODULE(poc)

{

                class_<CProofOfConceptWrapper>("CPOC")

                                .def("reality",
&CProofOfConceptWrapper::reality)

                                .def_readwrite("x",
&CProofOfConceptWrapper::x)

                                .def("ProofOfCallback" ,
&CProofOfConceptWrapper::ProofOfCallback)

                                ;

}



Here is the code Py++ generated:


struct CProofOfConcept_wrapper : CProofOfConcept, bp::wrapper<
CProofOfConcept > {

    CProofOfConcept_wrapper(CProofOfConcept const & arg ) 
    : CProofOfConcept( arg )
      , bp::wrapper< CProofOfConcept >(){
        // copy constructor
        
    }

    CProofOfConcept_wrapper( )
    : CProofOfConcept( )
      , bp::wrapper< CProofOfConcept >(){ 
        // null constructor
    
    }
 

....

};


BOOST_PYTHON_MODULE(pyplusplus){
    bp::class_< CProofOfConcept_wrapper >( "CProofOfConcept" )    
        .def( bp::init< >() )    
        ....
}

P.S. If you just start with Boost.Python I suggest you to try Py++ (
http://language-binding.net/pyplusplus/documentation/tutorials/pyplusplu
s_gui.html ). I think you will not be disappointed. 

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/ 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070907/cfc55340/attachment.htm>

From luke.titley at naturalmotion.com  Sat Sep  8 12:56:07 2007
From: luke.titley at naturalmotion.com (Luke Titley)
Date: Sat, 8 Sep 2007 11:56:07 +0100
Subject: [C++-sig]  Using boost::python in an /clr application
Message-ID: <000001c7f206$dcde9a10$946fa8c0@NM.local>

Hey Tom,
I'm having exactly the same problem as you have described in this message.
Were you able to resolve it? If so I would very much like to hear how.
 
Kind Regards,
Luke Titley
 
 
Hi everyone!
 
I'm embedding a python interpreter in an /clr application using visual 
studio 2005. For the most simple example I created a new CLR console 
application using the visual studio project wizard and added a few lines 
of code resulting in the following .cpp file.
 
        // CRLConsoleApp.cpp : main project file.
        #include "stdafx.h"
 
        // include as unmanaged and disable warnings for __fastcall
        #pragma unmanaged
        #pragma warning(disable:4561)
 
        #include <boost/python.hpp>
 
        #pragma warning(default:4561)
        #pragma managed
 
        // just a simple function
        int sampleFunction()
        {
               return 42;
        }
 
        // initialize a sample modul
        void initSampleModul()
        {
               boost::python::def("sampleFunction",sampleFunction);
        }
 
        int main(array<System::String ^> ^args)
        {
            return 0;
        }
 
This works perfectly fine, I can compile it, I can link it, I can run 
it, I can use the sample function in a python script running in an 
embedded python interpreter.
 
Exposing a class to python is not working quite as I want it to. I 
change the above .cpp file to include to following lines of code.
 
        // most simple class to expose to python
        class SampleClass {
        };
 
        // initialize the sample modul exposing the sample class
        void initSampleModul()
        {
               boost::python::class_<SampleClass>("SampleClass");
        }
 
 
using the above code gives me two linking errors:
 
error LNK2020: unresolved token (06000007) 
boost.python.handle<_object>::<MarshalCopy>
 
error LNK2020: unresolved token (06000008) 
boost.python.handle<_object>::<MarshalDestroy>
 
The version of boost I'm using here is 1.33.1 which was build using the 
VC_80 tools and I'm using Python version 2.5.
 
The above visual studio project is linked to 
boost_python-vc80-mt-1_33_1.lib and python25.lib
 
I've done the very same thing (linking to the same .lib files using 
mostly the same code except /clr specific parts) in a win32 console 
application and exposing the sample class to python works as expected. I 
can use the class in my embedded python interpreter....  just doing that 
in an CLR application is not working.
 
I'm very thankful for any help I can get!
 
best regards,
Tom

 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070908/5e70d3aa/attachment.htm>

From johann.borck at densedata.com  Mon Sep 10 00:33:58 2007
From: johann.borck at densedata.com (Johann Borck)
Date: Mon, 10 Sep 2007 00:33:58 +0200
Subject: [C++-sig] Python 3
Message-ID: <46E474D6.3060302@densedata.com>

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1


Hi all,
Are there any plans regarding  boost.python wrt Py3K? Maybe someone
here could say something about the extent of C-API changes that'll
require changes to boost.python? And then I'd like to ask the
developers of boost.python for their estimation how (un-)problematic
those changes might be.
I don't know if there's enough information about the API changes to
answer these questions. Is it likely, that Py3K will be supported
within some, maybe 12 or so, months after a stable release?

Thanks, Johann

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iD8DBQFG5HTVTaz+euYGsRERAqFyAJ4h2S1+nawhfyB7nyIDt9v0iQMsIACcDJm6
Br+VJEdUkwFdp85Vbkvl4Rc=
=kZzj
-----END PGP SIGNATURE-----



From rwgk at yahoo.com  Mon Sep 10 04:21:17 2007
From: rwgk at yahoo.com (Ralf W. Grosse-Kunstleve)
Date: Sun, 9 Sep 2007 19:21:17 -0700 (PDT)
Subject: [C++-sig] Python 3
Message-ID: <831027.90679.qm@web31104.mail.mud.yahoo.com>

See my posting from a few days ago:

http://mail.python.org/pipermail/c++-sig/2007-September/012805.html

> I don't know if there's enough information about the API changes to
> answer these questions. Is it likely, that Py3K will be supported
> within some, maybe 12 or so, months after a stable release?

Difficult to say. But I think as soon as there are good reasons to migrate someone will do it.

Ralf







       
____________________________________________________________________________________
Need a vacation? Get great deals
to amazing places on Yahoo! Travel.
http://travel.yahoo.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070909/79062751/attachment.htm>

From johann.borck at densedata.com  Mon Sep 10 17:53:56 2007
From: johann.borck at densedata.com (Johann Borck)
Date: Mon, 10 Sep 2007 17:53:56 +0200
Subject: [C++-sig] gccxml, Py++ and boost.python
Message-ID: <46E56894.5000904@densedata.com>

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1


Hi,
is there some recommended practice for working around the inability of
gccxml to parse boost.python itself when using Py++? I know it's
possible to use pythons C-API, but would like to use boost.python
inside extension modules. Maybe I should just use a preprocessor
switch to hide all boost.python related stuff from gccxml and add
those portions manually? Any suggestions/experiences/practices on
that issue?

Thanks, Johann
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iD8DBQFG5WiTTaz+euYGsRERAkQsAJ9vOWfFvw+pd3NHY6A+OP7ZL0DpbQCfZOrb
yTcSG4tASGMCuOjgzITY0RE=
=dREE
-----END PGP SIGNATURE-----



From dave at boost-consulting.com  Sun Sep  9 21:42:41 2007
From: dave at boost-consulting.com (David Abrahams)
Date: Sun, 09 Sep 2007 15:42:41 -0400
Subject: [C++-sig] Problems with compiling with 'Hello World' from
	Boost::python
References: <46E14F47.7000104@freenet.de>
Message-ID: <87ir6j62xa.fsf@grogan.peloton>


on Fri Sep 07 2007, Martin Rosekeit <martin.rosekeit-AT-freenet.de> wrote:

> Moin, moin, group,
>
> I have problems to compile the 'Hello World' from Boost::python (http://www.boost.org/libs/python/doc/tutorial/doc/html/index.html).
>
> When I start bjam I get the following error message:
>    $ bjam
>    error: Could not find parent for project at '.'
>    error: Did not find Jamfile or project-root.jam in any parent directory.

Sounds like the tutorial may be broken.
Please try the instructions at http://boost.org/libs/python/doc/building.html

> My test-folder:
>    ~/temp$ ls
>    hellp.cpp  Jamfile  Jamrules
>
> My Jamfile:
>    # This is the top of our own project tree
>    project-root ;
>
>    import python ;
>
>    extension hello                     # Declare a Python extension called hello
>    :   hello.cpp                       # source
>        # requirements and dependencies for Boost.Python extensions
>        <template>@boost/libs/python/build/extension

Okay, IIUC that's strictly a Boost.Build-v1-ism.  If so, and you got
that formula from the tutorial, the tutorial is definitely broken.


-- 
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com

The Astoria Seminar ==> http://www.astoriaseminar.com



From dave at boost-consulting.com  Sun Sep  9 21:43:57 2007
From: dave at boost-consulting.com (David Abrahams)
Date: Sun, 09 Sep 2007 15:43:57 -0400
Subject: [C++-sig] unused parameter warning in 1.34.1
References: <200709071823.22321.meine@informatik.uni-hamburg.de>
Message-ID: <87d4wr62v6.fsf@grogan.peloton>


on Fri Sep 07 2007, Hans Meine <meine-AT-informatik.uni-hamburg.de> wrote:

> Hi!
>
> I suspect that this is already fixed in SVN, but if not, here it is:
>
> --- boost/python/converter/implicit.hpp~	2007-09-06 21:58:01.141553000 +0200
> +++ boost/python/converter/implicit.hpp	2007-09-07 18:19:09.529179000 +0200
> @@ -31,8 +31,7 @@
>          void* storage = 
> ((rvalue_from_python_storage<Target>*)data)->storage.bytes;
>  
>          arg_from_python<Source> get_source(obj);
> -        bool convertible = get_source.convertible();
> -        BOOST_ASSERT(convertible);
> +        BOOST_ASSERT(get_source.convertible());
>          
>          new (storage) Target(get_source());

Please post your patch to the Trac at http://svn.boost.org

-- 
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com

The Astoria Seminar ==> http://www.astoriaseminar.com



From tegan at gnometank.net  Tue Sep 11 00:58:23 2007
From: tegan at gnometank.net (Matt Holmes)
Date: Mon, 10 Sep 2007 17:58:23 -0500
Subject: [C++-sig] Object lifetime issue
In-Reply-To: <7465b6170709040006s19609effgc0c7bceb86f770ac@mail.gmail.com>
References: <fbcrbs$m8u$1@sea.gmane.org>
	<7465b6170709040006s19609effgc0c7bceb86f770ac@mail.gmail.com>
Message-ID: <46E5CC0F.7060301@gnometank.net>

Roman Yakovenko wrote:
> On 9/2/07, *Matt Holmes* <tegan at gnometank.net 
> <mailto:tegan at gnometank.net>> wrote:
> 
>     I am trying to expose one of the classes in my engine as an abstract
>     class that is used as the base for a series of Python classes.
> 
>     That class is called InputCommand and is defined as such:
>     namespace Stasis {
>             class InputCommand {
>             public:
>                     virtual bool execute() = 0;
>             };
>     }
> 
>     To expose that class, I created the following wrapper:
> 
>     class InputCommandWrapper : public Stasis::InputCommand, public
>     wrapper<Stasis::InputCommand> {
>     public:
>             bool execute() {
>                     return this->get_override("execute")();
>             }
>     };
> 
>     And added it to my Boost.Python module like so:
> 
>     class_<InputCommandWrapper, boost::noncopyable>("InputCommand")
>             .def("execute", pure_virtual(&InputCommand::execute));
> 
>     Everything seems okay so far, but then I have another class called
>     InputManager. This class exposes a function, registerCommand, that takes
>     a const std::string& and an InputCommand*. That classes partial
>     defintion is:
> 
>     class InputManager : public Singleton<InputManager>
>     public:
>             static InputManager& getSingleton() { return *ms_Singleton; }
>             static InputManager* getSingletonPtr() { return ms_Singleton; }
> 
>             InputManager();
>             ~InputManager();
> 
>             void executeCommand(const string& cmdName);
>             void registerCommand(const string& cmdName, InputCommand* cmd);
>     }
> 
> 
> 
> Who is responsible for cmd lifetime, InputManager or somebody else? This 
> answer is a key for correct solution.
> 
> I attached 2 files that contains solution for your problem
> 
> P.S. The code is not minimal, because I extracted it from Py++ unittests
> 
> -- 
> Roman Yakovenko
> C++ Python language binding
> http://www.language-binding.net/
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> C++-sig mailing list
> C++-sig at python.org
> http://mail.python.org/mailman/listinfo/c++-sig


My apologies for not getting back to you on this sooner. InputManager 
will own the command objects. Currently one of the previous posters 
solution of having a duplicate() method that returns a new object of the 
given type works, but commands have no state, so I am okay with that. 
Later in my engine development, I will need objects that are created in 
Python to be owned by the C++ code and not have them duplicated, as I 
will need the exact objects and their state as processed by Python code. 
I will give your solution a look, thank you!.



From tegan at gnometank.net  Tue Sep 11 00:58:23 2007
From: tegan at gnometank.net (Matt Holmes)
Date: Mon, 10 Sep 2007 17:58:23 -0500
Subject: [C++-sig] Object lifetime issue
In-Reply-To: <7465b6170709040006s19609effgc0c7bceb86f770ac@mail.gmail.com>
References: <fbcrbs$m8u$1@sea.gmane.org>
	<7465b6170709040006s19609effgc0c7bceb86f770ac@mail.gmail.com>
Message-ID: <46E5CC0F.7060301@gnometank.net>

Roman Yakovenko wrote:
> On 9/2/07, *Matt Holmes* <tegan at gnometank.net 
> <mailto:tegan at gnometank.net>> wrote:
> 
>     I am trying to expose one of the classes in my engine as an abstract
>     class that is used as the base for a series of Python classes.
> 
>     That class is called InputCommand and is defined as such:
>     namespace Stasis {
>             class InputCommand {
>             public:
>                     virtual bool execute() = 0;
>             };
>     }
> 
>     To expose that class, I created the following wrapper:
> 
>     class InputCommandWrapper : public Stasis::InputCommand, public
>     wrapper<Stasis::InputCommand> {
>     public:
>             bool execute() {
>                     return this->get_override("execute")();
>             }
>     };
> 
>     And added it to my Boost.Python module like so:
> 
>     class_<InputCommandWrapper, boost::noncopyable>("InputCommand")
>             .def("execute", pure_virtual(&InputCommand::execute));
> 
>     Everything seems okay so far, but then I have another class called
>     InputManager. This class exposes a function, registerCommand, that takes
>     a const std::string& and an InputCommand*. That classes partial
>     defintion is:
> 
>     class InputManager : public Singleton<InputManager>
>     public:
>             static InputManager& getSingleton() { return *ms_Singleton; }
>             static InputManager* getSingletonPtr() { return ms_Singleton; }
> 
>             InputManager();
>             ~InputManager();
> 
>             void executeCommand(const string& cmdName);
>             void registerCommand(const string& cmdName, InputCommand* cmd);
>     }
> 
> 
> 
> Who is responsible for cmd lifetime, InputManager or somebody else? This 
> answer is a key for correct solution.
> 
> I attached 2 files that contains solution for your problem
> 
> P.S. The code is not minimal, because I extracted it from Py++ unittests
> 
> -- 
> Roman Yakovenko
> C++ Python language binding
> http://www.language-binding.net/
> 
> 
> ------------------------------------------------------------------------
> 
> _______________________________________________
> C++-sig mailing list
> C++-sig at python.org
> http://mail.python.org/mailman/listinfo/c++-sig


My apologies for not getting back to you on this sooner. InputManager 
will own the command objects. Currently one of the previous posters 
solution of having a duplicate() method that returns a new object of the 
given type works, but commands have no state, so I am okay with that. 
Later in my engine development, I will need objects that are created in 
Python to be owned by the C++ code and not have them duplicated, as I 
will need the exact objects and their state as processed by Python code. 
I will give your solution a look, thank you!.


From greg at smolyn.org  Tue Sep 11 14:34:41 2007
From: greg at smolyn.org (Greg Smolyn)
Date: Tue, 11 Sep 2007 12:34:41 +0000 (UTC)
Subject: [C++-sig] =?utf-8?q?Can=27t_import_boost=5Fpython_module_in_Mac_O?=
	=?utf-8?q?S_X?=
Message-ID: <loom.20070911T142608-620@post.gmane.org>

Hi, I'm having a problem with boost_python and Mac OS X. 
 I'm using the same build system (more or 
less) and on Linux it works just fine. 

I have a simple module:

BOOST_PYTHON_MODULE(pycov)
{
  def("consensus", consensus, "Build a consensus tree");
}

where consensus is 
std::string consensus(std::string in, double scale)

I build with:
/usr/bin/c++    -g -bundle -headerpad_max_install_names  -o libpycov.so 
"CMakeFiles/pycov.dir/wrappers/python.o" 
-L/Users/smolyn/school/bio/libcov/build/src 
-L/opt/local/lib -lboost_python -F/opt/local/Library/Frameworks 
-framework Python -lcov 

Which produces a proper bundle that links to all the right things:
]]] otool -L libpycov.so   
libpycov.so:
        /opt/local/lib/libboost_python-1_34.dylib (compatibility version 0.0.0, 
	current version 0.0.0)
        /opt/local/Library/Frameworks/Python.framework/Versions/2.4/Python 
	(compatibility version 2.4.0, current version 2.4.0)
        /Users/smolyn/school/bio/libcov/build/src/libcov.dylib (compatibility 
	version 0.0.0, current version 0.0.0)
        /usr/lib/libstdc++.6.dylib (compatibility version 7.0.0, current version 7.4.0)
        /usr/lib/libgcc_s.1.dylib (compatibility version 1.0.0, current version 1.0.0)
        /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 88.3.9)

BUT, when I try to import it into python, I get the following!

Python 2.4.4 (#1, May 25 2007, 15:00:28) 
[GCC 4.0.1 (Apple Computer, Inc. build 5367)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
]]] import pycov
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: attribute name must be string

Does anyone have _any_ ideas?  I'm stumped, I've tried everything!  
What's weird is this works absolutely 
fine in Linux.

Thanks.
-greg












From dave at boost-consulting.com  Tue Sep 11 17:06:46 2007
From: dave at boost-consulting.com (David Abrahams)
Date: Tue, 11 Sep 2007 11:06:46 -0400
Subject: [C++-sig] Can't import boost_python module in Mac OS X
References: <loom.20070911T142608-620@post.gmane.org>
Message-ID: <87k5qxxmux.fsf@grogan.peloton>


on Tue Sep 11 2007, Greg Smolyn <greg-AT-smolyn.org> wrote:

> Does anyone have _any_ ideas?  I'm stumped, I've tried everything!  
> What's weird is this works absolutely 
> fine in Linux.

My wild guess is that something on OSX  is doing 

  #define string wstring

You might try running your extension module through the preprocessor
to see what's happening.


Really, the only way to debug this is to run gdb on python itself and
set a breakpoint in the function that is used to throw exceptions, so
you can see what it's actually complaining about.

-- 
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com

The Astoria Seminar ==> http://www.astoriaseminar.com



From a.schmolck at gmx.net  Tue Sep 11 17:20:37 2007
From: a.schmolck at gmx.net (Alexander Schmolck)
Date: Tue, 11 Sep 2007 16:20:37 +0100
Subject: [C++-sig] numpy.ndarrays as C++ arrays
Message-ID: <yfsir6hqldm.fsf@gmx.net>

Hi,

I'm working working on an existing scientific code base that's mostly C++ and
I'm currently interfacing it to python with boost.python with a view to doing
non-performance critical things in python. The code currently mostly just uses
plain C double arrays passed around by pointers and I'd like to encapsulate
this at least with something like stl::vector (or maybe valarray), but I've
been wondering whether it might not make sense to use (slightly wrapped) numpy
ndarrays -- since I eventually plan to make fairly heavy use of existing
python infrastructure like matplotlib and scipy where possible. Also, ndarrays
provide fairly rich functionality even at the C-API-level and I'm pretty
familiar with numpy. Furthermore I can't find something equivalent to numpy
for C++ -- there's ublas as well as several other matrix libs and a couple of
array ones (like blitz++), but there doesn't seem to be one obvious choice, as
there is for python. I think I will mostly use double arrays of fairly large
size, so having really low overhead operations on small arrays with more or
less exotic types is not important to me.

Things that would eventually come in handy, although they're not needed yet,
are basic linear algebra and maybe two or three LAPACK-level functions (I can
think of cholesky decomposition and SVD right now) as well as possibly
wavelets (DWT). I think I could get all these things (and more) from scipy
with too much fuzz (although I haven't tried wavelets support yet) and it
seems like picking together the same functionality from different C++ libs
would require considerably more work.

So my question is: might it make sense to use (a slightly wrapped)
numpy.ndarray, and if so is some code already floating around for that (on
first glance it seems like there's a bit of support for the obsolete Numeric
package in boost, but none for the newer numpy that supercedes it); if not is
my impression correct that making the existing code numpy compatible shouldn't
be too much work.

Provided this route doesn't make much sense, I'd also be curious what people
would recommend doing instead.

many thanks,

'as


From nickm at sitius.com  Tue Sep 11 19:23:53 2007
From: nickm at sitius.com (Nikolay Mladenov)
Date: Tue, 11 Sep 2007 13:23:53 -0400
Subject: [C++-sig] Signatures/docstrings patch
Message-ID: <46E6CF29.2833E304@sitius.com>

Hi all,

A patch was applied to the boost.python svn repository,
which allows pythonic signatures to be included in the 
generated docstrings

Bellow is a small example of how the docstrings may look 
(it is docstrings_options dependent):


>>> help(ugui.AngleField.value)
Help on method value:

value(...) unbound sitius.ugui.AngleField method
    value( (AngleField)self) -> Angle :
       returns the field's value
    value( (AngleField)self, (Angle)angle [,
(bool)invoke_callback=False]) -> AngleField :
       Sets the value of the field and optionally invokes the activate
callback



the patch also adds docstring support for enums.


Nikolay Mladenov



From greg at smolyn.org  Tue Sep 11 19:29:29 2007
From: greg at smolyn.org (Greg Smolyn)
Date: Tue, 11 Sep 2007 17:29:29 +0000 (UTC)
Subject: [C++-sig]
	=?utf-8?q?Can=27t_import_boost=5Fpython_module_in_Mac_O?=
	=?utf-8?q?S_X?=
References: <loom.20070911T142608-620@post.gmane.org>
	<87k5qxxmux.fsf@grogan.peloton>
Message-ID: <loom.20070911T191903-584@post.gmane.org>

David Abrahams <dave <at> boost-consulting.com> writes:


> Really, the only way to debug this is to run gdb on python itself and
> set a breakpoint in the function that is used to throw exceptions, so
> you can see what it's actually complaining about.
> 

Ok, I did that, and I get this:

#0  PyErr_Restore (type=0x94e0, value=0x3acd0, traceback=0x0) at 
Python/errors.c:22
#1  0x002954f2 in PyErr_SetString (exception=0x94e0, string=0x20cf710 
"attribute name must be string") at Python/errors.c:51
#2  0x02042170 in PyObject_SetAttr (v=0x5b1b0, name=0x5ac00, 
value=0x609940) at Objects/object.c:1128
#3  0x00793279 in boost::python::objects::function::add_to_namespace ()
#4  0x0079699f in boost::python::detail::scope_setattr_doc ()
#5  0x007085a1 in boost::python::detail::def_from_helper<std::string (*)(
std::string, double), boost::python::detail::def_helper<char [87], 
boost::python::detail::not_specified, boost::python::detail::not_specified, 
boost::python::detail::not_specified> > (name=
0x707810 "consensus", fn=@0xbfffd774, helper=@0xbfffd738) at 
/opt/local/include/boost-1_34/boost/python/def.hpp:42
#6  0x007089ab in boost::python::detail::def_maybe_overloads<std::string (*)(
std::string, double), char [87]> (name=0x707810 "consensus", fn=0x7075a2 
<consensus(std::string, double)>, a1=@0x7077b8) at 
/opt/local/include/boost-1_34/boost/python/def.hpp:65
#7  0x007089d4 in boost::python::def<std::string (*)(std::string, double), 
char [87]>  (name=0x707810 "consensus", arg1=0x7075a2 <consensus(std::string,
 double)>, arg2=@0x7077b8) at 
/opt/local/include/boost-1_34/boost/python/def.hpp:97
#8  0x007076fb in init_module_pycov () at /Users/smolyn/school/bio/libcov/src/
wrappers/python.cpp:23
[...]

What's interesting is that at frame #2, it does a PyString_Check(name), 
which does a typecheck that name.ob_type == &PyString_Type.  
This, apparently, fails.  The interesting part is that in gdb, 
I get name.ob_type == &PyString_Type to be TRUE.

Inspecting name shows it to definitely be a PyString_Type. 
I wish I knew what gives!

-greg











From paustin at eos.ubc.ca  Tue Sep 11 19:46:31 2007
From: paustin at eos.ubc.ca (Philip Austin)
Date: Tue, 11 Sep 2007 10:46:31 -0700
Subject: [C++-sig] [Numpy-discussion] numpy.ndarrays as C++ arrays
	(wrapped with boost)
In-Reply-To: <yfsk5qxnoia.fsf@gmx.net>
References: <yfsk5qxnoia.fsf@gmx.net>
Message-ID: <18150.54391.274768.497392@owl.eos.ubc.ca>

Alexander Schmolck writes:

 > So my question is: might it make sense to use (a slightly wrapped)
 > numpy.ndarray, and if so is some code already floating around for that (on
 > first glance it seems like there's a bit of support for the obsolete Numeric
 > package in boost, but none for the newer numpy that supercedes it); if not is
 > my impression correct that making the existing code numpy compatible shouldn't
 > be too much work.

Right, it should work more or less as is if you just do:

set_module_and_type("numpy", "ArrayType");

in the examples.  Some tests will fail because of numpy changes to
function signatures, etc.

The current library doesn't wrap numpy.zeros, numpy.ones or
numpy.empty constructors, so the only way to construct an empty
is to pass the constructor a tuple and then resize.  Because
it (by design) doesn't include arrayobject.h, there's also no clean
way to get at the underlying data pointer to share the memory.  You
can use helper functions like this, though:

//Create a one-dimensional numpy array of length n and type t
boost::python::numeric::array makeNum(intp n, PyArray_TYPES t=PyArray_DOUBLE){
  object obj(handle<>(PyArray_FromDims(1, &n, t)));
  return extract<boost::python::numeric::array>(obj);
}

http://www.eos.ubc.ca/research/clouds/software/pythonlibs/num_util/num_util_release2/Readme.html

has more examples -- Phil



From dave at boost-consulting.com  Tue Sep 11 22:02:12 2007
From: dave at boost-consulting.com (David Abrahams)
Date: Tue, 11 Sep 2007 16:02:12 -0400
Subject: [C++-sig] Can't import boost_python module in Mac OS X
References: <loom.20070911T142608-620@post.gmane.org>
	<87k5qxxmux.fsf@grogan.peloton>
	<loom.20070911T191903-584@post.gmane.org>
Message-ID: <87tzq1ug1n.fsf@grogan.peloton>


on Tue Sep 11 2007, Greg Smolyn <greg-AT-smolyn.org> wrote:

>> Really, the only way to debug this is to run gdb on python itself and
>> set a breakpoint in the function that is used to throw exceptions, so
>> you can see what it's actually complaining about.
>> 
>
> Ok, I did that, and I get this:
>
> #0  PyErr_Restore (type=0x94e0, value=0x3acd0, traceback=0x0) at 
> Python/errors.c:22
> #1  0x002954f2 in PyErr_SetString (exception=0x94e0, string=0x20cf710 
> "attribute name must be string") at Python/errors.c:51
> #2  0x02042170 in PyObject_SetAttr (v=0x5b1b0, name=0x5ac00, 
> value=0x609940) at Objects/object.c:1128
> #3  0x00793279 in boost::python::objects::function::add_to_namespace ()
> #4  0x0079699f in boost::python::detail::scope_setattr_doc ()
> #5  0x007085a1 in boost::python::detail::def_from_helper<std::string (*)(
> std::string, double), boost::python::detail::def_helper<char [87], 
> boost::python::detail::not_specified, boost::python::detail::not_specified, 
> boost::python::detail::not_specified> > (name=
> 0x707810 "consensus", fn=@0xbfffd774, helper=@0xbfffd738) at 
> /opt/local/include/boost-1_34/boost/python/def.hpp:42
> #6  0x007089ab in boost::python::detail::def_maybe_overloads<std::string (*)(
> std::string, double), char [87]> (name=0x707810 "consensus", fn=0x7075a2 
> <consensus(std::string, double)>, a1=@0x7077b8) at 
> /opt/local/include/boost-1_34/boost/python/def.hpp:65
> #7  0x007089d4 in boost::python::def<std::string (*)(std::string, double), 
> char [87]>  (name=0x707810 "consensus", arg1=0x7075a2 <consensus(std::string,
>  double)>, arg2=@0x7077b8) at 
> /opt/local/include/boost-1_34/boost/python/def.hpp:97
> #8  0x007076fb in init_module_pycov () at /Users/smolyn/school/bio/libcov/src/
> wrappers/python.cpp:23
> [...]
>
> What's interesting is that at frame #2, it does a PyString_Check(name), 
> which does a typecheck that name.ob_type == &PyString_Type.  
> This, apparently, fails.  The interesting part is that in gdb, 
> I get name.ob_type == &PyString_Type to be TRUE.
>
> Inspecting name shows it to definitely be a PyString_Type. 
> I wish I knew what gives!

It should be possible to set a conditional breakpoint in
PyObject_SetAttr that checks for the particular string you're passing,
so you can trace each step from there.

Good luck,

-- 
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com

The Astoria Seminar ==> http://www.astoriaseminar.com



From a.schmolck at gmx.net  Wed Sep 12 00:25:45 2007
From: a.schmolck at gmx.net (Alexander Schmolck)
Date: Tue, 11 Sep 2007 23:25:45 +0100
Subject: [C++-sig] [Numpy-discussion] numpy.ndarrays as C++ arrays
	(wrapped with boost)
In-Reply-To: <18150.54391.274768.497392@owl.eos.ubc.ca> (Philip Austin's
	message of "Tue\, 11 Sep 2007 10\:46\:31 -0700")
References: <yfsk5qxnoia.fsf@gmx.net>
	<18150.54391.274768.497392@owl.eos.ubc.ca>
Message-ID: <yfs7imwn8k6.fsf@gmx.net>

Philip Austin <paustin at eos.ubc.ca> writes:

> Alexander Schmolck writes:
>
>  > So my question is: might it make sense to use (a slightly wrapped)
>  > numpy.ndarray, and if so is some code already floating around for that (on
>  > first glance it seems like there's a bit of support for the obsolete Numeric
>  > package in boost, but none for the newer numpy that supercedes it); if not is
>  > my impression correct that making the existing code numpy compatible shouldn't
>  > be too much work.
>
> Right, it should work more or less as is if you just do:
>
> set_module_and_type("numpy", "ArrayType");

Ah, I guess that's the advantage of going via python, rather than calling the
C-api directly (although I assume it must be rather costly).

>
> in the examples.  Some tests will fail because of numpy changes to
> function signatures, etc.
>
> The current library doesn't wrap numpy.zeros, numpy.ones or
> numpy.empty constructors, so the only way to construct an empty
> is to pass the constructor a tuple and then resize.  Because
> it (by design) doesn't include arrayobject.h, there's also no clean
> way to get at the underlying data pointer to share the memory.

Not being able to get at the data-pointer sounds like a show-stopper for this
purpose -- I will almost certainly need to interface to exisitng C and C++
code, and I do not intend to copy hundres of MB around unnecessarily.

I think it is a real shame that boost currently doesn't properly support numpy
out of the box, although numpy has long obsoleted both numarray and Numeric
(which is both buggy and completely unsupported). All the more so since
writing multimedial or scientific extensions (in which numpy's array interface
is very natural to figure prominently) would seem such an ideal use for
boost.python, as soon as complex classes or compound structures that need to
efficiently support several (primitive) datatypes are involved, boost.python
could really play its strenghts compared to Fortran/C based extensions.

I've since stumbled (in the numpy-list) upon

<http://thread.gmane.org/gmane.comp.python.c++/11559/focus=11560>

which seems like it could offer a great fit for my needs, but unfortunately
it's not really documented and there's also no indication how ready for use it
is -- I'd be interested to hear if anyone has an experience-report to offer;
if not I guess I might just end up settling for std::vector for the time
being, I need something workable soon, and it doesn't look like it'd be able
to figure it out and verify that it works for me without a substantial time
investment.


> You can use helper functions like this, though:
>
> //Create a one-dimensional numpy array of length n and type t
> boost::python::numeric::array makeNum(intp n, PyArray_TYPES t=PyArray_DOUBLE){
>   object obj(handle<>(PyArray_FromDims(1, &n, t)));
>   return extract<boost::python::numeric::array>(obj);
> }
>
> http://www.eos.ubc.ca/research/clouds/software/pythonlibs/num_util/num_util_release2/Readme.html

Thanks! This looks rather useful, I will try it on some data I need to convert
to pass to python tomorrow.

alex


From fullung at gmail.com  Wed Sep 12 01:21:12 2007
From: fullung at gmail.com (Albert Strasheim)
Date: Wed, 12 Sep 2007 01:21:12 +0200
Subject: [C++-sig] [Numpy-discussion] numpy.ndarrays as C++
	arrays(wrapped with boost)
References: <yfsk5qxnoia.fsf@gmx.net><18150.54391.274768.497392@owl.eos.ubc.ca>
	<yfs7imwn8k6.fsf@gmx.net>
Message-ID: <01c001c7f4ca$718bb1a0$a885e892@sun.ac.za>

Hello

> I've since stumbled (in the numpy-list) upon
>
> <http://thread.gmane.org/gmane.comp.python.c++/11559/focus=11560>
>
> which seems like it could offer a great fit for my needs, but 
> unfortunately
> it's not really documented and there's also no indication how ready for 
> use it
> is -- I'd be interested to hear if anyone has an experience-report to 
> offer;
> if not I guess I might just end up settling for std::vector for the time
> being, I need something workable soon, and it doesn't look like it'd be 
> able
> to figure it out and verify that it works for me without a substantial 
> time
> investment.

That code is what it is -- a basic idea for better integration between 
C++/Boost.Python and NumPy. The tests pass, but that's more less all I can 
say for it.

I don't foresee that I will work on that code again, so anyone should feel 
free to use it as a base for building something bigger and/or better. 
However, as you noted, there's going to be some substantial time investment.

Cheers,

Albert 



From ndbecker2 at gmail.com  Wed Sep 12 03:12:44 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Tue, 11 Sep 2007 21:12:44 -0400
Subject: [C++-sig] Signatures/docstrings patch
References: <46E6CF29.2833E304@sitius.com>
Message-ID: <fc7eep$b1a$1@sea.gmane.org>

Nikolay Mladenov wrote:

> Hi all,
> 
> A patch was applied to the boost.python svn repository,
> which allows pythonic signatures to be included in the
> generated docstrings
> 
> Bellow is a small example of how the docstrings may look
> (it is docstrings_options dependent):
> 
> 
>>>> help(ugui.AngleField.value)
> Help on method value:
> 
> value(...) unbound sitius.ugui.AngleField method
>     value( (AngleField)self) -> Angle :
>        returns the field's value
>     value( (AngleField)self, (Angle)angle [,
> (bool)invoke_callback=False]) -> AngleField :
>        Sets the value of the field and optionally invokes the activate
> callback
> 
> 
> 
> the patch also adds docstring support for enums.
> 
> 
> Nikolay Mladenov

Causes the following breakage in my code, any ideas?
/usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: error: no matching function for call to 'boost::python::detail::shared_ptr_to_python_value<boost::shared_ptr<filter<double> >&>::get_pytype(boost::type<boost::shared_ptr<filter<double> >&>*) const'
/usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: note: candidates are: const PyTypeObject* boost::python::detail::shared_ptr_to_python_value<T>::get_pytype() const [with T = boost::shared_ptr<filter<double> >&]



From a.schmolck at gmx.net  Wed Sep 12 12:36:42 2007
From: a.schmolck at gmx.net (Alexander Schmolck)
Date: Wed, 12 Sep 2007 11:36:42 +0100
Subject: [C++-sig] [Numpy-discussion] numpy.ndarrays as C++
	arrays(wrapped with boost)
In-Reply-To: <01c001c7f4ca$718bb1a0$a885e892@sun.ac.za> (Albert Strasheim's
	message of "Wed\, 12 Sep 2007 01\:21\:12 +0200")
References: <yfsk5qxnoia.fsf@gmx.net>
	<18150.54391.274768.497392@owl.eos.ubc.ca> <yfs7imwn8k6.fsf@gmx.net>
	<01c001c7f4ca$718bb1a0$a885e892@sun.ac.za>
Message-ID: <yfs1wd4jhl1.fsf@gmx.net>

"Albert Strasheim" <fullung at gmail.com> writes:

> That code is what it is -- a basic idea for better integration between 
> C++/Boost.Python and NumPy. The tests pass, but that's more less all I can 
> say for it.
>
> I don't foresee that I will work on that code again, so anyone should feel 
> free to use it as a base for building something bigger and/or better. 
> However, as you noted, there's going to be some substantial time investment.

Thanks, this is quite useful (if a bit disappointing) to know. I hope
eventually someone will build on your work and that it'll end up in the
distribution, but I guess I'll need to shop for another solution for the time
being.

cheers,

'as


From furkankuru at gmail.com  Wed Sep 12 12:45:26 2007
From: furkankuru at gmail.com (Furkan Kuru)
Date: Wed, 12 Sep 2007 13:45:26 +0300
Subject: [C++-sig]  Extracting inherited class instances
Message-ID: <3a4a8f930709120345x69746bb4kf07c070dd934e68e@mail.gmail.com>

Hello,

I have a class exposed to python and extract it like this;

X& xins = boost::python::extract<X&> (xList.pop())    ( xList is a python
list)

And now I need a change and want to derive a class from X.

Actually I will need several classes derived from X.

I know how to expose them to python but I do not know how to extract and
manage them?

The only thing that comes to my mind is writing too many try catch blocks
nested.

int
len=boost::python::len(xList);

for(int i=0;i<len;i++) {

boost::python::object cur = xList.pop();

try {

Y& xins = boost::python::extract<Y&> (cur);

YHandler(Y);

}

catch(...) {

try {

Z& xins = boost::python::extract<Z&> (cur);

ZHandler(Z);

}

catch(...) {

... nested ugly structure goes on like this

}

}

}
Any help is appreciated.
-- 
Furkan Kuru
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070912/f4a10f4d/attachment.htm>

From johann.borck at densedata.com  Wed Sep 12 13:50:41 2007
From: johann.borck at densedata.com (Johann Borck)
Date: Wed, 12 Sep 2007 13:50:41 +0200
Subject: [C++-sig] Extracting inherited class instances
In-Reply-To: <3a4a8f930709120345x69746bb4kf07c070dd934e68e@mail.gmail.com>
References: <3a4a8f930709120345x69746bb4kf07c070dd934e68e@mail.gmail.com>
Message-ID: <46E7D291.8040900@densedata.com>

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Furkan Kuru wrote:
> Hello,
>
> I have a class exposed to python and extract it like this; ..
>
> int
>
> len=boost::python::len(xList); for(int i=0;i<len;i++) {
>
> boost::python::object cur = xList.pop();
>
> try {
>
> Y& xins = boost::python::extract<Y&> (cur);
>
> YHandler(Y);
>
> }
>
> catch(...) {
>

Is there a reason  why you don't use check()?
like
       bp::extract<Y&> x (cur);
       if (x.check()){ YHandler(x()); }

it at least seems to reduce the ugliness of the nested structure.

Johann

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iD8DBQFG59KRTaz+euYGsRERAsojAKCLrL6EEqXUPYe7BH3dR0zeWJFJYACfQND1
vOzP8qvGTWSZU5HEbSYP4s8=
=d5Rx
-----END PGP SIGNATURE-----



From charlesr.harris at gmail.com  Wed Sep 12 13:56:23 2007
From: charlesr.harris at gmail.com (Charles R Harris)
Date: Wed, 12 Sep 2007 05:56:23 -0600
Subject: [C++-sig] [Numpy-discussion] numpy.ndarrays as C++ arrays
	(wrapped with boost)
In-Reply-To: <yfs7imwn8k6.fsf@gmx.net>
References: <yfsk5qxnoia.fsf@gmx.net>
	<18150.54391.274768.497392@owl.eos.ubc.ca> <yfs7imwn8k6.fsf@gmx.net>
Message-ID: <e06186140709120456vf515e9drc1462da7be300c6@mail.gmail.com>

On 9/11/07, Alexander Schmolck <a.schmolck at gmx.net> wrote:
>
> Philip Austin <paustin at eos.ubc.ca> writes:
>
> > Alexander Schmolck writes:
> >
> >  > So my question is: might it make sense to use (a slightly wrapped)
> >  > numpy.ndarray, and if so is some code already floating around for
> that (on
> >  > first glance it seems like there's a bit of support for the obsolete
> Numeric
> >  > package in boost, but none for the newer numpy that supercedes it);
> if not is
> >  > my impression correct that making the existing code numpy compatible
> shouldn't
> >  > be too much work.
> >
> > Right, it should work more or less as is if you just do:
> >
> > set_module_and_type("numpy", "ArrayType");
>
> Ah, I guess that's the advantage of going via python, rather than calling
> the
> C-api directly (although I assume it must be rather costly).
>
> >
> > in the examples.  Some tests will fail because of numpy changes to
> > function signatures, etc.
> >
> > The current library doesn't wrap numpy.zeros, numpy.ones or
> > numpy.empty constructors, so the only way to construct an empty
> > is to pass the constructor a tuple and then resize.  Because
> > it (by design) doesn't include arrayobject.h, there's also no clean
> > way to get at the underlying data pointer to share the memory.
>
> Not being able to get at the data-pointer sounds like a show-stopper for
> this
> purpose -- I will almost certainly need to interface to exisitng C and C++
> code, and I do not intend to copy hundres of MB around unnecessarily.


You can get to the data pointer pretty easily through the buffer interface
if you just need contiguous memory. If you keep the dirty details on the
Python side, you can do something like:

#include <boost/python.hpp>
#include <stdexcept>

using namespace boost::python;

static const void* getReadBuffer(object obj, int size)
{
    int bufLen;
    void const *buffer;
    bool isReadBuffer = !PyObject_AsReadBuffer(obj.ptr(), &buffer, &bufLen);

    if (!isReadBuffer) {
        throw std::invalid_argument("Camera: buffer is not read buffer.");
    }
    if (bufLen != size) {
        throw std::invalid_argument("Camera: buffer is wrong size.");
    }
    return buffer;
}

You can certainly get fancier with shared pointers and stuff, but I can't
find the code at the moment.

I think it is a real shame that boost currently doesn't properly support
> numpy
> out of the box, although numpy has long obsoleted both numarray and
> Numeric
> (which is both buggy and completely unsupported). All the more so since
> writing multimedial or scientific extensions (in which numpy's array
> interface
> is very natural to figure prominently) would seem such an ideal use for
> boost.python, as soon as complex classes or compound structures that need
> to
> efficiently support several (primitive) datatypes are involved,
> boost.python
> could really play its strenghts compared to Fortran/C based extensions.
>
> I've since stumbled (in the numpy-list) upon
>
> <http://thread.gmane.org/gmane.comp.python.c++/11559/focus=11560>
>
> which seems like it could offer a great fit for my needs, but
> unfortunately
> it's not really documented and there's also no indication how ready for
> use it
> is -- I'd be interested to hear if anyone has an experience-report to
> offer;
> if not I guess I might just end up settling for std::vector for the time
> being, I need something workable soon, and it doesn't look like it'd be
> able
> to figure it out and verify that it works for me without a substantial
> time
> investment.
>
>
> > You can use helper functions like this, though:
> >
> > //Create a one-dimensional numpy array of length n and type t
> > boost::python::numeric::array makeNum(intp n, PyArray_TYPES
> t=PyArray_DOUBLE){
> >   object obj(handle<>(PyArray_FromDims(1, &n, t)));
> >   return extract<boost::python::numeric::array>(obj);
> > }
> >
> >
> http://www.eos.ubc.ca/research/clouds/software/pythonlibs/num_util/num_util_release2/Readme.html


Yep, that works.

If you need Cholesky for ublas, I've got templates for that. I've found
ublas quite efficient for small arrays when compiled as release code.

Chuck
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070912/16a723ad/attachment.htm>

From nickm at sitius.com  Wed Sep 12 17:22:52 2007
From: nickm at sitius.com (Nikolay Mladenov)
Date: Wed, 12 Sep 2007 11:22:52 -0400
Subject: [C++-sig] Signatures/docstrings patch
References: <46E6CF29.2833E304@sitius.com> <fc7eep$b1a$1@sea.gmane.org>
Message-ID: <46E8044C.F4E5051D@sitius.com>

Hi Neal,

Could you try substituting T with argument_type on
/usr/local/src/boost.hg/boost/python/to_python_value.hpp:109

and could you provide me with a small example so I can add it to the
tests.

Nick

Neal Becker wrote:
> 
> Nikolay Mladenov wrote:
> 
> > Hi all,
> >
> > A patch was applied to the boost.python svn repository,
> > which allows pythonic signatures to be included in the
> > generated docstrings
> >
> > Bellow is a small example of how the docstrings may look
> > (it is docstrings_options dependent):
> >
> >
> >>>> help(ugui.AngleField.value)
> > Help on method value:
> >
> > value(...) unbound sitius.ugui.AngleField method
> >     value( (AngleField)self) -> Angle :
> >        returns the field's value
> >     value( (AngleField)self, (Angle)angle [,
> > (bool)invoke_callback=False]) -> AngleField :
> >        Sets the value of the field and optionally invokes the activate
> > callback
> >
> >
> >
> > the patch also adds docstring support for enums.
> >
> >
> > Nikolay Mladenov
> 
> Causes the following breakage in my code, any ideas?
> /usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: error: no matching function for call to 'boost::python::detail::shared_ptr_to_python_value<boost::shared_ptr<filter<double> >&>::get_pytype(boost::type<boost::shared_ptr<filter<double> >&>*) const'
> /usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: note: candidates are: const PyTypeObject* boost::python::detail::shared_ptr_to_python_value<T>::get_pytype() const [with T = boost::shared_ptr<filter<double> >&]



From ndbecker2 at gmail.com  Wed Sep 12 18:09:34 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Wed, 12 Sep 2007 12:09:34 -0400
Subject: [C++-sig] Signatures/docstrings patch
Message-ID: <200709121209.35528.ndbecker2@gmail.com>

New python function sig code breaks this test case (gcc-4.1.2):

#include <boost/shared_ptr.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/class.hpp>
#include <boost/python/init.hpp>

using namespace boost::python;

struct base {};
struct concrete : public base {};

struct Test {
  Test (boost::shared_ptr<base> _x) : x (_x) {}
  boost::shared_ptr<base> x;
};

BOOST_PYTHON_MODULE(test1) {
  class_<base, boost::noncopyable> ("base", "abstract", no_init);
  class_<concrete, bases<base> > ("concrete", "concrete");
  class_<Test> ("Test", init<boost::shared_ptr<base> >())
    .def_readonly ("x", &Test::x, "x") <<<< this seems to trigger the error
  ;
}

g++ -o mod/test1.os -c -g -DBOOST_DISABLE_THREADS -O3 -ftree-vectorize -fstrict-aliasing -ffast-math -DNDEBUG -Wall -fPIC -Isrc -I/usr/local/src/boost.hg -I/usr/include/python2.5 mod/test1.cc
/usr/local/src/boost.hg/boost/python/to_python_value.hpp: In member function 'const PyTypeObject* boost::python::detail::shared_ptr_to_python_value<T>::get_pytype() const [with T = boost::shared_ptr<base>&]':
/usr/local/src/boost.hg/boost/python/detail/caller.hpp:102:   instantiated from 'static const PyTypeObject* boost::python::detail::converter_target_type<ResultConverter>::get_pytype() [with ResultConverter = boost::python::to_python_value<boost::shared_ptr<base>&>]'
/usr/local/src/boost.hg/boost/python/detail/caller.hpp:242:   instantiated from 'static boost::python::detail::py_func_sig_info boost::python::detail::caller_arity<1u>::impl<F, Policies, Sig>::signature() [with F = boost::python::detail::member<boost::shared_ptr<base>, Test>, Policies = boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, Sig = boost::mpl::vector2<boost::shared_ptr<base>&, Test&>]'
/usr/local/src/boost.hg/boost/python/object/py_function.hpp:48:   instantiated from 'boost::python::detail::py_func_sig_info boost::python::objects::caller_py_function_impl<Caller>::signature() const [with Caller = boost::python::detail::caller<boost::python::detail::member<boost::shared_ptr<base>, Test>, boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, boost::mpl::vector2<boost::shared_ptr<base>&, Test&> >]'
mod/test1.cc:22:   instantiated from here
/usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: error: no matching function for call to 'boost::python::detail::shared_ptr_to_python_value<boost::shared_ptr<base>&>::get_pytype(boost::type<boost::shared_ptr<base>&>*) const'
/usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: note: candidates are: const PyTypeObject* boost::python::detail::shared_ptr_to_python_value<T>::get_pytype() const [with T = boost::shared_ptr<base>&]
scons: *** [mod/test1.os] Error 1
scons: building terminated because of errors.

Compilation exited abnormally with code 2 at Wed Sep 12 07:18:15


From ndbecker2 at gmail.com  Wed Sep 12 18:08:38 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Wed, 12 Sep 2007 12:08:38 -0400
Subject: [C++-sig] Signatures/docstrings bug
References: <46E6CF29.2833E304@sitius.com> <fc7eep$b1a$1@sea.gmane.org>
	<46E8044C.F4E5051D@sitius.com>
Message-ID: <fc92up$f6h$2@sea.gmane.org>

New python function sig code breaks this test case (gcc-4.1.2):

#include <boost/shared_ptr.hpp>
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/class.hpp>
#include <boost/python/init.hpp>

using namespace boost::python;

struct base {};
struct concrete : public base {};

struct Test {
  Test (boost::shared_ptr<base> _x) : x (_x) {}
  boost::shared_ptr<base> x;
};

BOOST_PYTHON_MODULE(test1) {
  class_<base, boost::noncopyable> ("base", "abstract", no_init);
  class_<concrete, bases<base> > ("concrete", "concrete");
  class_<Test> ("Test", init<boost::shared_ptr<base> >())
    .def_readonly ("x", &Test::x, "x") <<<< this seems to trigger the error
  ;
}

g++ -o mod/test1.os -c -g -DBOOST_DISABLE_THREADS -O3 -ftree-vectorize -fstrict-aliasing -ffast-math -DNDEBUG -Wall -fPIC -Isrc -I/usr/local/src/boost.hg -I/usr/include/python2.5 mod/test1.cc
/usr/local/src/boost.hg/boost/python/to_python_value.hpp: In member function 'const PyTypeObject* boost::python::detail::shared_ptr_to_python_value<T>::get_pytype() const [with T = boost::shared_ptr<base>&]':
/usr/local/src/boost.hg/boost/python/detail/caller.hpp:102:   instantiated from 'static const PyTypeObject* boost::python::detail::converter_target_type<ResultConverter>::get_pytype() [with ResultConverter = boost::python::to_python_value<boost::shared_ptr<base>&>]'
/usr/local/src/boost.hg/boost/python/detail/caller.hpp:242:   instantiated from 'static boost::python::detail::py_func_sig_info boost::python::detail::caller_arity<1u>::impl<F, Policies, Sig>::signature() [with F = boost::python::detail::member<boost::shared_ptr<base>, Test>, Policies = boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, Sig = boost::mpl::vector2<boost::shared_ptr<base>&, Test&>]'
/usr/local/src/boost.hg/boost/python/object/py_function.hpp:48:   instantiated from 'boost::python::detail::py_func_sig_info boost::python::objects::caller_py_function_impl<Caller>::signature() const [with Caller = boost::python::detail::caller<boost::python::detail::member<boost::shared_ptr<base>, Test>, boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, boost::mpl::vector2<boost::shared_ptr<base>&, Test&> >]'
mod/test1.cc:22:   instantiated from here
/usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: error: no matching function for call to 'boost::python::detail::shared_ptr_to_python_value<boost::shared_ptr<base>&>::get_pytype(boost::type<boost::shared_ptr<base>&>*) const'
/usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: note: candidates are: const PyTypeObject* boost::python::detail::shared_ptr_to_python_value<T>::get_pytype() const [with T = boost::shared_ptr<base>&]
scons: *** [mod/test1.os] Error 1
scons: building terminated because of errors.

Compilation exited abnormally with code 2 at Wed Sep 12 07:18:15




From nickm at sitius.com  Wed Sep 12 23:30:27 2007
From: nickm at sitius.com (Nikolay Mladenov)
Date: Wed, 12 Sep 2007 17:30:27 -0400
Subject: [C++-sig] Signatures/docstrings bug
References: <46E6CF29.2833E304@sitius.com> <fc7eep$b1a$1@sea.gmane.org>
	<46E8044C.F4E5051D@sitius.com> <fc92up$f6h$2@sea.gmane.org>
Message-ID: <46E85A73.9E98C641@sitius.com>

Should be fixed in the repository.

Neal Becker wrote:
> 
> New python function sig code breaks this test case (gcc-4.1.2):
> 
> #include <boost/shared_ptr.hpp>
> #include <boost/python/module.hpp>
> #include <boost/python/def.hpp>
> #include <boost/python/class.hpp>
> #include <boost/python/init.hpp>
> 
> using namespace boost::python;
> 
> struct base {};
> struct concrete : public base {};
> 
> struct Test {
>   Test (boost::shared_ptr<base> _x) : x (_x) {}
>   boost::shared_ptr<base> x;
> };
> 
> BOOST_PYTHON_MODULE(test1) {
>   class_<base, boost::noncopyable> ("base", "abstract", no_init);
>   class_<concrete, bases<base> > ("concrete", "concrete");
>   class_<Test> ("Test", init<boost::shared_ptr<base> >())
>     .def_readonly ("x", &Test::x, "x") <<<< this seems to trigger the error
>   ;
> }
> 
> g++ -o mod/test1.os -c -g -DBOOST_DISABLE_THREADS -O3 -ftree-vectorize -fstrict-aliasing -ffast-math -DNDEBUG -Wall -fPIC -Isrc -I/usr/local/src/boost.hg -I/usr/include/python2.5 mod/test1.cc
> /usr/local/src/boost.hg/boost/python/to_python_value.hpp: In member function 'const PyTypeObject* boost::python::detail::shared_ptr_to_python_value<T>::get_pytype() const [with T = boost::shared_ptr<base>&]':
> /usr/local/src/boost.hg/boost/python/detail/caller.hpp:102:   instantiated from 'static const PyTypeObject* boost::python::detail::converter_target_type<ResultConverter>::get_pytype() [with ResultConverter = boost::python::to_python_value<boost::shared_ptr<base>&>]'
> /usr/local/src/boost.hg/boost/python/detail/caller.hpp:242:   instantiated from 'static boost::python::detail::py_func_sig_info boost::python::detail::caller_arity<1u>::impl<F, Policies, Sig>::signature() [with F = boost::python::detail::member<boost::shared_ptr<base>, Test>, Policies = boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, Sig = boost::mpl::vector2<boost::shared_ptr<base>&, Test&>]'
> /usr/local/src/boost.hg/boost/python/object/py_function.hpp:48:   instantiated from 'boost::python::detail::py_func_sig_info boost::python::objects::caller_py_function_impl<Caller>::signature() const [with Caller = boost::python::detail::caller<boost::python::detail::member<boost::shared_ptr<base>, Test>, boost::python::return_value_policy<boost::python::return_by_value, boost::python::default_call_policies>, boost::mpl::vector2<boost::shared_ptr<base>&, Test&> >]'
> mod/test1.cc:22:   instantiated from here
> /usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: error: no matching function for call to 'boost::python::detail::shared_ptr_to_python_value<boost::shared_ptr<base>&>::get_pytype(boost::type<boost::shared_ptr<base>&>*) const'
> /usr/local/src/boost.hg/boost/python/to_python_value.hpp:109: note: candidates are: const PyTypeObject* boost::python::detail::shared_ptr_to_python_value<T>::get_pytype() const [with T = boost::shared_ptr<base>&]
> scons: *** [mod/test1.os] Error 1
> scons: building terminated because of errors.
> 
> Compilation exited abnormally with code 2 at Wed Sep 12 07:18:15



From ndbecker2 at gmail.com  Thu Sep 13 02:42:28 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Wed, 12 Sep 2007 20:42:28 -0400
Subject: [C++-sig] [patch] signatures/docstrings formatting
Message-ID: <fca12e$i6s$1@sea.gmane.org>

# HG changeset patch
# User ndbecker2 at gmail.com
# Date 1189643327 14400
# Node ID f6e6ad1cbdc8d6c9736b3d261e6e5fd3e6823f2e
# Parent  056ace359968e07b83b67bed532796ec18f517c3
fix c++ sig

The current docstring signatures seem to confuse epydoc (using rst), because of 
unexpected indentation.  The following 2 patches seem to be a bit better:

diff -r 056ace359968 -r f6e6ad1cbdc8 libs/python/src/object/function.cpp
--- a/libs/python/src/object/function.cpp       Wed Sep 12 19:05:52 2007 -0400
+++ b/libs/python/src/object/function.cpp       Wed Sep 12 20:28:47 2007 -0400
@@ -544,9 +544,9 @@ void function::add_to_namespace(
     if (docstring_options::show_cpp_signatures_)
     {
         if(len(_doc))
-            _doc += "\n    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
+            _doc += "\n"+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
         else
-            _doc += "    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
+            _doc += str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
     }
     if(_doc)
     {    
# HG changeset patch
# User ndbecker2 at gmail.com
# Date 1189643963 14400
# Node ID 33ce4a3bb451b917b315fa2400748955f794f546
# Parent  f6e6ad1cbdc8d6c9736b3d261e6e5fd3e6823f2e
add newlines after python sig

diff -r f6e6ad1cbdc8 -r 33ce4a3bb451 libs/python/src/object/function.cpp
--- a/libs/python/src/object/function.cpp       Wed Sep 12 20:28:47 2007 -0400
+++ b/libs/python/src/object/function.cpp       Wed Sep 12 20:39:23 2007 -0400
@@ -539,7 +539,7 @@ void function::add_to_namespace(
         _doc += str(reinterpret_cast<const char*>(detail::py_signature_tag));
     }
     if (doc != 0 && docstring_options::show_user_defined_)
-        _doc += doc;
+      _doc += str("\n\n")+doc;
 
     if (docstring_options::show_cpp_signatures_)
     {



From johann.borck at densedata.com  Thu Sep 13 11:14:32 2007
From: johann.borck at densedata.com (Johann Borck)
Date: Thu, 13 Sep 2007 11:14:32 +0200
Subject: [C++-sig] Extracting inherited class instances
In-Reply-To: <3a4a8f930709120345x69746bb4kf07c070dd934e68e@mail.gmail.com>
References: <3a4a8f930709120345x69746bb4kf07c070dd934e68e@mail.gmail.com>
Message-ID: <46E8FF78.50105@densedata.com>

Furkan Kuru wrote:
> Hello,
>
> I have a class exposed to python and extract it like this; ..
>
> int
>
> len=boost::python::len(xList); for(int i=0;i<len;i++) {
>
> boost::python::object cur = xList.pop();
>
> try {
>
> Y& xins = boost::python::extract<Y&> (cur);
>
> YHandler(Y);
>
> }
>
> catch(...) {
>

Is there a reason  why you don't use check()?
like
       bp::extract<Y&> y (cur);
       if (y.check()){ YHandler(y()); }

it at least it reduces the ugliness of the nested structures,
(if needed at all).

Johann



From furkankuru at gmail.com  Thu Sep 13 13:16:58 2007
From: furkankuru at gmail.com (Furkan Kuru)
Date: Thu, 13 Sep 2007 14:16:58 +0300
Subject: [C++-sig] Extracting inherited class instances
In-Reply-To: <46E7D291.8040900@densedata.com>
References: <3a4a8f930709120345x69746bb4kf07c070dd934e68e@mail.gmail.com>
	<46E7D291.8040900@densedata.com>
Message-ID: <3a4a8f930709130416p37872d58j3d74d4f604dacc6d@mail.gmail.com>

yes, thanks
check will solve my problem.


On 9/12/07, Johann Borck <johann.borck at densedata.com> wrote:
>
> -----BEGIN PGP SIGNED MESSAGE-----
> Hash: SHA1
>
> Furkan Kuru wrote:
> > Hello,
> >
> > I have a class exposed to python and extract it like this; ..
> >
> > int
> >
> > len=boost::python::len(xList); for(int i=0;i<len;i++) {
> >
> > boost::python::object cur = xList.pop();
> >
> > try {
> >
> > Y& xins = boost::python::extract<Y&> (cur);
> >
> > YHandler(Y);
> >
> > }
> >
> > catch(...) {
> >
>
> Is there a reason  why you don't use check()?
> like
>       bp::extract<Y&> x (cur);
>       if (x.check()){ YHandler(x()); }
>
> it at least seems to reduce the ugliness of the nested structure.
>
> Johann
>
> -----BEGIN PGP SIGNATURE-----
> Version: GnuPG v1.4.5 (GNU/Linux)
> Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org
>
> iD8DBQFG59KRTaz+euYGsRERAsojAKCLrL6EEqXUPYe7BH3dR0zeWJFJYACfQND1
> vOzP8qvGTWSZU5HEbSYP4s8=
> =d5Rx
> -----END PGP SIGNATURE-----
>
> _______________________________________________
> C++-sig mailing list
> C++-sig at python.org
> http://mail.python.org/mailman/listinfo/c++-sig
>



-- 
Furkan Kuru
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070913/f230097e/attachment.htm>

From johann.borck at densedata.com  Thu Sep 13 14:08:04 2007
From: johann.borck at densedata.com (Johann Borck)
Date: Thu, 13 Sep 2007 14:08:04 +0200
Subject: [C++-sig] Extracting inherited class instances
In-Reply-To: <3a4a8f930709130416p37872d58j3d74d4f604dacc6d@mail.gmail.com>
References: <3a4a8f930709120345x69746bb4kf07c070dd934e68e@mail.gmail.com>	<46E7D291.8040900@densedata.com>
	<3a4a8f930709130416p37872d58j3d74d4f604dacc6d@mail.gmail.com>
Message-ID: <46E92824.8020500@densedata.com>

Furkan Kuru wrote:
> yes, thanks check will solve my problem.
>

sorry for the noise..
I got some strange delivery error for my post today, and resent it
without checking if it had actually reached the list.

Johann



From nickm at sitius.com  Thu Sep 13 16:40:19 2007
From: nickm at sitius.com (Nikolay Mladenov)
Date: Thu, 13 Sep 2007 10:40:19 -0400
Subject: [C++-sig] [patch] signatures/docstrings formatting
References: <fca12e$i6s$1@sea.gmane.org>
Message-ID: <46E94BD3.DD48A8F0@sitius.com>

Are you saying that every one of the two is sufficient?

Nick

Neal Becker wrote:
> 
> # HG changeset patch
> # User ndbecker2 at gmail.com
> # Date 1189643327 14400
> # Node ID f6e6ad1cbdc8d6c9736b3d261e6e5fd3e6823f2e
> # Parent  056ace359968e07b83b67bed532796ec18f517c3
> fix c++ sig
> 
> The current docstring signatures seem to confuse epydoc (using rst), because of
> unexpected indentation.  The following 2 patches seem to be a bit better:
> 
> diff -r 056ace359968 -r f6e6ad1cbdc8 libs/python/src/object/function.cpp
> --- a/libs/python/src/object/function.cpp       Wed Sep 12 19:05:52 2007 -0400
> +++ b/libs/python/src/object/function.cpp       Wed Sep 12 20:28:47 2007 -0400
> @@ -544,9 +544,9 @@ void function::add_to_namespace(
>      if (docstring_options::show_cpp_signatures_)
>      {
>          if(len(_doc))
> -            _doc += "\n    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> +            _doc += "\n"+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
>          else
> -            _doc += "    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> +            _doc += str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
>      }
>      if(_doc)
>      {
> # HG changeset patch
> # User ndbecker2 at gmail.com
> # Date 1189643963 14400
> # Node ID 33ce4a3bb451b917b315fa2400748955f794f546
> # Parent  f6e6ad1cbdc8d6c9736b3d261e6e5fd3e6823f2e
> add newlines after python sig
> 
> diff -r f6e6ad1cbdc8 -r 33ce4a3bb451 libs/python/src/object/function.cpp
> --- a/libs/python/src/object/function.cpp       Wed Sep 12 20:28:47 2007 -0400
> +++ b/libs/python/src/object/function.cpp       Wed Sep 12 20:39:23 2007 -0400
> @@ -539,7 +539,7 @@ void function::add_to_namespace(
>          _doc += str(reinterpret_cast<const char*>(detail::py_signature_tag));
>      }
>      if (doc != 0 && docstring_options::show_user_defined_)
> -        _doc += doc;
> +      _doc += str("\n\n")+doc;
> 
>      if (docstring_options::show_cpp_signatures_)
>      {



From ndbecker2 at gmail.com  Thu Sep 13 16:55:39 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Thu, 13 Sep 2007 10:55:39 -0400
Subject: [C++-sig] make_constructor, with_custodian_and_ward problems (again)
Message-ID: <fcbj1b$vn0$1@sea.gmane.org>

What's the correct way to do this?  Neither of the below .defs will compile:

multi_array_ref<int,1>* make_array_int_1 (object & o) {
  void* buffer;
  bp::ssize_t size;
  int ret = PyObject_AsWriteBuffer (o.ptr(), &buffer, &size);

  return new multi_array_ref<int,1> (static_cast<int*>(buffer),
                                 extents[size/sizeof(int)]);
}

BOOST_PYTHON_MODULE(multi_array) {
  def ("make_buffer", &make_buffer);

  class_<multi_array_ref<int,1> > ("multi_array_int_1", no_init)
    .def ("__init__", make_constructor (&make_array_int_1), with_custodian_and_ward_postcall<0,1>())
    .def ("__init__", make_constructor (&make_array_int_1, with_custodian_and_ward_postcall<0,1>()))
   ;
}

This same question was raised before, but I don't see a correct answer:
http://mail.python.org/pipermail/c++-sig/2007-June/012470.html



From hans_meine at gmx.net  Thu Sep 13 17:32:39 2007
From: hans_meine at gmx.net (Hans Meine)
Date: Thu, 13 Sep 2007 17:32:39 +0200
Subject: [C++-sig] make_constructor,
	with_custodian_and_ward problems (again)
In-Reply-To: <fcbj1b$vn0$1@sea.gmane.org>
References: <fcbj1b$vn0$1@sea.gmane.org>
Message-ID: <200709131732.40261.hans_meine@gmx.net>

On Donnerstag 13 September 2007, Neal Becker wrote:
> What's the correct way to do this?  Neither of the below .defs will
> compile:
> [...]
>   class_<multi_array_ref<int,1> > ("multi_array_int_1", no_init)
>     .def ("__init__", make_constructor (&make_array_int_1),
> with_custodian_and_ward_postcall<0,1>()) 
> .def ("__init__", make_constructor 
> (&make_array_int_1, with_custodian_and_ward_postcall<0,1>())) ;
> }
>
> This same question was raised before, but I don't see a correct answer:
> http://mail.python.org/pipermail/c++-sig/2007-June/012470.html

I was about to point you to the thread I started about the very same problem, 
but I realized last-minute that the link you posted is exactly that one.
FWIW, I have not found a solution, but still have the same problem.
(I.e. I live with the dangerous default_policies ATM.)

-- 
Ciao, /  /                                                    .o.
     /--/                                                     ..o
    /  / ANS                                                  ooo
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 189 bytes
Desc: This is a digitally signed message part.
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070913/06a334a0/attachment.pgp>

From cfinch at ieee.org  Thu Sep 13 18:46:15 2007
From: cfinch at ieee.org (Craig Finch)
Date: Thu, 13 Sep 2007 09:46:15 -0700 (PDT)
Subject: [C++-sig] Boost.python example: accessing C++ containers from
	Python using indexing suite
Message-ID: <650426.63023.qm@web30312.mail.mud.yahoo.com>

I recently figured out how to make C++ indexable containers available
to Python programs using Boost.python.  The Boost.python docs do cover
this topic, but not in enough detail to make it clear to a beginner. 
To summarize what I learned and hopefully save some time for other
programmers, I have created a simple example and made it available
through my software development blog:
http://www.shocksolution.com/blog/2007/09/13/direct-access-to-c-containers-from-python/

You will also find a number of other Boost.python tutorial examples in
previous posts.  I hope you find this useful--and if not, please let me
know how it can be improved.

   Craig Finch

--------------
Please reply to cfinch at ieee.org


       
____________________________________________________________________________________
Need a vacation? Get great deals
to amazing places on Yahoo! Travel.
http://travel.yahoo.com/


From ndbecker2 at gmail.com  Thu Sep 13 18:59:24 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Thu, 13 Sep 2007 12:59:24 -0400
Subject: [C++-sig] [patch] signatures/docstrings formatting
References: <fca12e$i6s$1@sea.gmane.org> <46E94BD3.DD48A8F0@sitius.com>
Message-ID: <fcbq9c$tvm$1@sea.gmane.org>

Nikolay Mladenov wrote:

> Are you saying that every one of the two is sufficient?
> 

Sorry if I was not clear.  Here is a single clean patch:

diff -r 056ace359968 libs/python/src/object/function.cpp
--- a/libs/python/src/object/function.cpp       Wed Sep 12 19:05:52 2007 -0400
+++ b/libs/python/src/object/function.cpp       Thu Sep 13 12:57:44 2007 -0400
@@ -539,14 +539,14 @@ void function::add_to_namespace(
         _doc += str(reinterpret_cast<const char*>(detail::py_signature_tag));
     }
     if (doc != 0 && docstring_options::show_user_defined_)
-        _doc += doc;
+      _doc += str("\n\n")+doc;
 
     if (docstring_options::show_cpp_signatures_)
     {
         if(len(_doc))
-            _doc += "\n    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
+            _doc += "\n"+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
         else
-            _doc += "    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
+            _doc += str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
     }
     if(_doc)
     {    





From nickm at sitius.com  Thu Sep 13 23:15:04 2007
From: nickm at sitius.com (Nikolay Mladenov)
Date: Thu, 13 Sep 2007 17:15:04 -0400
Subject: [C++-sig] [patch] signatures/docstrings formatting
References: <fca12e$i6s$1@sea.gmane.org> <46E94BD3.DD48A8F0@sitius.com>
	<fcbq9c$tvm$1@sea.gmane.org>
Message-ID: <46E9A858.145C6F8B@sitius.com>

The command line help output becomes very ugly...

Neal Becker wrote:
> 
> Nikolay Mladenov wrote:
> 
> > Are you saying that every one of the two is sufficient?
> >
> 
> Sorry if I was not clear.  Here is a single clean patch:
> 
> diff -r 056ace359968 libs/python/src/object/function.cpp
> --- a/libs/python/src/object/function.cpp       Wed Sep 12 19:05:52 2007 -0400
> +++ b/libs/python/src/object/function.cpp       Thu Sep 13 12:57:44 2007 -0400
> @@ -539,14 +539,14 @@ void function::add_to_namespace(
>          _doc += str(reinterpret_cast<const char*>(detail::py_signature_tag));
>      }
>      if (doc != 0 && docstring_options::show_user_defined_)
> -        _doc += doc;
> +      _doc += str("\n\n")+doc;
> 
>      if (docstring_options::show_cpp_signatures_)
>      {
>          if(len(_doc))
> -            _doc += "\n    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> +            _doc += "\n"+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
>          else
> -            _doc += "    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> +            _doc += str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
>      }
>      if(_doc)
>      {



From nickm at sitius.com  Thu Sep 13 23:23:57 2007
From: nickm at sitius.com (Nikolay Mladenov)
Date: Thu, 13 Sep 2007 17:23:57 -0400
Subject: [C++-sig] [patch] signatures/docstrings formatting
References: <fca12e$i6s$1@sea.gmane.org> <46E94BD3.DD48A8F0@sitius.com>
	<fcbq9c$tvm$1@sea.gmane.org> <46E9A858.145C6F8B@sitius.com>
Message-ID: <46E9AA6D.3DFA2300@sitius.com>

And so does the pydoc.html.document output ...
Do you have any other possible epydoc fixes which don't mess the 
standard docs that much?

Nick

Nikolay Mladenov wrote:
> 
> The command line help output becomes very ugly...
> 
> Neal Becker wrote:
> >
> > Nikolay Mladenov wrote:
> >
> > > Are you saying that every one of the two is sufficient?
> > >
> >
> > Sorry if I was not clear.  Here is a single clean patch:
> >
> > diff -r 056ace359968 libs/python/src/object/function.cpp
> > --- a/libs/python/src/object/function.cpp       Wed Sep 12 19:05:52 2007 -0400
> > +++ b/libs/python/src/object/function.cpp       Thu Sep 13 12:57:44 2007 -0400
> > @@ -539,14 +539,14 @@ void function::add_to_namespace(
> >          _doc += str(reinterpret_cast<const char*>(detail::py_signature_tag));
> >      }
> >      if (doc != 0 && docstring_options::show_user_defined_)
> > -        _doc += doc;
> > +      _doc += str("\n\n")+doc;
> >
> >      if (docstring_options::show_cpp_signatures_)
> >      {
> >          if(len(_doc))
> > -            _doc += "\n    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> > +            _doc += "\n"+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> >          else
> > -            _doc += "    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> > +            _doc += str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> >      }
> >      if(_doc)
> >      {



From ndbecker2 at gmail.com  Fri Sep 14 11:58:01 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Fri, 14 Sep 2007 05:58:01 -0400
Subject: [C++-sig] [patch] signatures/docstrings formatting
References: <fca12e$i6s$1@sea.gmane.org> <46E94BD3.DD48A8F0@sitius.com>
	<fcbq9c$tvm$1@sea.gmane.org> <46E9A858.145C6F8B@sitius.com>
	<46E9AA6D.3DFA2300@sitius.com>
Message-ID: <fcdlvf$3bc$1@sea.gmane.org>

Nikolay Mladenov wrote:

> And so does the pydoc.html.document output ...
> Do you have any other possible epydoc fixes which don't mess the
> standard docs that much?
> 
> Nick
> 
I'm not an expert in this, but I think the issue is that the markup is
restructured text, and that in rest the indentation has to be consistent.



From hans_meine at gmx.net  Fri Sep 14 12:41:21 2007
From: hans_meine at gmx.net (Hans Meine)
Date: Fri, 14 Sep 2007 12:41:21 +0200
Subject: [C++-sig] [patch] signatures/docstrings formatting
In-Reply-To: <46E9AA6D.3DFA2300@sitius.com>
References: <fca12e$i6s$1@sea.gmane.org> <46E9A858.145C6F8B@sitius.com>
	<46E9AA6D.3DFA2300@sitius.com>
Message-ID: <200709141241.22013.hans_meine@gmx.net>

On Donnerstag 13 September 2007, Nikolay Mladenov wrote:
> And so does the pydoc.html.document output ...
> Do you have any other possible epydoc fixes which don't mess the
> standard docs that much?

I have no boost CVS at hand and can only guess from reading the code, but what 
about addint two \n\n also in the second part, like this:

         if(len(_doc))
-            _doc += "\n    "+str(reinterpret_cast<const 
char*>(detail::cpp_signature_tag));
+            _doc += "\n\n  "+str(reinterpret_cast<const 
char*>(detail::cpp_signature_tag));

That should make reST interpret it as an indented quotation IIRC.  (It is just 
important that the indentation is not within a paragraph.)  I once sent a 
similar patch which first checked whether the user-defined doc already 
contained a trailing \n, in order to prevent multiple empty lines.

-- 
Ciao, /  /                                                    .o.
     /--/                                                     ..o
    /  / ANS                                                  ooo
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 189 bytes
Desc: This is a digitally signed message part.
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070914/b585645c/attachment.pgp>

From ndbecker2 at gmail.com  Fri Sep 14 13:42:55 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Fri, 14 Sep 2007 07:42:55 -0400
Subject: [C++-sig] make_constructor,
	with_custodian_and_ward problems (again)
References: <fcbj1b$vn0$1@sea.gmane.org>
	<200709131732.40261.hans_meine@gmx.net>
Message-ID: <fcds48$nsl$1@sea.gmane.org>

Hans Meine wrote:

> On Donnerstag 13 September 2007, Neal Becker wrote:
>> What's the correct way to do this?  Neither of the below .defs will
>> compile:
>> [...]
>>   class_<multi_array_ref<int,1> > ("multi_array_int_1", no_init)
>>     .def ("__init__", make_constructor (&make_array_int_1),
>> with_custodian_and_ward_postcall<0,1>())
>> .def ("__init__", make_constructor
>> (&make_array_int_1, with_custodian_and_ward_postcall<0,1>())) ;
>> }
>>
>> This same question was raised before, but I don't see a correct answer:
>> http://mail.python.org/pipermail/c++-sig/2007-June/012470.html
> 
> I was about to point you to the thread I started about the very same
> problem, but I realized last-minute that the link you posted is exactly
> that one. FWIW, I have not found a solution, but still have the same
> problem. (I.e. I live with the dangerous default_policies ATM.)
> 

Here is more info:
/usr/local/src/boost.hg/boost/python/object_core.hpp: In member
function 'void boost::python::api::object_operators<U>::visit(ClassT&,
const char*, const boost::python::detail::def_helper<DocStringT,
boost::python::detail::not_specified, boost::python::detail::not_specified,
boost::python::detail::not_specified>&) const [with ClassT =
boost::python::class_<boost::multi_array_ref<int, 1ul>,
boost::python::detail::not_specified, boost::python::detail::not_specified,
boost::python::detail::not_specified>, DocStringT =
boost::python::with_custodian_and_ward_postcall<0ul, 1ul,
boost::python::default_call_policies>, U = boost::python::api::object]':
/usr/local/src/boost.hg/boost/python/def_visitor.hpp:43:   instantiated
from 'static void boost::python::def_visitor_access::visit(const V&,
classT&, const char*, const OptionalArgs&) [with V =
boost::python::def_visitor<boost::python::api::object>, classT =
boost::python::class_<boost::multi_array_ref<int, 1ul>,
boost::python::detail::not_specified, boost::python::detail::not_specified,
boost::python::detail::not_specified>, OptionalArgs =
boost::python::detail::def_helper<boost::python::with_custodian_and_ward_postcall<0ul,
1ul, boost::python::default_call_policies>,
boost::python::detail::not_specified, boost::python::detail::not_specified,
boost::python::detail::not_specified>]'
/usr/local/src/boost.hg/boost/python/def_visitor.hpp:74:   instantiated
from 'void boost::python::def_visitor<DerivedVisitor>::visit(classT&, const
char*, const OptionalArgs&) const [with classT =
boost::python::class_<boost::multi_array_ref<int, 1ul>,
boost::python::detail::not_specified, boost::python::detail::not_specified,
boost::python::detail::not_specified>, OptionalArgs =
boost::python::detail::def_helper<boost::python::with_custodian_and_ward_postcall<0ul,
1ul, boost::python::default_call_policies>,
boost::python::detail::not_specified, boost::python::detail::not_specified,
boost::python::detail::not_specified>, DerivedVisitor =
boost::python::api::object]'
/usr/local/src/boost.hg/boost/python/class.hpp:524:   instantiated
from 'void boost::python::class_<T, X1, X2, X3>::def_impl(T*, const char*,
LeafVisitor, const Helper&, const boost::python::def_visitor<Visitor>*)
[with T = boost::multi_array_ref<int, 1ul>, Helper =
boost::python::detail::def_helper<boost::python::with_custodian_and_ward_postcall<0ul,
1ul, boost::python::default_call_policies>,
boost::python::detail::not_specified, boost::python::detail::not_specified,
boost::python::detail::not_specified>, LeafVisitor =
boost::python::api::object, Visitor = boost::python::api::object, W =
boost::multi_array_ref<int, 1ul>, X1 =
boost::python::detail::not_specified, X2 =
boost::python::detail::not_specified, X3 =
boost::python::detail::not_specified]'
/usr/local/src/boost.hg/boost/python/class.hpp:608:   instantiated
from 'void boost::python::class_<T, X1, X2, X3>::def_maybe_overloads(const
char*, Fn, const A1&, ...) [with Fn = boost::python::api::object, A1 =
boost::python::with_custodian_and_ward_postcall<0ul, 1ul,
boost::python::default_call_policies>, W = boost::multi_array_ref<int,
1ul>, X1 = boost::python::detail::not_specified, X2 =
boost::python::detail::not_specified, X3 =
boost::python::detail::not_specified]'
/usr/local/src/boost.hg/boost/python/class.hpp:244:   instantiated
from 'boost::python::class_<T, X1, X2, X3>& boost::python::class_<T, X1,
X2, X3>::def(const char*, A1, const A2&) [with A1 =
boost::python::api::object, A2 =
boost::python::with_custodian_and_ward_postcall<0ul, 1ul,
boost::python::default_call_policies>, W = boost::multi_array_ref<int,
1ul>, X1 = boost::python::detail::not_specified, X2 =
boost::python::detail::not_specified, X3 =
boost::python::detail::not_specified]'
mod/multi_array.cc:37:   instantiated from here
/usr/local/src/boost.hg/boost/python/object_core.hpp:186: error: invalid
application of 'sizeof' to incomplete
type 'boost::STATIC_ASSERTION_FAILURE<false>' 




From winkatl1213 at yahoo.com  Fri Sep 14 15:21:55 2007
From: winkatl1213 at yahoo.com (Jeff Winkelman)
Date: Fri, 14 Sep 2007 06:21:55 -0700 (PDT)
Subject: [C++-sig] Inline error checking
Message-ID: <685604.42151.qm@web39810.mail.mud.yahoo.com>

Hello,

I'm wrapping a large C++ library using boost and py++.  The C++ library does not use exceptions.  Instead, it uses a more C style of error checking where you need to call a set of error APIs after each call to check to see if an error occurred.

Using SWIG, you can add error checking code to each wrapped function or method by using the %exception directive.  This instructs the code generator to add the same error checking routine to each wrapper.

Does anyone know of a similar way to do this with boost or py++?

I've found where I can add a custom exception translator.  However, this doesn't really apply since this library doesn't generate exceptions.  I've also found where I can add custom code for a specific function.   This isn't ideal either due to the fact that the library is very large.

Is there a way to do this on a more "global" basis?  The error checking code is identical every time you call it.

Any sugessions are greatly appreciated.  Thanks in advance,

Jeff




       
____________________________________________________________________________________
Building a website is a piece of cake. Yahoo! Small Business gives you all the tools to get online.
http://smallbusiness.yahoo.com/webhosting 
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070914/2f076be7/attachment.htm>

From pertti.kellomaki at tut.fi  Fri Sep 14 17:22:48 2007
From: pertti.kellomaki at tut.fi (=?ISO-8859-1?Q?Pertti_Kellom=E4ki?=)
Date: Fri, 14 Sep 2007 18:22:48 +0300
Subject: [C++-sig] Problems splitting up a library
Message-ID: <46EAA748.7030207@tut.fi>

I am exposing a largish library using Py++ and Boost.Python, and I'm 
running into a bit of a problem when I try to expose it in manageable 
parts. I've tried to condense the problem below.

One module contains class NIT:

==================================================
class NIT : public IT {
public:
     static NIT& instance();
//...
}
==================================================

which is exposed by Py++ as follows:

==================================================
struct NIT_wrapper : TT::NIT, bp::wrapper< TT::NIT > {
//...
};

BOOST_PYTHON_MODULE(mach){
     bp::class_< NIT_wrapper,
                 bp::bases< TT::IT >,
                 boost::noncopyable >
     ( "NIT", bp::no_init )
         .def("instance"
             , (::TT::NIT & (*)(  ))
                  ( &::TT::NIT::instance )
             , bp::return_value_policy< bp::reference_existing_object 
 >() )
         .staticmethod( "instance" );
     //...
==================================================

In another module, there is a member function that uses NIT as a default 
value:

==================================================
class I {
public:
     I(const TT::IT& iT = TT::NIT::instance());
     //...
}
==================================================

This is exposed by Py++ as follows:

==================================================
BOOST_PYTHON_MODULE(program){
     bp::class_< TTAProgram::I,
                 boost::noncopyable >
          ( "I",
            bp::init< bp::optional< TT::IT const & > >
                 (( bp::arg("iT")
                     =TT::NIT::instance( ) )) )
     //...
==================================================

Importing the "mach" Python extension as

	import TCE.base.mach

succeeds, but

	import TCE.base.program

results in the error message

	Traceback (most recent call last):
	  File "<stdin>", line 1, in <module>
	TypeError: No to_python (by-value) converter found
	for C++ type: TTAMachine::NullInstructionTemplate

If I remove the default value from the signature, the problem 
disappears. Any ideas how to fix this?

Thanks in advance.
-- 
Pertti


From Matthew.Scouten at tradingtechnologies.com  Fri Sep 14 18:41:21 2007
From: Matthew.Scouten at tradingtechnologies.com (Matthew Scouten (TT))
Date: Fri, 14 Sep 2007 11:41:21 -0500
Subject: [C++-sig] Threads and boost Python
Message-ID: <32490DFF7774554A85D65D23A9F0F93806212CE9@chiex01>

The (large, complex) library I am wrapping uses threads. The user make
calls into the lib make a request,  and the lib calls back on a
different thread some time later.

 

I am aware that Python has some multi-threading  support, but I am not
sure how this will interoperate with boost python. For example, are
there any special things I need to do in the wrapper? Are there any
common gotchas I need to know about?

 

Keep in mind that these questions are from someone who is new to python
and boost::python, and rusty at c++, so don't jump on me to hard if they
are stupid questions :) 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070914/6924fa03/attachment.htm>

From roman.yakovenko at gmail.com  Fri Sep 14 19:45:59 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Fri, 14 Sep 2007 20:45:59 +0300
Subject: [C++-sig] Inline error checking
In-Reply-To: <685604.42151.qm@web39810.mail.mud.yahoo.com>
References: <685604.42151.qm@web39810.mail.mud.yahoo.com>
Message-ID: <7465b6170709141045j51446894sba86ef58fbe3da4@mail.gmail.com>

On 9/14/07, Jeff Winkelman <winkatl1213 at yahoo.com> wrote:
>
> Hello,
>
> I'm wrapping a large C++ library using boost and py++.  The C++ library
> does not use exceptions.  Instead, it uses a more C style of error checking
> where you need to call a set of error APIs after each call to check to see
> if an error occurred.
>
> Using SWIG, you can add error checking code to each wrapped function or
> method by using the %exception directive.  This instructs the code generator
> to add the same error checking routine to each wrapper.
>
> Does anyone know of a similar way to do this with boost or py++?
>
> I've found where I can add a custom exception translator.  However, this
> doesn't really apply since this library doesn't generate exceptions.  I've
> also found where I can add custom code for a specific function.   This isn't
> ideal either due to the fact that the library is very large.
>
> Is there a way to do this on a more "global" basis?  The error checking
> code is identical every time you call it.
>
> Any sugessions are greatly appreciated.  Thanks in advance,
>


Py++ doesn't have right now this functionality, but it provides the way to
add it through "function transformation" functionality:
http://language-binding.net/pyplusplus/documentation/functions/transformation/built_in/built_in.html

You can find many examples in the package:
http://pygccxml.svn.sourceforge.net/viewvc/pygccxml/pyplusplus_dev/pyplusplus/function_transformers/transformers.py?view=markup

Once you have created the transformer, it is very easy to apply it on all
relevant functions.


Let me know if you need more help.


-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070914/68185ff5/attachment.htm>

From roman.yakovenko at gmail.com  Fri Sep 14 19:51:49 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Fri, 14 Sep 2007 20:51:49 +0300
Subject: [C++-sig] Problems splitting up a library
In-Reply-To: <46EAA748.7030207@tut.fi>
References: <46EAA748.7030207@tut.fi>
Message-ID: <7465b6170709141051n3756a6gc918a87b6d3501ad@mail.gmail.com>

On 9/14/07, Pertti Kellom?ki <pertti.kellomaki at tut.fi> wrote:
>
> I am exposing a largish library using Py++ and Boost.Python, and I'm
> running into a bit of a problem when I try to expose it in manageable
> parts. I've tried to condense the problem below.
>
> One module contains class NIT:
>
> ==================================================
> class NIT : public IT {
> public:
>      static NIT& instance();
> //...
> }
> ==================================================
>
> which is exposed by Py++ as follows:
>
> ==================================================
> struct NIT_wrapper : TT::NIT, bp::wrapper< TT::NIT > {
> //...
> };
>
> BOOST_PYTHON_MODULE(mach){
>      bp::class_< NIT_wrapper,
>                  bp::bases< TT::IT >,
>                  boost::noncopyable >
>      ( "NIT", bp::no_init )
>          .def("instance"
>              , (::TT::NIT & (*)(  ))
>                   ( &::TT::NIT::instance )
>              , bp::return_value_policy< bp::reference_existing_object
> >() )
>          .staticmethod( "instance" );
>      //...
> ==================================================
>
> In another module, there is a member function that uses NIT as a default
> value:
>
> ==================================================
> class I {
> public:
>      I(const TT::IT& iT = TT::NIT::instance());
>      //...
> }
> ==================================================
>
> This is exposed by Py++ as follows:
>
> ==================================================
> BOOST_PYTHON_MODULE(program){
>      bp::class_< TTAProgram::I,
>                  boost::noncopyable >
>           ( "I",
>             bp::init< bp::optional< TT::IT const & > >
>                  (( bp::arg("iT")
>                      =TT::NIT::instance( ) )) )
>      //...
> ==================================================
>
> Importing the "mach" Python extension as
>
>         import TCE.base.mach
>
> succeeds, but
>
>         import TCE.base.program
>
> results in the error message
>
>         Traceback (most recent call last):
>           File "<stdin>", line 1, in <module>
>         TypeError: No to_python (by-value) converter found
>         for C++ type: TTAMachine::NullInstructionTemplate
>
> If I remove the default value from the signature, the problem
> disappears. Any ideas how to fix this?


This is a Boost.Python limitation: you can't register function with default
argument - it requires the type of the argument to be already registered. By
importing the module TCE.base.mach you register the relevant class.

Take a look on next link:
http://language-binding.net/pyplusplus/documentation/functions/default_args.html

HTH



-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070914/713d2472/attachment.htm>

From gtang at bcm.edu  Sun Sep 16 17:53:08 2007
From: gtang at bcm.edu (Grant)
Date: Sun, 16 Sep 2007 10:53:08 -0500
Subject: [C++-sig] float data pickling issue
Message-ID: <fcjjh5$mmb$1@sea.gmane.org>

Hi,

I have a class which has a float array. I write the pickling support for
this class by following boost.python's way and it works fine. But the thing
is the object size after pickling is about twice as I expect. Apparently
the float is saved as double when pickling. I checked the python API, there
are functions in floatobj.h like: _PyFloat_Pack4() and _PyFloat_Unpack4().
If these are functions I need to pickle float as four bytes, How can I do?
Or is there any other way to accomplish this (pickle float as four bytes
other than double)?

Thanks in advance,
Grant



From meine at informatik.uni-hamburg.de  Mon Sep 17 12:06:01 2007
From: meine at informatik.uni-hamburg.de (Hans Meine)
Date: Mon, 17 Sep 2007 12:06:01 +0200
Subject: [C++-sig] unused parameter warning in 1.34.1
In-Reply-To: <87d4wr62v6.fsf@grogan.peloton>
References: <200709071823.22321.meine@informatik.uni-hamburg.de>
	<87d4wr62v6.fsf@grogan.peloton>
Message-ID: <200709171206.01551.meine@informatik.uni-hamburg.de>

Am Sonntag, 09. September 2007 21:43:57 schrieb David Abrahams:
> on Fri Sep 07 2007, Hans Meine <meine-AT-informatik.uni-hamburg.de> wrote:
> > --- boost/python/converter/implicit.hpp~	2007-09-06 21:58:01.141553000
> > +0200 +++ boost/python/converter/implicit.hpp	2007-09-07
> > 18:19:09.529179000 +0200 @@ -31,8 +31,7 @@
> >          void* storage =
> > ((rvalue_from_python_storage<Target>*)data)->storage.bytes;
> >
> >          arg_from_python<Source> get_source(obj);
> > -        bool convertible = get_source.convertible();
> > -        BOOST_ASSERT(convertible);
> > +        BOOST_ASSERT(get_source.convertible());
> >
> >          new (storage) Target(get_source());
>
> Please post your patch to the Trac at http://svn.boost.org

I did so (my first use of Trac), but I made a mistake and first attached the 
wrong file: http://svn.boost.org/trac/boost/ticket/1271

Otherwise, is that what you wanted me to do?

-- 
Ciao, /  /
     /--/
    /  / ANS


From matthew.scouten at gmail.com  Mon Sep 17 17:27:25 2007
From: matthew.scouten at gmail.com (Matthew Scouten)
Date: Mon, 17 Sep 2007 10:27:25 -0500
Subject: [C++-sig] Threads and boost Python
Message-ID: <3dc9bcf00709170827i2f308252v1d1c882021720c0@mail.gmail.com>

The (large, complex) library I am wrapping uses threads. The user make
calls into the lib make a request,  and the lib calls back on a
different thread some time later.

I am aware that Python has some multi-threading  support, but I am not
sure how this will interoperate with boost python. For example, are
there any special things I need to do in the wrapper? Are there any
common gotchas I need to know about?

Keep in mind that these questions are from someone who is new to
python and boost::python, and rusty at c++, so don't jump on me to
hard if they are stupid questions :)


From johann.borck at densedata.com  Mon Sep 17 20:08:16 2007
From: johann.borck at densedata.com (Johann Borck)
Date: Mon, 17 Sep 2007 20:08:16 +0200
Subject: [C++-sig] Threads and boost Python
In-Reply-To: <3dc9bcf00709170827i2f308252v1d1c882021720c0@mail.gmail.com>
References: <3dc9bcf00709170827i2f308252v1d1c882021720c0@mail.gmail.com>
Message-ID: <46EEC290.3080403@densedata.com>

Matthew Scouten wrote:
> The (large, complex) library I am wrapping uses threads. The user make
> calls into the lib make a request,  and the lib calls back on a
> different thread some time later.
>
> I am aware that Python has some multi-threading  support, but I am not
> sure how this will interoperate with boost python. For example, are
> there any special things I need to do in the wrapper? Are there any
> common gotchas I need to know about?
>
I'd suggest you read about pythons global interpreter lock (GIL).
Threading in python is tricky and often not what one expects when
using the term "threads". Some projects use processes instead to avoid
some of the issues with python-threads. But it depends on the library
you wrap, and it is very hard to say anything general but "better be
careful when using them".

http://effbot.org/pyfaq/what-kinds-of-global-value-mutation-are-thread-safe.htm
http://effbot.org/pyfaq/can-t-we-get-rid-of-the-global-interpreter-lock.htm

http://mail.python.org/pipermail/c++-sig/2007-July/012617.html
http://mail.python.org/pipermail/c++-sig/2006-January/010034.html

http://mirrors.techiesabode.com/linuxgazette/107/pai.html
http://www.thescripts.com/forum/thread23198.html

http://jessenoller.com/2007/09/12/have-gil-want-benchmarks/

http://mail.python.org/pipermail/python-dev/2003-January/032429.html



Johann



From nickm at sitius.com  Tue Sep 18 22:01:01 2007
From: nickm at sitius.com (Nikolay Mladenov)
Date: Tue, 18 Sep 2007 16:01:01 -0400
Subject: [C++-sig] [patch] signatures/docstrings formatting
References: <fca12e$i6s$1@sea.gmane.org>
Message-ID: <46F02E7D.F65C00FA@sitius.com>

Neal,

I commited new formatting in the trunk. 
Could you please try it?

Nick

Neal Becker wrote:
> 
> # HG changeset patch
> # User ndbecker2 at gmail.com
> # Date 1189643327 14400
> # Node ID f6e6ad1cbdc8d6c9736b3d261e6e5fd3e6823f2e
> # Parent  056ace359968e07b83b67bed532796ec18f517c3
> fix c++ sig
> 
> The current docstring signatures seem to confuse epydoc (using rst), because of
> unexpected indentation.  The following 2 patches seem to be a bit better:
> 
> diff -r 056ace359968 -r f6e6ad1cbdc8 libs/python/src/object/function.cpp
> --- a/libs/python/src/object/function.cpp       Wed Sep 12 19:05:52 2007 -0400
> +++ b/libs/python/src/object/function.cpp       Wed Sep 12 20:28:47 2007 -0400
> @@ -544,9 +544,9 @@ void function::add_to_namespace(
>      if (docstring_options::show_cpp_signatures_)
>      {
>          if(len(_doc))
> -            _doc += "\n    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> +            _doc += "\n"+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
>          else
> -            _doc += "    "+str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
> +            _doc += str(reinterpret_cast<const char*>(detail::cpp_signature_tag));
>      }
>      if(_doc)
>      {
> # HG changeset patch
> # User ndbecker2 at gmail.com
> # Date 1189643963 14400
> # Node ID 33ce4a3bb451b917b315fa2400748955f794f546
> # Parent  f6e6ad1cbdc8d6c9736b3d261e6e5fd3e6823f2e
> add newlines after python sig
> 
> diff -r f6e6ad1cbdc8 -r 33ce4a3bb451 libs/python/src/object/function.cpp
> --- a/libs/python/src/object/function.cpp       Wed Sep 12 20:28:47 2007 -0400
> +++ b/libs/python/src/object/function.cpp       Wed Sep 12 20:39:23 2007 -0400
> @@ -539,7 +539,7 @@ void function::add_to_namespace(
>          _doc += str(reinterpret_cast<const char*>(detail::py_signature_tag));
>      }
>      if (doc != 0 && docstring_options::show_user_defined_)
> -        _doc += doc;
> +      _doc += str("\n\n")+doc;
> 
>      if (docstring_options::show_cpp_signatures_)
>      {



From kanand at qualcomm.com  Wed Sep 19 01:06:09 2007
From: kanand at qualcomm.com (Anand, Kumar)
Date: Tue, 18 Sep 2007 16:06:09 -0700
Subject: [C++-sig] Py++ unable to expose an abstract class that inherits
	from another abstract class
Message-ID: <C6ED4FE91AFB124A9F67F1677280FED7ED5EBD@NAEX13.na.qualcomm.com>

Problem:
-----------
Py++ is unable to expose an abstract class (say Abstract2) that inherits
from another abstract class (say Abstract1), if none of the pure virtual
functions in Abstarct2 are exposed. This is because Py++ always tries to
expose the pure virtual function of base Abstract1 class on the
Abstract2_wrapper class and there seems to be no way to control the
exposure of these base class functions. Look at the example code below
for clarification:

--------------------------Example:
------------------------------------------------------------------------

--------------------C++ code----------------------------

class Abstract1
{
public:
   void virtual func1() =0;
};

class Abstract2 : public Abstract1
{
public:
   void virtual func2() =0;
};

--------------------generate_code.py---------------------

//The following should have caused all member functions on Abstarct2 to
be excluded and
//PY++ should not have generated an Abstract2_wrapper class. However,
this excludes only //the functions on Abstract2 and not the ones
inherited by Abstract1 base class.

mb.class_("Abstract2").member_functions().exclude() 

------------------Generated Py++ code for Abstract2 in
Abstract2.pypp.cpp---------------------

struct Abstract2_wrapper : Abstract2, bp::wrapper< Abstract2 > {

    Abstract2_wrapper()
    : Abstract2()
      , bp::wrapper< Abstract2 >(){
        // null constructor

    }

    virtual void func1(  ){
        bp::override func_func1 = this->get_override( "func1" );
        func_func1(  );
    }
};

void register_Abstract2_class(){

    bp::class_< Abstract2_wrapper, bp::bases< Abstract1 >,
boost::noncopyable >( "Abstract2")
        .def("func1" , bp::pure_virtual( &::Abstract1::func1 ) );

}
------------------------------------------------------------------------
------------------------------------

Abstract2.pypp.cpp does not compile and error message is as follows:

../../../../../../thirdParty/include/boost/python/object/value_holder.hp
p:66: error: cannot declare field
'boost::python::objects::value_holder<Abstract2_wrapper>::m_held' to be
of abstract type 'Abstract2_wrapper'

Thanks
Kumar


From ndbecker2 at gmail.com  Wed Sep 19 02:47:46 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Tue, 18 Sep 2007 20:47:46 -0400
Subject: [C++-sig] Python 3
References: <46E474D6.3060302@densedata.com>
Message-ID: <fcprln$dlk$1@sea.gmane.org>

Should anyone take this on, this message might be helpful:

PyObject_HEAD was changed in Py3k to make it conform to C's strict
aliasing rules (See PEP 3123 [1]).

In your code, you need to change:

    static PyTypeObject MPFType = {
        PyObject_HEAD_INIT(NULL)
        0,                         /*ob_size*/
        ...
    }

to this:

    static PyTypeObject MPFType = {
        PyVarObject_HEAD_INIT(NULL, 0)
        ...
    }

Good luck,
-- Alexandre

[1]: http://www.python.org/dev/peps/pep-3123/



From ndbecker2 at gmail.com  Wed Sep 19 04:13:22 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Tue, 18 Sep 2007 22:13:22 -0400
Subject: [C++-sig] [patch] signatures/docstrings formatting
References: <fca12e$i6s$1@sea.gmane.org> <46F02E7D.F65C00FA@sitius.com>
Message-ID: <fcq0m9$obq$1@sea.gmane.org>

Nikolay Mladenov wrote:

> Neal,
> 
> I commited new formatting in the trunk.
> Could you please try it?
> 
> Nick
> 

Initial results look good!  No complaint from epydoc, and formatted output
is OK by my eyes.



From roman.yakovenko at gmail.com  Wed Sep 19 09:04:15 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Wed, 19 Sep 2007 09:04:15 +0200
Subject: [C++-sig] Py++ unable to expose an abstract class that inherits
	from another abstract class
In-Reply-To: <C6ED4FE91AFB124A9F67F1677280FED7ED5EBD@NAEX13.na.qualcomm.com>
References: <C6ED4FE91AFB124A9F67F1677280FED7ED5EBD@NAEX13.na.qualcomm.com>
Message-ID: <7465b6170709190004k685792fduf798a10583a099a@mail.gmail.com>

On 9/19/07, Anand, Kumar <kanand at qualcomm.com> wrote:
>
> Problem:
> -----------
> Py++ is unable to expose an abstract class (say Abstract2) that inherits
> from another abstract class (say Abstract1), if none of the pure virtual
> functions in Abstarct2 are exposed. This is because Py++ always tries to
> expose the pure virtual function of base Abstract1 class on the
> Abstract2_wrapper class and there seems to be no way to control the
> exposure of these base class functions. Look at the example code below
> for clarification:
>
> --------------------------Example:
> ------------------------------------------------------------------------
>
> --------------------C++ code----------------------------
>
> class Abstract1
> {
> public:
>    void virtual func1() =0;
> };
>
> class Abstract2 : public Abstract1
> {
> public:
>    void virtual func2() =0;
> };
>
>

Thanks for bug reporting. Technically you are right, but ... Why do you want
to exclude pure virtual function? It doesn't make sense to me.

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070919/68a1aa62/attachment.htm>

From Mark.English at rbccm.com  Wed Sep 19 13:45:37 2007
From: Mark.English at rbccm.com (English, Mark)
Date: Wed, 19 Sep 2007 12:45:37 +0100
Subject: [C++-sig] Pointer to pointer class_ held type,
	arguments to functions, and polymorphism
Message-ID: <EE7D40281B517A41AF5A90847A61F27930CAE4E2@SEW39051.oak.fg.rbc.com>

Problem
=======
Using smart pointers to smart pointers as held type of class_ loses argument matching capabilities
for functions which take a smart pointer to held type.
Also lose implicit casting ability.

Setup
=====
Windows 2000 SP4
MSVS 2003 (no service pack)
Python 2.3.6
Boost 1.32

Background
==========
--Original problem--
Constrained to using a third-party smart pointer.
Using this as the held type of a class_ loses Python polymorphic capabilities.
For example:
given a class "base_i", derived class "derived_t" and a function "base_ptr_to_base_ptr" exposed through boost python:
// cpp code snippet start
class base_i{};
class derived_t : public base_i {};
smart_pointers::shared_ptr_t<base_i> base_ptr_to_base_ptr(smart_pointers::shared_ptr_t<base_i> ptr)
{ return ptr; }
// cpp code snippet end

#python code snippet start
class pyderived(derived_t):
	def pytest(self): return 'pyderived test'
pyd = pyderived()
bfrompyd = base_ptr_to_base_ptr(pyd)
bfrompyd.pytest() #FAILS with c++ held type third party smart pointer
#python code snippet end

This seems to be a common problem and no solution has been presented that I'm aware of.
The following posts seem related:
http://mail.python.org/pipermail/c++-sig/2006-March/010423.html (I haven't tried using has_back_reference - I'm not sure it would help here)
http://mail.python.org/pipermail/c++-sig/2003-December/006481.html (doesn't deal with python derived classes)

There is example code here:
http://www.language-binding.net/pyplusplus/troubleshooting_guide/shared_ptr/shared_ptr.html
which demonstrates using a third party smart pointer.
The snippets above are actually name-changed code to use the same names as this example,
and I'll continue to do that for the remainder of this email so if you're interested in it you
might want to look at the sample code here:
http://www.language-binding.net/pyplusplus/troubleshooting_guide/shared_ptr/shared_ptr.zip


-- Potential solution to original problem--
Boost Python relies on boost::shared_ptr (and in particular the boost python checked deleter ?) to support
Python subclasses. The code snippets above would work fine if boost::shared_ptr were used, and as a result the original object
would be returned by "base_ptr_to_base_ptr()".

So one approach is to use boost::shared_ptr because Boost::Python "requires" it, wrapped around the third party
smart_ptr because the library being wrapped requires it.

I've put example code at the bottom of this mail tagged with
big c++ code snippet to use boost::shared_ptr<smart_pointers::smart_ptr_t<T> >

This allows the code snippets above to work (substituting the ptr class names for the original class names in the snippets).

Functions with raw pointers arguments will work, as I understand it, because of the pointee and get_pointer specializations.
Functions with boost::shared_ptr <smart_pointers::smart_ptr_t<T> > arguments will work because that's the held type.

Problems
==========
==New Problem 1==
Can't implicitly convert from base held type to derived held type.
i.e.
 bp::implicitly_convertible< 
               boost::shared_ptr < smart_pointers::smart_ptr_t< derived_t > >
             , boost::shared_ptr < smart_pointers::smart_ptr_t< base_i > > >();
Doesn't work.

==Potential solution to Problem 1==
- Write a converter for boost::shared_ptr < smart_pointers::smart_ptr_t< T > >.
  This is in the example code at the bottom named "ptr_ptr_from_python".
- Register a converter for base_i

As commented this is naively based on the code in shared_ptr_from_python.hpp
I'd really like some input on how to solve this problem.

I also tried specialising 
 template <class Source, class Target>
 struct implicit<boost::shared_ptr<smart_pointers::smart_ptr_t <Source> >
                ,boost::shared_ptr<smart_pointers::smart_ptr_t <Target> >
                >
but this seemed like a really bad idea.

==New Problem 2==
Can't call functions like "base_ptr_to_base_ptr()" because held type
boost::shared_ptr < smart_pointers::smart_ptr_t< T > >
won't match argument signature smart_pointers::smart_ptr_t< T >

==New problem 2 Solution==
I have no idea.

At the moment using this approach I have to write wrappers for all code which takes
smart_pointers::smart_ptr_t< T >
so that the wrapper takes
boost::shared_ptr < smart_pointers::smart_ptr_t< T > >
and dereferences the boost::shared_ptr calling the wrapped function.

I thought there might be a way to register a conversion but I can't find it.
The type of the passed in argument seems to be the result of pointee (i.e. T *)
and this can't find a registered match for the held type of the class_.
For example it seems that where T is derived_t,
the registered conversions/initialisers/??? are:
 smart_pointers::smart_ptr_t< derived_t >
 smart_pointers::smart_ptr_t< base_wrapper_t >
 smart_pointers::smart_ptr_t< base_i >

Changing pointee to return smart_pointers::smart_ptr_t<T> breaks all kinds of other code.

So my question is: is there a relatively easy,
not-having-to-specialise-arg_from_python-and-numerous-other-bits-of-implementation-dependant-code
way to support conversion of the wrapped Python type to a smart_pointers::smart_ptr_t<T> ?
Possibly involving visitors ?

Obviously that question is based on the assumption that this whole pointer to pointer approach is useful and valid.
Other suggestions for supporting Python polymorphism (other than stop using smart_pointers::smart_ptr_t) welcome.

Related links:
I think this is the inverse of the question in:
http://mail.python.org/pipermail/c++-sig/2006-August/011080.html
which is why I ended up with a "from_python()" style "ptr_ptr_from_python" converter.

Could register_conversion help ?
http://mail.python.org/pipermail/c++-sig/2005-August/009487.html

Thanks,
Mark
X-Replace-Address: mark.ignorethisbit.english at xxxrbccmxxx.ignorethisbittoo_and_removethosepreceding_xxxs_.com

CODE EXAMPLE FOLLOWS:
(sorry for the size):
// ==Start big c++ code snippet to use boost::shared_ptr<smart_pointers::smart_ptr_t<T> >==
namespace boost{ 
// boost accessor function to get raw pointer from shared_ptr <smart_pointers::smart_ptr_t <T> >
template<class T>
inline T* get_pointer( boost::shared_ptr <smart_pointers::smart_ptr_t<T> > const& p )
{
  return const_cast< T* >( p.get()->get() );
}

// Expose to Python
namespace python{
    // Expose nested shared_ptr <smart_pointers::smart_ptr_t <T> > as pointee
    template<class T>
    struct pointee< boost::shared_ptr <smart_pointers::smart_ptr_t<T> > >
    {
        typedef T type;
    };
} // Ends namespace python
} // Ends namespace boost

// Converter to allow extraction of
// shared_ptr <smart_pointers::smart_ptr_t <base_i> >
// (based on shared_ptr_from_python.hpp)
namespace boost { namespace python { namespace converter {
template <class T>
struct ptr_ptr_from_python
{
 private:
    typedef smart_pointers::smart_ptr_t <T> TargetType;
    typedef boost::shared_ptr <TargetType>  PtrPtrType;
public:
    ptr_ptr_from_python()
    {
        converter::registry::insert(&convertible, &construct, type_id< PtrPtrType >());
    }

 private:
    static void* convertible(PyObject* p)
    {
        if (p == Py_None)
            return p;
        
        return converter::get_lvalue_from_python(p, registered<T>::converters);
    }
    
    static void construct(PyObject* source, rvalue_from_python_stage1_data* data)
    {
        void* const storage = ((converter::rvalue_from_python_storage<PtrPtrType >*)data)->storage.bytes;
        // Deal with the "None" case.
        if (data->convertible == source)
            new (storage) PtrPtrType();
        else
            new (storage) PtrPtrType(
                static_cast<TargetType*>(data->convertible),
                shared_ptr_deleter(handle<>(borrowed(source)))
                );
        
        data->convertible = storage;
    }
};
}}} // Ends namespace boost::python::converter

// Example holder class to demonstrate Python polymorphism
typedef std::vector<boost::shared_ptr <smart_pointers::smart_ptr_t<base_i> > > vec_smart_base_i;
struct hold_base_i
{
  vec_smart_base_i  m_vecHold;

  void add(vec_smart_base_i::value_type valAdd)
  {
    m_vecHold.push_back(valAdd);
  }

  vec_smart_base_i::value_type get(int nPos)
  {
    return m_vecHold.at(nPos);
  }
};

// Example constructor function
boost::shared_ptr <smart_pointers::smart_ptr_t <derived_wrapper_t> >
makeDerived()
{
  return boost::shared_ptr< smart_pointers::smart_ptr_t <derived_wrapper_t> >
    (new smart_pointers::smart_ptr_t <derived_wrapper_t>(new derived_wrapper_t));
}

// <snip> all the other code from the original example apart from the BOOST_PYTHON_MODULE declaration</snip>

BOOST_PYTHON_MODULE( custom_sptr ){
/// <snip> Code from original sample code goes here</snip>
  // For demonstration purposes expose same C++ types with different names,
  // but use boost::shared_ptr<smart_pointers::smart_ptr_t<T> > as held type
    bp::class_<base_wrapper_t
              ,boost::shared_ptr<smart_pointers::smart_ptr_t <base_wrapper_t> >
              // ^^^^^^Note use of shared_ptr <smart_ptr_t <T> > here
              ,boost::noncopyable
              >
      ("base_i_ptr"
      ,bp::no_init
      )
      .def( "get_value", bp::pure_virtual( &base_i::get_value ) );
      ;

    bp::class_<derived_wrapper_t
              ,boost::shared_ptr<smart_pointers::smart_ptr_t <derived_wrapper_t> >
              // ^^^^^^Note use of shared_ptr <smart_ptr <T> > here
              ,bp::bases< base_i >
              ,boost::noncopyable
              >
      ("derived_t_ptr"
      ,bp::no_init
      )
      .def("__init__", bp::make_constructor(&makeDerived))
          // ^^^^^^Constructor for shared_ptr<smart_ptr<derived_t> >
      .def( "get_value", &derived_t::get_value, &derived_wrapper_t::default_get_value );
      ;

    // Class used to demonstrate storing smart_ptr<derived_t>
    bp::class_<hold_base_i>
      ("hold_base_i")
      .def("add", &hold_base_i::add)
      .def("get", &hold_base_i:get)
      ;

    // Register a base converter
    boost::python::converter::ptr_ptr_from_python<base_i>();
}
// ==End big c++ code snippet to use boost::shared_ptr<smart_pointers::smart_ptr_t<T> >==

Oversized disclaimer follows:
________________________________________

This E-Mail (including any attachments) may contain privileged or confidential information.  It is intended only for the addressee(s) indicated above.

The sender does not waive any of its rights, privileges or other protections respecting this information.  

Any distribution, copying or other use of this E-Mail or the information it contains, by other than an intended recipient, is not sanctioned and is prohibited.

If you received this E-Mail in error, please delete it and advise the sender (by return E-Mail or otherwise) immediately. 

This E-Mail (including any attachments) has been scanned for viruses. 

It is believed to be free of any virus or other defect that might affect any computer system into which it is received and opened. 

However, it is the responsibility of the recipient to ensure that it is virus free. 

The sender accepts no responsibility for any loss or damage arising in any way from its use.

E-Mail received by or sent from RBC Capital Markets is subject to review by Supervisory personnel. 

Such communications are retained and may be produced to regulatory authorities or others with legal rights to the information.

IRS CIRCULAR 230 NOTICE:  TO COMPLY WITH U.S. TREASURY REGULATIONS, WE ADVISE YOU THAT ANY U.S. FEDERAL TAX ADVISE INCLUDED IN THIS COMMUNICATION IS NOT INTENDED OR WRITTEN TO BE USED, AND CANNOT BE USED, TO AVOID ANY U.S. FEDERAL TAX PENALTIES OR TO PROMOTE, MARKET, OR RECOMMEND TO ANOTHER PARTY ANY TRANSACTION OR MATTER.


From kanand at qualcomm.com  Wed Sep 19 19:46:09 2007
From: kanand at qualcomm.com (Anand, Kumar)
Date: Wed, 19 Sep 2007 10:46:09 -0700
Subject: [C++-sig] Py++ unable to expose an abstract class that
	inheritsfrom another abstract class
In-Reply-To: <7465b6170709190004k685792fduf798a10583a099a@mail.gmail.com>
Message-ID: <C6ED4FE91AFB124A9F67F1677280FED7ED5F21@NAEX13.na.qualcomm.com>

In my case, the pure virtual functions have pointers as return types and
since the memory owner ship rules are not well defined, we do not want
to expose them to python.

 

I think an ability to specify that "exclude/include an inherited virtual
function" for a given class will be really useful. In my example C++
code below, I do not want "func1" to be re-exposed on Abstract2 class.

 

Thanks

Kumar

 

________________________________

From: c++-sig-bounces at python.org [mailto:c++-sig-bounces at python.org] On
Behalf Of Roman Yakovenko
Sent: Wednesday, September 19, 2007 12:04 AM
To: Development of Python/C++ integration
Subject: Re: [C++-sig] Py++ unable to expose an abstract class that
inheritsfrom another abstract class

 

On 9/19/07, Anand, Kumar <kanand at qualcomm.com> wrote:

	Problem:
	-----------
	Py++ is unable to expose an abstract class (say Abstract2) that
inherits
	from another abstract class (say Abstract1), if none of the pure
virtual
	functions in Abstarct2 are exposed. This is because Py++ always
tries to 
	expose the pure virtual function of base Abstract1 class on the
	Abstract2_wrapper class and there seems to be no way to control
the
	exposure of these base class functions. Look at the example code
below
	for clarification: 
	
	--------------------------Example:
	
------------------------------------------------------------------------
	
	--------------------C++ code----------------------------
	
	class Abstract1
	{
	public: 
	   void virtual func1() =0;
	};
	
	class Abstract2 : public Abstract1
	{
	public:
	   void virtual func2() =0;
	};



Thanks for bug reporting. Technically you are right, but ... Why do you
want to exclude pure virtual function? It doesn't make sense to me. 

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/ 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070919/8d09aff7/attachment.htm>

From pertti.kellomaki at tut.fi  Thu Sep 20 11:29:50 2007
From: pertti.kellomaki at tut.fi (=?ISO-8859-1?Q?Pertti_Kellom=E4ki?=)
Date: Thu, 20 Sep 2007 12:29:50 +0300
Subject: [C++-sig] Exposing inherited members with Py++
Message-ID: <46F23D8E.60706@tut.fi>

Is there a way to expose inherited members without exposing
the classes they were inherited from? If I have the following
classes and expose them using Py++, C1::f() is exposed:

   class C {
   public:
     C();
     virtual ~C();
     virtual int f();
   };

   class C1 : public C {
   public:
     C1();
   };

However, if I exclude class C, C1::f() is no longer exposed. If
I repeat f() in the declaration of C1, it is exposed, but this is
not really an option for me.

The reason for excluding C is that it is defined in another library,
separately exposed using Py++.
-- 
Pertti


From roman.yakovenko at gmail.com  Thu Sep 20 11:46:56 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Thu, 20 Sep 2007 11:46:56 +0200
Subject: [C++-sig] Exposing inherited members with Py++
In-Reply-To: <46F23D8E.60706@tut.fi>
References: <46F23D8E.60706@tut.fi>
Message-ID: <7465b6170709200246m7d9136evfb92d3c22f1845@mail.gmail.com>

On 9/20/07, Pertti Kellom?ki <pertti.kellomaki at tut.fi> wrote:
>
> Is there a way to expose inherited members without exposing
> the classes they were inherited from?


No

If I have the following
> classes and expose them using Py++, C1::f() is exposed:
>
>    class C {
>    public:
>      C();
>      virtual ~C();
>      virtual int f();
>    };
>
>    class C1 : public C {
>    public:
>      C1();
>    };
>
> However, if I exclude class C, C1::f() is no longer exposed. If
> I repeat f() in the declaration of C1, it is exposed, but this is
> not really an option for me.
>
> The reason for excluding C is that it is defined in another library,
> separately exposed using Py++.
>

Please read this:
http://language-binding.net/pyplusplus/documentation/multi_module_development.html

If your use case is pretty complex ( contains many classes and functions ),
than SVN version of Py++ contains new functionality that does such things
automatically:

mb = module_builder_t( ... )
mb.register_module_dependency( path to directory where other module
generated the code )

Of course the order of running code generators is important.


-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070920/907ce42a/attachment.htm>

From gazihan at cse.wustl.edu  Thu Sep 20 11:49:12 2007
From: gazihan at cse.wustl.edu (Gazihan Alankus)
Date: Thu, 20 Sep 2007 04:49:12 -0500
Subject: [C++-sig] Opening up a main window asynchronously
Message-ID: <fctfop$773$1@sea.gmane.org>

Hi, 

I'm about to create python extensions (or whatever I should be calling it)
in my simulation application for ease of use, for eliminating the
edit-compile-run killer loop. I know in the worst case I could embed python
in my application and run it by giving it a script file, but I could really
use an interactive approach where I do things step by step on the python
interpreter and immediately see results and continue.

I once used the mex interface in matlab and I remember it used to handle
everything itself. It would make my application(library) think that it is
running by itself while at the same time letting me call its functions. It
would be great if I could do something like that with Boost.Python.

At this point I could really use some feedback for my design. Here is what I
want in the end and I don't know if it is possible at all:

* run python
* import the python module that I made using Boost.Python
* run open_mainwindow()
-> this should open a main window that is constantly redrawn and interactive
-> but the call to open_mainwindow() should return in the python interprener
* make many different calls that adds-removes-manipulates the things in the
simulation
* have python objects that resemble the things in the simulation. I should
be able to use those python objects to manipulate things in the simulation.

If I could do this straight by exposing classes with Boost.Python, that
would be lovely. However, I realize that the window needs to have a main
loop - or at least something that frequently calls its process_events()
function. Now I'm speculating that there can be a couple of ways this might
be done:

1. make the open_mainwindow() call spawn a thread in c++ for the mainwindow
main loop:
I don't know how nice this would be, I'm afraid of losing grip of the thread
somehow. And I don't know if python will be happy with that thread possibly
changing the python objects about the simulation entities that python
holds. 

2. make a python thread: 
I don't know how to use them yet, I heard they are not what I expect. Maybe
that python thread could keep calling my window's process_events() and
everyone would be happy. or not, because maybe it will slow down the
simulation. 

3. call things like process_events() from the python interpreter myself.
make the python interpreter block while really doing something on the main
window. something like window.take_control(), and click on something on the
window to give it back to the interpreter.

4. make only an interface library with Boost.Python, make the real
application a separate process and make the interface talk to it via
sockets or something. 


I know that 4 would work for sure and 3 will probably work, but I really
would love a solution like 1, or maybe 2. Any eperienced C++/Python hybrid
developers that can lead me in the right direction? 

Thank you.

-Gazi 







From meine at informatik.uni-hamburg.de  Thu Sep 20 13:26:39 2007
From: meine at informatik.uni-hamburg.de (Hans Meine)
Date: Thu, 20 Sep 2007 13:26:39 +0200
Subject: [C++-sig] Opening up a main window asynchronously
In-Reply-To: <fctfop$773$1@sea.gmane.org>
References: <fctfop$773$1@sea.gmane.org>
Message-ID: <200709201326.39376.meine@informatik.uni-hamburg.de>

Hi!

Am Donnerstag, 20. September 2007 11:49:12 schrieb Gazihan Alankus:
> I know that 4 would work for sure and 3 will probably work, but I really
> would love a solution like 1, or maybe 2. Any eperienced C++/Python hybrid
> developers that can lead me in the right direction?

You gave a good overview of the possibilities.  AFAIK, all are possible, but 
require different levels of care. ;-)

You might want to have a look at IPython, which does 2).

You have to be careful though since e.g. Qt only allows Qt functions to be 
called from the mainloop thread.  (In version 3, that is.)  And no, IPython 
is not 100% careful enough yet. :-(

-- 
Ciao, /  /
     /--/
    /  / ANS


From pertti.kellomaki at tut.fi  Thu Sep 20 13:34:00 2007
From: pertti.kellomaki at tut.fi (=?ISO-8859-1?Q?Pertti_Kellom=E4ki?=)
Date: Thu, 20 Sep 2007 14:34:00 +0300
Subject: [C++-sig] Exposing inherited members with Py++
In-Reply-To: <7465b6170709200246m7d9136evfb92d3c22f1845@mail.gmail.com>
References: <46F23D8E.60706@tut.fi>
	<7465b6170709200246m7d9136evfb92d3c22f1845@mail.gmail.com>
Message-ID: <46F25AA8.6070406@tut.fi>

Roman Yakovenko wrote
> On 9/20/07, *Pertti Kellom?ki* <pertti.kellomaki at tut.fi 
> <mailto:pertti.kellomaki at tut.fi>> wrote:
>     Is there a way to expose inherited members without exposing
>     the classes they were inherited from? 
> No

Is there some deeper technical reason for this, or is it just
a matter of nobody having written the code yet?
-- 
Pertti


From duranlef at iro.umontreal.ca  Thu Sep 20 17:46:22 2007
From: duranlef at iro.umontreal.ca (=?ISO-8859-1?Q?Fran=E7ois_Duranleau?=)
Date: Thu, 20 Sep 2007 11:46:22 -0400 (EDT)
Subject: [C++-sig] Opening up a main window asynchronously
In-Reply-To: <fctfop$773$1@sea.gmane.org>
References: <fctfop$773$1@sea.gmane.org>
Message-ID: <Pine.LNX.4.63.0709201128100.32128@brocoli.iro.umontreal.ca>

On Thu, 20 Sep 2007, Gazihan Alankus wrote:

> I know that 4 would work for sure and 3 will probably work, but I really
> would love a solution like 1, or maybe 2. Any eperienced C++/Python hybrid
> developers that can lead me in the right direction?

I use option 5: Tkinter. When the interpreter is idle, Tkinter processes 
events. With that, you have no thread problems at all. Caveats:
- after you run a command, until it returns, the GUI is blocked
- I am not sure if this behaviour is portable (IIRC, there were some
   comments on that in Tkinter's source code)
- it's Tk..., although if you are really motivated, you could take a look
   at Tkinter's source code and see how they do it and port it to another
   GUI toolkit

I tried 2, but it was a pain to always make sure that the calls to the 
GUI's API and, in my case, OpenGL, where done in the thread owning it, and 
I didn't really have enough time to do development further in that 
direction. Since I was happy with Tk, I opted for 5.

I would take a look at IPython pointed out by Hans Meine. It looks very 
interesting.

-- 
Francois Duranleau


From littlesweetmelon at gmail.com  Fri Sep 21 04:28:43 2007
From: littlesweetmelon at gmail.com (=?GB2312?B?zPC5zw==?=)
Date: Fri, 21 Sep 2007 10:28:43 +0800
Subject: [C++-sig] [c++-sig]how to insert C++ object into python list?
Message-ID: <cdb837ea0709201928o4227f59dh606b8222018b7b74@mail.gmail.com>

Hi! I am sorry for asking this newbie question, but I really cannot
find any clue. ^_^
In my project, I use class_<> exports a c++ class 'MyRegion'. Some c++
functions will generate a series of 'MyRegion' objects and insert them
into a boost::python::list object as return value. But
boost::python::list only accepts boost::python::object when inserting.
What should I do?

Thank you!

---
ShenLei


From littlesweetmelon at gmail.com  Fri Sep 21 04:50:28 2007
From: littlesweetmelon at gmail.com (=?GB2312?B?zPC5zw==?=)
Date: Fri, 21 Sep 2007 10:50:28 +0800
Subject: [C++-sig] [c++-sig]how to insert C++ object into python list?
In-Reply-To: <cdb837ea0709201928o4227f59dh606b8222018b7b74@mail.gmail.com>
References: <cdb837ea0709201928o4227f59dh606b8222018b7b74@mail.gmail.com>
Message-ID: <cdb837ea0709201950x76ed2b7bi8af4434120ae3a49@mail.gmail.com>

Oh! Sorry... boost::python::list can accept "MyRegion" arguments directly!! @_@

boost::python::list list_obj;
MyRegion rgn(..);
class_<MyRegion>.def()....;
list_obj.append(rgn);  // It is OK!

My question changes to how does boost python wrap rgn into a pyObject
when appending to a python list?

---
ShenLei


From gazihan at cse.wustl.edu  Sat Sep 22 08:52:27 2007
From: gazihan at cse.wustl.edu (Gazihan Alankus)
Date: Sat, 22 Sep 2007 01:52:27 -0500
Subject: [C++-sig] Opening up a main window asynchronously
References: <fctfop$773$1@sea.gmane.org>
	<200709201326.39376.meine@informatik.uni-hamburg.de>
Message-ID: <fd2e5e$4j6$1@sea.gmane.org>

Hi, thanks for the responses Hans and Fran?ois.

Hans Meine wrote:

> 
> You might want to have a look at IPython, which does 2).

Oh, IPython is one cool piece of candy, thank you for creating such a nice
tool. I'm using it for everything Python from now on. I think I may also
end up using it for this GUI thing.

> 
> You have to be careful though since e.g. Qt only allows Qt functions to be
> called from the mainloop thread.  (In version 3, that is.)  And no,
> IPython is not 100% careful enough yet. :-(
> 

Yes! I remember being frustrated trying to have a QApplication on a thread
it Qt3. I'm not sure which thread library I tried though (QThread or
pthreads). I just tried the same thing on Qt4 with QThread now and it
didn't work as the documentation says, but then I tried with pthreads and
it worked just fine. I could update the GUI with a pthread where I created
the QApplication and make the main thread stay in an infinite loop printing
out numbers. I may end up just updating the GUI with pthreads and doing the
simulation stepping via Python. It's nice to have options and I'll try to
find the most convenient configuration. 

Thanks for the help guys I appreciate it.

-Gazi 




From Steve.Tucker at coair.com  Mon Sep 24 18:38:20 2007
From: Steve.Tucker at coair.com (Tucker, Steve)
Date: Mon, 24 Sep 2007 11:38:20 -0500
Subject: [C++-sig] C++ object reference passed to Python trouble...
Message-ID: <CA243F609C44584EAD3796DA1473E81C04BF6469@nhqsexc21.nam.coair.com>

I am having trouble passing a reference of a C++ instance to my Python
script? At first I was able to pass a simple string to the script but
then wanted to pass a C++ object reference and that's were things got
ugly? I am using Visual Studio 2005 and Python 2.5 and Boost 1.34.

 

My code compiles fine and executes up until the 

 

call<void>(pyFunc, obj);

 

code is called. By stepping into the "shared_ptr_to_python.hpp" an
exception is thrown on line 23

else

        return converter::registered<shared_ptr<T>
const&>::converters.to_python(&x);

 

I have tried using a raw pointer, but read it was highly suggested not
to do this!!! So I wrapped the class pointer in a boost::shared_ptr, is
this correct?

 

At first I got this error message -

 

"Unhandled exception at 0x7c812a5b in cpp_python.exe: Microsoft C++
exception: boost::python::error_already_set at memory location
0x0012f900.."

 

Then stripped out actual message using some brilliant code listed in the
forum and got - 

 

"TypeError: No to_python (by-value) converter found for C++ type: class
boost::shared_ptr<class Host>"

 

 Below is my C++ and Python code...

 

"py_connection.pyd" Code

 

class Host

{

public:     

      Host(): _greetVal("Hello"){}

      ~Host(){}

      std::string greet(void){return _greetVal;}

      void set_greet(std::string value){_greetVal = value; _greetVal +=
" good to see you.";}

 

private:

      std::string _greetVal;

};

 

BOOST_PYTHON_MODULE(py_connection)

{

class_<Host>("Host")

            .def("greet", &Host::greet)

            .def("set_greet", &Host::set_greet)

            ;

}

 

-------------------------------------------------------------------

EXE Code ".cpp" file-

 

typedef boost::shared_ptr<Host> spHost;

 

template <class T>

void CallPyFunc(PyObject* pyFunc, T obj)

{

      try

      {

            // ERROR here in shared_ptr_to_python.hpp Line 23

            call<void>(pyFunc, obj);

      }

      catch (error_already_set&)

      {

            PyObject *type, *value, *traceback;

            PyErr_Fetch(&type, &value, &traceback);

            PyErr_Restore(type, value, traceback);

            PyErr_Print();

            PyErr_Restore(type, value, traceback);

            throw;

      }

}

 

int main(int argc, char *argv[])

{

      spHost host(new Host());      

      host->set_greet("Gidday");

 

      Py_Initialize();

 

      PyObject* pyMod = PyImport_ImportModule("parser_util");

      PyObject* pyFunc = PyObject_GetAttrString(pyMod,
"PrintObjectValue");

 

      CallPyFunc(pyFunc, host);

      

      Py_DECREF(pyMod);

      Py_DECREF(pyFunc);

 

      Py_Finalize();

 

      return 0;

}

 

Parser_util.py

 

import py_connection

 

def PrintObjectValue(o):

print o.greet()

o.set_greet("Py Hello")

 

Can you see if I am passing the value correctly so that my Python code
is able to alter the reference? I need to alter it in Python and have it
reflected when the C++ code executes again?

 

I have read a lot about wrapping the C++ object but still don't see my
error. The more I look the more I find that there are many complex
solutions that are sometimes unreadable or understandable. I would love
to find a simple (less complex) solution to passing a C++ object
reference to Python and back but I am not seeing it? 

 

Regards,

--Steve.

 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070924/057ba18f/attachment.htm>

From matthew.scouten at gmail.com  Mon Sep 24 20:56:36 2007
From: matthew.scouten at gmail.com (Matthew Scouten)
Date: Mon, 24 Sep 2007 13:56:36 -0500
Subject: [C++-sig] splitting a module definition over several cpp files
Message-ID: <3dc9bcf00709241156y394c7d76i323259fd2a2b8781@mail.gmail.com>

The library I am trying to wrap is of unwieldy size.

I would like to split my boost python "declarations" in to several
different cpp files.

//file 1
BOOST_PYTHON_MODULE(poc)
{
      //first code
}

//file 2
BOOST_PYTHON_MODULE(poc)
{
      //second code
}

This does not work.

I know I saw a way to do this somewhere, but I cannot find it now.
Somthing invloling a function called from the end of '//first code'
that contained '//second code'.
I think the 'scope()' function may have been involved.

Can someone lend me a clue (or at least a link to one)?


From amohr at pixar.com  Mon Sep 24 21:07:15 2007
From: amohr at pixar.com (Alex Mohr)
Date: Mon, 24 Sep 2007 12:07:15 -0700
Subject: [C++-sig] splitting a module definition over several cpp files
In-Reply-To: <3dc9bcf00709241156y394c7d76i323259fd2a2b8781@mail.gmail.com>
References: <3dc9bcf00709241156y394c7d76i323259fd2a2b8781@mail.gmail.com>
Message-ID: <46F80AE3.1070007@pixar.com>

Matthew Scouten wrote:
> The library I am trying to wrap is of unwieldy size.
> 
> I would like to split my boost python "declarations" in to several
> different cpp files.
> This does not work.
> 
> I know I saw a way to do this somewhere, but I cannot find it now.
> Somthing invloling a function called from the end of '//first code'
> that contained '//second code'.
> I think the 'scope()' function may have been involved.

Probably the simplest thing to do is to just call functions from a 
central module definition.  e.g.

//file 1
BOOST_PYTHON_MODULE(poc)
{
    wrapFoo();
    wrapBar();
    wrapBaz();
}

//file 2
void wrapFoo() {
    class_<...>(...);
}

//file 3
void wrapBar() {
    class_<...>(...);
}

//file 4
void wrapBaz() {
    class_<...>(...);
}

Alex


From gjcarneiro at gmail.com  Tue Sep 25 11:21:14 2007
From: gjcarneiro at gmail.com (Gustavo Carneiro)
Date: Tue, 25 Sep 2007 10:21:14 +0100
Subject: [C++-sig] Announcing project PyBindGen
Message-ID: <a467ca4f0709250221v4e62ea89v46efbddc1337bcaf@mail.gmail.com>

  Hello all,

  I'd like to announce a new project for producing python extensions, called
PyBindGen.  It follows a radical new path for Python bindings generation: it
is itself written in (gasp!) Python!  And it does not even use C++ templates
at all! :-)

  The project is young but has been slowly developed for a few months now,
so it has already reached a point where it is useful for many tasks.  For
now, it has only a Python interface.  No interface description file or
header scanning supported yet.  It also has been focused more on C++ code
for now, although it was designed to also support pure C from the start.

  More information in: https://launchpad.net/pybindgen/

-- 
Gustavo J. A. M. Carneiro
INESC Porto, Telecommunications and Multimedia Unit
"The universe is always one step beyond logic." -- Frank Herbert
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070925/a1f91c19/attachment.htm>

From nat at lindenlab.com  Tue Sep 25 16:57:48 2007
From: nat at lindenlab.com (Nat Goodspeed)
Date: Tue, 25 Sep 2007 10:57:48 -0400
Subject: [C++-sig] Announcing project PyBindGen
In-Reply-To: <a467ca4f0709250221v4e62ea89v46efbddc1337bcaf@mail.gmail.com>
References: <a467ca4f0709250221v4e62ea89v46efbddc1337bcaf@mail.gmail.com>
Message-ID: <46F921EC.6000702@lindenlab.com>

Gustavo Carneiro wrote:
>   Hello all,
>
>   I'd like to announce a new project for producing python extensions, 
> called PyBindGen.  It follows a radical new path for Python bindings 
> generation: it is itself written in (gasp!) Python!  And it does not 
> even use C++ templates at all! :-)
Interesting! I would be curious to see you contrast it with the Py++ 
project:

http://www.language-binding.net/pyplusplus/pyplusplus.html

to get a sense of when I might choose to use one vs. the other.


From matthew.scouten at gmail.com  Tue Sep 25 17:33:02 2007
From: matthew.scouten at gmail.com (Matthew Scouten)
Date: Tue, 25 Sep 2007 10:33:02 -0500
Subject: [C++-sig] Wrapping a class with a private copy ctor
Message-ID: <3dc9bcf00709250833k17aae7e4scbe11ab40f71c2d9@mail.gmail.com>

Right, so the class that I need to wrap has a private copy ctor.  I do
not need to copy objects of this class, or pass them to and from
python.  I only need to subclass them in python. In fact I only ever
need one. But Boost::python seems to choke on the private copy ctor.
Is there a way around this?

example code:

class Base
{
	private:
	Base(const Base&);
	Base & operator=(const Base &);
}

class Derived : public Base
{

}

struct Derived_wrapper : Derived
{
}

BOOST_PYTHON_MODULE(core)
{
	class_<CTTPriceConsumer_wrapper>("CTTPriceConsumer");
}

Errors:
1>------ Build started: Project: corewrapper, Configuration: Release
Win32 ------
1>Compiling...
1>test.cpp
1>.\test.cpp(21) : error C2248: 'Base::Base' : cannot access private
member declared in class 'Base'
1>        .\test.cpp(14) : see declaration of 'Base::Base'
1>        .\test.cpp(12) : see declaration of 'Base'
1>        This diagnostic occurred in the compiler generated function
'Derived::Derived(const Derived &)'
1>Build log was saved at
"file://c:\tt-dev\corewrapper\tools\fix\main\dev\corewrapper\Release\corewrapper_Release_BuildLog.htm"
1>corewrapper - 1 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========


From matthew.scouten at gmail.com  Tue Sep 25 17:33:42 2007
From: matthew.scouten at gmail.com (Matthew Scouten)
Date: Tue, 25 Sep 2007 10:33:42 -0500
Subject: [C++-sig] splitting a module definition over several cpp files
In-Reply-To: <46F80AE3.1070007@pixar.com>
References: <3dc9bcf00709241156y394c7d76i323259fd2a2b8781@mail.gmail.com>
	<46F80AE3.1070007@pixar.com>
Message-ID: <3dc9bcf00709250833j6bfc21dq86b7b4da1c60c7f8@mail.gmail.com>

Ah yes that worked. thanks

On 9/24/07, Alex Mohr <amohr at pixar.com> wrote:
> Matthew Scouten wrote:
> > The library I am trying to wrap is of unwieldy size.
> >
> > I would like to split my boost python "declarations" in to several
> > different cpp files.
> > This does not work.
> >
> > I know I saw a way to do this somewhere, but I cannot find it now.
> > Somthing invloling a function called from the end of '//first code'
> > that contained '//second code'.
> > I think the 'scope()' function may have been involved.
>
> Probably the simplest thing to do is to just call functions from a
> central module definition.  e.g.
>
> //file 1
> BOOST_PYTHON_MODULE(poc)
> {
>     wrapFoo();
>     wrapBar();
>     wrapBaz();
> }
>
> //file 2
> void wrapFoo() {
>     class_<...>(...);
> }
>
> //file 3
> void wrapBar() {
>     class_<...>(...);
> }
>
> //file 4
> void wrapBaz() {
>     class_<...>(...);
> }
>
> Alex
> _______________________________________________
> C++-sig mailing list
> C++-sig at python.org
> http://mail.python.org/mailman/listinfo/c++-sig
>


From Mark.English at rbccm.com  Tue Sep 25 17:38:06 2007
From: Mark.English at rbccm.com (English, Mark)
Date: Tue, 25 Sep 2007 16:38:06 +0100
Subject: [C++-sig] Wrapping a class with a private copy ctor
Message-ID: <EE7D40281B517A41AF5A90847A61F2793796556A@SEW39051.oak.fg.rbc.com>

> From: c++-sig-bounces at python.org [mailto:c++-sig-bounces at python.org]On
> Behalf Of Matthew Scouten
> Sent: 25 September 2007 16:33
> Subject: [C++-sig] Wrapping a class with a private copy ctor
> 
> <snip>
> But Boost::python seems to choke on the private copy ctor.
> Is there a way around this?
> <snip>
> BOOST_PYTHON_MODULE(core)
> {
> 	class_<CTTPriceConsumer_wrapper>("CTTPriceConsumer");
> }
This doesn't reference the classes you mention earlier in your example.

Try noncopyable:

BOOST_PYTHON_MODULE(core)
{
	class_<CTTPriceConsumer_wrapper
            ,boost::noncopyable>
      ("CTTPriceConsumer")
      ;
}

Cheers,
mE
______________________________________________________________________

This email is intended only for the use of the individual(s) to whom it is addressed and may be privileged and confidential.
Unauthorised use or disclosure is prohibited.If you receive This e-mail in error, please advise immediately and delete the original message.
This message may have been altered without your or our knowledge and the sender does not accept any liability for any errors or omissions in the message.


From duranlef at iro.umontreal.ca  Tue Sep 25 17:39:09 2007
From: duranlef at iro.umontreal.ca (=?ISO-8859-1?Q?Fran=E7ois_Duranleau?=)
Date: Tue, 25 Sep 2007 11:39:09 -0400 (EDT)
Subject: [C++-sig] Wrapping a class with a private copy ctor
In-Reply-To: <3dc9bcf00709250833k17aae7e4scbe11ab40f71c2d9@mail.gmail.com>
References: <3dc9bcf00709250833k17aae7e4scbe11ab40f71c2d9@mail.gmail.com>
Message-ID: <Pine.LNX.4.63.0709251137400.29321@brocoli.iro.umontreal.ca>

On Tue, 25 Sep 2007, Matthew Scouten wrote:

> Right, so the class that I need to wrap has a private copy ctor.
[snip]
> BOOST_PYTHON_MODULE(core)
> {
> 	class_<CTTPriceConsumer_wrapper>("CTTPriceConsumer");
> }

Tell Boost.Python the class is not copyable:

BOOST_PYTHON_MODULE(core)
{
     class_<CTTPriceConsumer_wrapper,boost::noncopyable>("CTTPriceConsumer");
}                                   ^^^^^^^^^^^^^^^^^^

-- 
Fran??ois Duranleau

From cwg at falma.de  Wed Sep 26 09:48:21 2007
From: cwg at falma.de (Christoph Groth)
Date: Wed, 26 Sep 2007 09:48:21 +0200
Subject: [C++-sig] reloading modules written with Boost.Python
Message-ID: <87ejglamuy.fsf@falma.de>

Dear group,

I've created a simple module with Boost.Python which provides a single simple
function.  Importing that module into python and executing the function works.

It would be nice to be able to change the function, recompile the module, and
`reload(module_name)' it in python without restarting the interpreter.  This,
however does not work.  Python says it has reloaded the module but when I
execute the function it is still the old one:

****************************************************************
$ python
Python 2.4.4 (#2, Aug 16 2007, 02:03:40) 
[GCC 4.1.3 20070812 (prerelease) (Debian 4.1.2-15)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import rrn
>>> rrn.test()
old function
>>> # now I recompile rrn.so
... 
>>> reload(rrn)
<module 'rrn' from 'rrn.so'>
>>> rrn.test()
old function
>>> 
$ python
Python 2.4.4 (#2, Aug 16 2007, 02:03:40) 
[GCC 4.1.3 20070812 (prerelease) (Debian 4.1.2-15)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import rrn
>>> rrn.test()
new function
****************************************************************

I'm using the libboost packages from Debian testing (Version 1.33.1-10).

I'm grateful for any hints

Christoph



From Mark.English at rbccm.com  Wed Sep 26 12:21:41 2007
From: Mark.English at rbccm.com (English, Mark)
Date: Wed, 26 Sep 2007 11:21:41 +0100
Subject: [C++-sig] How do I detect a Python subclass (with 3rd party
	pointer) ?
Message-ID: <EE7D40281B517A41AF5A90847A61F27937965570@SEW39051.oak.fg.rbc.com>

If I expose a class through Boost Python, is there a way to discover that the parameter to a wrapped function
is an instance of a sub-class defined in Python, rather than an instance of the actual exposed class ?
Some kind of lookup in the converter::registry ?
Some kind of attribute added to exposed classes by a visitor ?
Something else ?

For example:
// Start cpp
#include <smart_ptr.h>
class ExampleBase{};
class Example1 : public ExampleBase {};
class Example2 : public ExampleBase {};
//...
class ExampleN : public ExampleBase {};

void testFunction(boost::python::object objTest)
{
  // Some kind of check for exposed classes here
}

BOOST_PYTHON_MODULE(test)
{
  class_<Example, smart_ptr<Example> >("Example");
  class_<Example1, bases<Example>, smart_ptr<Example1> >("Example1");
  class_<Example2, bases<Example>, smart_ptr<Example2> >("Example2");
  //...
  class_<ExampleN, bases<Example>, smart_ptr<ExampleN> >("ExampleN");

  def("testFunction", &testFunction);
}

// End of cpp
#Start of py
import test
class PyDerived(test.Example2): pass
class External(object): pass
ex2 = test.Example2()
pyd = PyDerived()
ext = External()
test.testFunction(ex2) #Handled by straight C++ conversion
test.testFunction(pyd) #<- Want C++ code to realise this is a Python derived class
test.testFunction(ext) #<- Want C++ code to realise this is a Python class unrelated to C++ code
#End of py
______________________________________________________________________

This email is intended only for the use of the individual(s) to whom it is addressed and may be privileged and confidential.
Unauthorised use or disclosure is prohibited.If you receive This e-mail in error, please advise immediately and delete the original message.
This message may have been altered without your or our knowledge and the sender does not accept any liability for any errors or omissions in the message.


From gjcarneiro at gmail.com  Wed Sep 26 14:48:39 2007
From: gjcarneiro at gmail.com (Gustavo Carneiro)
Date: Wed, 26 Sep 2007 13:48:39 +0100
Subject: [C++-sig] Announcing pybindgen
Message-ID: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>

(manually replying from copy-pasting the archives because my c++-sig
subscription was disabled by accident).

Nat Goodspeed wrote:

>Gustavo Carneiro wrote:
>>   Hello all,
>>
>>   I'd like to announce a new project for producing python extensions,
>> called PyBindGen.  It follows a radical new path for Python bindings
>> generation: it is itself written in (gasp!) Python!  And it does not
>> even use C++ templates at all! :-)
>Interesting! I would be curious to see you contrast it with the Py++
>project:
>
>http://www.language-binding.net/pyplusplus/pyplusplus.html
>
>to get a sense of when I might choose to use one vs. the other.

I know Py++.  You cannot compare Py++ with PyBindGen.  I would say that
PyBindGen replaces Boost.Python.  Py++ is a layer on top of Boost.Python.
Py++ generates Boost.Python module definition sources through automatic
scanning of C++ header files.  PyBindGen lacks the header files scanning
feature that Py++ provides, and I really miss that feature in PyBindGen.  I
hope that someone (maybe me) finds time to work on that for PyBindGen, some
day...  I'm not sure if Py++ is modular enough to be able to receive a
different code generation backend besides Boost.Python (Roman, feel free to
comment :).

Although I like Py++ a lot, I really hate Boost.Python.  Maybe it's because
of my lack of skill in understanding C++ templates, but I feel like
Boost.Python hides too many details underneath a layer of cryptic to follow
set of C++ templates, while I need to see the generated code in order to
check that memory management details are being declared and implemented
correctly.  In addition, to compile Boost.Python based bindings your users
need to have the boost python library and header files installed.  In
contrast, PyBindGen generated extensions only require python development
header files in order to compile, nothing more.  I also think
Boost.Pythonextensions compile to rather large modules...

Regards,

-- 
Gustavo J. A. M. Carneiro
INESC Porto, Telecommunications and Multimedia Unit
"The universe is always one step beyond logic." -- Frank Herbert
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070926/9cce45cf/attachment.htm>

From hans_meine at gmx.net  Wed Sep 26 15:36:31 2007
From: hans_meine at gmx.net (Hans Meine)
Date: Wed, 26 Sep 2007 15:36:31 +0200
Subject: [C++-sig] Announcing pybindgen
In-Reply-To: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>
References: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>
Message-ID: <200709261536.42765.hans_meine@gmx.net>

On Mittwoch 26 September 2007, Gustavo Carneiro wrote:
> Although I like Py++ a lot, I really hate Boost.Python.
Alarm!  Wrong list! ;-P

> Maybe it's because 
> of my lack of skill in understanding C++ templates, but I feel like
> Boost.Python hides too many details underneath a layer of cryptic to follow
> set of C++ templates, while I need to see the generated code in order to
> check that memory management details are being declared and implemented
> correctly.
That's a matter of trust.  I like boost::python's memory management concepts a 
lot.  But you are right, that it is very difficult to look behind the scenes.  
You should not have to, but if you want, it's really... scary. ;-)
(I am often giving up quite early when I see all the preprocessor magic with 
#includes of #define'd files that recursively include the current header 
file..)

> In addition, to compile Boost.Python based bindings your users 
> need to have the boost python library and header files installed.
That's a real disadvantage indeed.  If you happen to work on a very small 
project that you want to offer to the world with Python bindings included, 
boost::python is a rather large and inconvenient dependency.

> In contrast, PyBindGen generated extensions only require python development
> header files in order to compile, nothing more.
That's cool, but it's a pity that it does not have something like py++, based 
on pygccxml.

> I also think Boost.Pythonextensions compile to rather large modules...
My experience is only with wrapping highly templatized code, thus I don't know 
if that should be attributed to boost::python.

-- 
Ciao, /  /                                                    .o.
     /--/                                                     ..o
    /  / ANS                                                  ooo
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 189 bytes
Desc: This is a digitally signed message part.
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070926/b7e5e2c9/attachment.pgp>

From seefeld at sympatico.ca  Wed Sep 26 15:48:34 2007
From: seefeld at sympatico.ca (Stefan Seefeld)
Date: Wed, 26 Sep 2007 09:48:34 -0400
Subject: [C++-sig] Announcing pybindgen
In-Reply-To: <200709261536.42765.hans_meine@gmx.net>
References: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>
	<200709261536.42765.hans_meine@gmx.net>
Message-ID: <46FA6332.1070406@sympatico.ca>

Hans Meine wrote:
> On Mittwoch 26 September 2007, Gustavo Carneiro wrote:
>> Although I like Py++ a lot, I really hate Boost.Python.
> Alarm!  Wrong list! ;-P

Well, no, actually. This list is about python-C++ integration (see its
name). If you want a boost.python-specific list, it needed to be created
first. ;-)

>> Maybe it's because 
>> of my lack of skill in understanding C++ templates, but I feel like
>> Boost.Python hides too many details underneath a layer of cryptic to follow
>> set of C++ templates, while I need to see the generated code in order to
>> check that memory management details are being declared and implemented
>> correctly.
> That's a matter of trust.  I like boost::python's memory management concepts a 
> lot.  But you are right, that it is very difficult to look behind the scenes.  
> You should not have to, but if you want, it's really... scary. ;-)

Yes, and that seems indeed to be one of the weak points of the library: it works
great as long as it works great. Once either the user makes an error, or
his requirements aren't quite covered, all in a sudden things become very muddy.

Regards,
		Stefan

-- 

      ...ich hab' noch einen Koffer in Berlin...


From Mark.English at rbccm.com  Wed Sep 26 16:01:53 2007
From: Mark.English at rbccm.com (English, Mark)
Date: Wed, 26 Sep 2007 15:01:53 +0100
Subject: [C++-sig] Announcing pybindgen
Message-ID: <EE7D40281B517A41AF5A90847A61F27937965572@SEW39051.oak.fg.rbc.com>

> -----Original Message-----
> From: c++-sig-bounces at python.org [mailto:c++-sig-bounces at python.org]On
> Behalf Of Stefan Seefeld
> Sent: 26 September 2007 14:49
> To: Development of Python/C++ integration
> Subject: Re: [C++-sig] Announcing pybindgen
> 
> Once either the user makes 
> an error, or
> his requirements aren't quite covered, all in a sudden things 
> become very muddy.
> 
> Regards,
> 		Stefan
+ or Dave Abrahams goes on holiday
______________________________________________________________________

This email is intended only for the use of the individual(s) to whom it is addressed and may be privileged and confidential.
Unauthorised use or disclosure is prohibited.If you receive This e-mail in error, please advise immediately and delete the original message.
This message may have been altered without your or our knowledge and the sender does not accept any liability for any errors or omissions in the message.


From hans_meine at gmx.net  Wed Sep 26 17:28:06 2007
From: hans_meine at gmx.net (Hans Meine)
Date: Wed, 26 Sep 2007 17:28:06 +0200
Subject: [C++-sig] Announcing pybindgen
In-Reply-To: <46FA6332.1070406@sympatico.ca>
References: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>
	<200709261536.42765.hans_meine@gmx.net>
	<46FA6332.1070406@sympatico.ca>
Message-ID: <200709261728.06586.hans_meine@gmx.net>

On Mittwoch 26 September 2007, Stefan Seefeld wrote:
> > That's a matter of trust.  I like boost::python's memory management
> > concepts a lot.  But you are right, that it is very difficult to look
> > behind the scenes. You should not have to, but if you want, it's
> > really... scary. ;-)
>
> Yes, and that seems indeed to be one of the weak points of the library: it
> works great as long as it works great. Once either the user makes an error,
> or his requirements aren't quite covered, all in a sudden things become
> very muddy.

Right.  Actually, my errors often led to nice assertion errors, but the 
requirements-not-covered case obviously bit me with make_constructor(), which 
obviously does not support the usual call policies (cf. the 
with_custodian_and_ward problems). :-(

-- 
Ciao, /  /                                                    .o.
     /--/                                                     ..o
    /  / ANS                                                  ooo
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 189 bytes
Desc: This is a digitally signed message part.
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070926/7acd2522/attachment.pgp>

From duranlef at iro.umontreal.ca  Wed Sep 26 20:03:27 2007
From: duranlef at iro.umontreal.ca (=?ISO-8859-1?Q?Fran=E7ois_Duranleau?=)
Date: Wed, 26 Sep 2007 14:03:27 -0400 (EDT)
Subject: [C++-sig] reloading modules written with Boost.Python
In-Reply-To: <87ejglamuy.fsf@falma.de>
References: <87ejglamuy.fsf@falma.de>
Message-ID: <Pine.LNX.4.63.0709261400080.18948@brocoli.iro.umontreal.ca>

On Wed, 26 Sep 2007, Christoph Groth wrote:

> Dear group,
>
> I've created a simple module with Boost.Python which provides a single simple
> function.  Importing that module into python and executing the function works.
>
> It would be nice to be able to change the function, recompile the module, and
> `reload(module_name)' it in python without restarting the interpreter.  This,
> however does not work.  Python says it has reloaded the module but when I
> execute the function it is still the old one:

AFAIK, it is a limitation of any extension modules, not just Boost.Python. 
Reloading works properly only with pure Python modules.

-- 
Francois Duranleau


From roman.yakovenko at gmail.com  Wed Sep 26 22:08:57 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Wed, 26 Sep 2007 22:08:57 +0200
Subject: [C++-sig] Announcing pybindgen
In-Reply-To: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>
References: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>
Message-ID: <7465b6170709261308h571c91c3ofe5837dea5cc3a1d@mail.gmail.com>

On 9/26/07, Gustavo Carneiro <gjcarneiro at gmail.com> wrote:
>
> I know Py++.  You cannot compare Py++ with PyBindGen.  I would say that
> PyBindGen replaces Boost.Python.  Py++ is a layer on top of Boost.Python.
> Py++ generates Boost.Python module definition sources through automatic
> scanning of C++ header files.  PyBindGen lacks the header files scanning
> feature that Py++ provides, and I really miss that feature in PyBindGen.  I
> hope that someone (maybe me) finds time to work on that for PyBindGen, some
> day...


pygccxml is stand-alone Python package. You are free to integrate it within
your project.

I'm not sure if Py++ is modular enough to be able to receive a different
> code generation backend besides Boost.Python (Roman, feel free to comment
> :).


Some refactoring is needed, but the code generators could share a lot of
code.

Although I like Py++ a lot, I really hate Boost.Python.  Maybe it's because
> of my lack of skill in understanding C++ templates, but I feel like
> Boost.Python hides too many details underneath a layer of cryptic to
> follow set of C++ templates, while I need to see the generated code in order
> to check that memory management details are being declared and implemented
> correctly.


:-), I think you are going to reinvent the wheel here. I guess there are
many reasons why memory management  is complex and you eventually rediscover
all of them

  In addition, to compile Boost.Python based bindings your users need to
> have the boost python library and header files installed.


Completely agree with you. It takes too much time to setup working
environment.

  In contrast, PyBindGen generated extensions only require python
> development header files in order to compile, nothing more.  I also think
> Boost.Python extensions compile to rather large modules...


This is also true.

Good luck with your project and let me know if you need help with pygccxml.


-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070926/8f7fb655/attachment.htm>

From david at ar.media.kyoto-u.ac.jp  Thu Sep 27 08:59:25 2007
From: david at ar.media.kyoto-u.ac.jp (David Cournapeau)
Date: Thu, 27 Sep 2007 15:59:25 +0900
Subject: [C++-sig] reloading modules written with Boost.Python
In-Reply-To: <Pine.LNX.4.63.0709261400080.18948@brocoli.iro.umontreal.ca>
References: <87ejglamuy.fsf@falma.de>
	<Pine.LNX.4.63.0709261400080.18948@brocoli.iro.umontreal.ca>
Message-ID: <46FB54CD.5020009@ar.media.kyoto-u.ac.jp>

Fran?ois Duranleau wrote:
> On Wed, 26 Sep 2007, Christoph Groth wrote:
>
>   
>> Dear group,
>>
>> I've created a simple module with Boost.Python which provides a single simple
>> function.  Importing that module into python and executing the function works.
>>
>> It would be nice to be able to change the function, recompile the module, and
>> `reload(module_name)' it in python without restarting the interpreter.  This,
>> however does not work.  Python says it has reloaded the module but when I
>> execute the function it is still the old one:
>>     
>
> AFAIK, it is a limitation of any extension modules, not just Boost.Python. 
> Reloading works properly only with pure Python modules.
>
>   
Couldn't it depends on the platform ? From an OS perspective, a C 
extension is a dll/shared library, and not all OS can "deload" and 
"reload" libraries in a running process ? Maybe python implementation 
relies on the smallest common denominator ?

cheers,

David


From meine at informatik.uni-hamburg.de  Thu Sep 27 15:26:36 2007
From: meine at informatik.uni-hamburg.de (Hans Meine)
Date: Thu, 27 Sep 2007 15:26:36 +0200
Subject: [C++-sig] reloading modules written with Boost.Python
In-Reply-To: <46FB54CD.5020009@ar.media.kyoto-u.ac.jp>
References: <87ejglamuy.fsf@falma.de>
	<Pine.LNX.4.63.0709261400080.18948@brocoli.iro.umontreal.ca>
	<46FB54CD.5020009@ar.media.kyoto-u.ac.jp>
Message-ID: <200709271526.37113.meine@informatik.uni-hamburg.de>

Am Donnerstag, 27. September 2007 08:59:25 schrieb David Cournapeau:
> Fran?ois Duranleau wrote:
> > AFAIK, it is a limitation of any extension modules, not just
> > Boost.Python. Reloading works properly only with pure Python modules.
>
> Couldn't it depends on the platform ? From an OS perspective, a C
> extension is a dll/shared library, and not all OS can "deload" and
> "reload" libraries in a running process ? Maybe python implementation
> relies on the smallest common denominator ?

I think it's a theoretical limit/problem.  When unloading / reloading DSOs 
(DLLs / plugins), there are serious difficulties with static object 
destruction / initialization, and now imagine that someone still holds 
references to python objects that are instances of classes defined in 
extension modules..

AFAICT, there are enough reasons for not supporting that at the Python level 
(let alone boost::python, which does not even support PyFinalize ATM).

-- 
Ciao, /  /
     /--/
    /  / ANS


From ndbecker2 at gmail.com  Thu Sep 27 16:11:00 2007
From: ndbecker2 at gmail.com (Neal Becker)
Date: Thu, 27 Sep 2007 10:11:00 -0400
Subject: [C++-sig] Announcing project PyBindGen
References: <a467ca4f0709250221v4e62ea89v46efbddc1337bcaf@mail.gmail.com>
Message-ID: <fdgdm0$hjb$1@sea.gmane.org>

Gustavo Carneiro wrote:

>   Hello all,
> 
>   I'd like to announce a new project for producing python extensions,
>   called
> PyBindGen.  It follows a radical new path for Python bindings generation:
> it
> is itself written in (gasp!) Python!  And it does not even use C++
> templates at all! :-)
> 
>   The project is young but has been slowly developed for a few months now,
> so it has already reached a point where it is useful for many tasks.  For
> now, it has only a Python interface.  No interface description file or
> header scanning supported yet.  It also has been focused more on C++ code
> for now, although it was designed to also support pure C from the start.
> 
>   More information in: https://launchpad.net/pybindgen/
> 

I'd be interested to see some more examples, and some docs on this



From thauk at novuscom.net  Sat Sep 29 06:48:44 2007
From: thauk at novuscom.net (Thomas Hauk)
Date: Fri, 28 Sep 2007 21:48:44 -0700
Subject: [C++-sig] Problem with Pyste and simple struct
Message-ID: <D37949EF-F3BC-4AB3-B096-A272C1A50C97@novuscom.net>

Given Foo.h:

	struct Foo
	{
		unsigned char data[4];
	};

Pyste produces the following binding:

	// Module  
======================================================================
	BOOST_PYTHON_MODULE(PysteTest)
	{
	    class_< Foo >("Foo", init<  >())
	        .def(init< const Foo& >())
         	.def_readwrite("data", &Foo::data)
	    ;
	}

When compiled using bjam, produces the following error:

	..\..\boost\1_34_1\boost\python\data_members.hpp(64) : error C2440:  
'=' : cannot
	convert from 'const unsigned char [4]' to 'unsigned char [4]'
         	There is no context in which this conversion is possible

I've poured through the documentation, tutorials, everything, and I  
haven't found a single example like this.

What is wrong, and how do I fix it?

T

--
Some people, when confronted with a problem, think "I know, I'll use  
regular expressions."  Now they have two problems.
   --Jamie Zawinski, in comp.lang.emacs



From roman.yakovenko at gmail.com  Sun Sep 30 13:04:35 2007
From: roman.yakovenko at gmail.com (Roman Yakovenko)
Date: Sun, 30 Sep 2007 13:04:35 +0200
Subject: [C++-sig] Problem with Pyste and simple struct
In-Reply-To: <D37949EF-F3BC-4AB3-B096-A272C1A50C97@novuscom.net>
References: <D37949EF-F3BC-4AB3-B096-A272C1A50C97@novuscom.net>
Message-ID: <7465b6170709300404i206085edhbba8be05c7202d42@mail.gmail.com>

On 9/29/07, Thomas Hauk <thauk at novuscom.net> wrote:
>
> Given Foo.h:
>
>         struct Foo
>         {
>                 unsigned char data[4];
>         };
>
> Pyste produces the following binding:
>
>         // Module
> ======================================================================
>         BOOST_PYTHON_MODULE(PysteTest)
>         {
>             class_< Foo >("Foo", init<  >())
>                 .def(init< const Foo& >())
>                 .def_readwrite("data", &Foo::data)
>             ;
>         }
>
> When compiled using bjam, produces the following error:
>
>         ..\..\boost\1_34_1\boost\python\data_members.hpp(64) : error
> C2440:
> '=' : cannot
>         convert from 'const unsigned char [4]' to 'unsigned char [4]'
>                 There is no context in which this conversion is possible
>
> I've poured through the documentation, tutorials, everything, and I
> haven't found a single example like this.
>
> What is wrong, and how do I fix it?
>

Nothing wrong, Pyste doesn't generate right code.

There are few possible solutions to the problem:

1. To use indexing suite v2:
http://language-binding.net/pyplusplus/documentation/containers.html
2. To use Py++, which will generate code that works:
http://pygccxml.svn.sourceforge.net/viewvc/pygccxml/pyplusplus_dev/pyplusplus/code_repository/array_1.py?view=markup

-- 
Roman Yakovenko
C++ Python language binding
http://www.language-binding.net/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070930/7f991cc2/attachment.htm>

From jlisee at gmail.com  Sun Sep 30 19:38:44 2007
From: jlisee at gmail.com (Joseph Lisee)
Date: Sun, 30 Sep 2007 17:38:44 +0000 (UTC)
Subject: [C++-sig] Announcing pybindgen
References: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>
Message-ID: <loom.20070930T173407-556@post.gmane.org>

Gustavo Carneiro <gjcarneiro <at> gmail.com> writes:

> 
> 
> (manually replying from copy-pasting the archives because my c++-sig
subscription was disabled by accident).Nat Goodspeed wrote:       >Gustavo
Carneiro wrote:>>   Hello all,>>
> >>   I'd like to announce a new project for producing python extensions, >>
called PyBindGen.  It follows a radical new path for Python bindings >>
generation: it is itself written in (gasp!) Python!  And it does not 
> >> even use C++ templates at all! >Interesting! I would be curious to see you
contrast it with the Py++ >project:>>
> http://www.language-binding.net/pyplusplus/pyplusplus.html>>to get a sense of
when I might choose to use one vs. the other.I know Py++.  You cannot compare
Py++ with PyBindGen.  I would say that PyBindGen replaces 
> Boost.Python.  Py++ is a layer on top of Boost.Python.  Py++ generates
Boost.Python module definition sources through automatic scanning of C++ header
files.  PyBindGen lacks the header files scanning feature that Py++ provides,
and I really miss that feature in PyBindGen.  I hope that someone (maybe me)
finds time to work on that for PyBindGen, some day...  I'm not sure if Py++ is
modular enough to be able to receive a different code generation backend besides 
> Boost.Python (Roman, feel free to comment :).Although I like Py++ a lot, I
really hate Boost.Python.  Maybe it's because of my lack of skill in
understanding C++ templates, but I feel like Boost.Python hides too many details
underneath a layer of cryptic to follow set of C++ templates, while I need to
see the generated code in order to check that memory management details are
being declared and implemented correctly.  In addition, to compile 
> Boost.Python based bindings your users need to have the boost python library
and header files installed.  In contrast, PyBindGen generated extensions only
require python development header files in order to compile, nothing more.  I
also think 
> Boost.Python extensions compile to rather large modules...Regards,-- Gustavo
J. A. M. CarneiroINESC Porto, Telecommunications and Multimedia Unit"The
universe is always one step beyond logic." -- Frank Herbert
> 
> 
> _______________________________________________
> C++-sig mailing list
> C++-sig <at> python.org
> http://mail.python.org/mailman/listinfo/c++-sig
> 

Let me chime in on the code generation side too.  Just taking a look at your
example, you have to write almost twice as much python wrapping code as there is
C++ in the header you are wrapping.  Is this case for all headers you wish to
wrap, or is it because you were overexercising your library?

I welcome a project that removes the longer compile times of Boost.Python.  Yet
one of those reasons for the long compile times is because its hard to
understand template magic is doing quite a bit of work for you.

-Joe



From thauk at novuscom.net  Sun Sep 30 22:06:06 2007
From: thauk at novuscom.net (Thomas Hauk)
Date: Sun, 30 Sep 2007 13:06:06 -0700
Subject: [C++-sig] Problem with Pyste and simple struct
In-Reply-To: <7465b6170709300404i206085edhbba8be05c7202d42@mail.gmail.com>
References: <D37949EF-F3BC-4AB3-B096-A272C1A50C97@novuscom.net>
	<7465b6170709300404i206085edhbba8be05c7202d42@mail.gmail.com>
Message-ID: <08E17295-FAB8-4F29-BFA2-5ABFC731ED85@novuscom.net>

On Sep 30, 2007, at 4:04 AM, Roman Yakovenko wrote:
> Nothing wrong, Pyste doesn't generate right code.

Could you tell me what the right code would be?

As an aside, I'm rather shocked that Pyste can't generate the proper  
code for a simple struct like this. I would figure that would be one  
of the first test cases made. Unless it's a problem with  
Boost.Python, in which case what I said applies to that.

> There are few possible solutions to the problem:
>
> 1. To use indexing suite v2: http://language-binding.net/pyplusplus/ 
> documentation/containers.html
> 2. To use Py++, which will generate code that works:http:// 
> pygccxml.svn.sourceforge.net/viewvc/pygccxml/pyplusplus_dev/ 
> pyplusplus/code_repository/array_1.py?view=markup

I've looked at Py++ (before I tried Pyste) but I wasn't impressed at  
how complex the scripts were. I may go back to it if I don't have a  
choice, though.

T

--
Some people, when confronted with a problem, think "I know, I'll use  
regular expressions."  Now they have two problems.
   --Jamie Zawinski, in comp.lang.emacs



From gjcarneiro at gmail.com  Sun Sep 30 22:23:23 2007
From: gjcarneiro at gmail.com (Gustavo Carneiro)
Date: Sun, 30 Sep 2007 21:23:23 +0100
Subject: [C++-sig] Announcing pybindgen
In-Reply-To: <loom.20070930T173407-556@post.gmane.org>
References: <a467ca4f0709260548j42e3bba8y2b0aaf3a43b42621@mail.gmail.com>
	<loom.20070930T173407-556@post.gmane.org>
Message-ID: <a467ca4f0709301323y3138176wae864cd1082061ee@mail.gmail.com>

On 30/09/2007, Joseph Lisee <jlisee at gmail.com> wrote:
>
> Gustavo Carneiro <gjcarneiro <at> gmail.com> writes:
>
> >
> >
> > (manually replying from copy-pasting the archives because my c++-sig
> subscription was disabled by accident).Nat Goodspeed wrote:       >Gustavo
> Carneiro wrote:>>   Hello all,>>
> > >>   I'd like to announce a new project for producing python extensions,
> >>
> called PyBindGen.  It follows a radical new path for Python bindings >>
> generation: it is itself written in (gasp!) Python!  And it does not
> > >> even use C++ templates at all! >Interesting! I would be curious to
> see you
> contrast it with the Py++ >project:>>
> > http://www.language-binding.net/pyplusplus/pyplusplus.html>>to get a
> sense of
> when I might choose to use one vs. the other.I know Py++.  You cannot
> compare
> Py++ with PyBindGen.  I would say that PyBindGen replaces
> > Boost.Python.  Py++ is a layer on top of Boost.Python.  Py++ generates
> Boost.Python module definition sources through automatic scanning of C++
> header
> files.  PyBindGen lacks the header files scanning feature that Py++
> provides,
> and I really miss that feature in PyBindGen.  I hope that someone (maybe
> me)
> finds time to work on that for PyBindGen, some day...  I'm not sure if
> Py++ is
> modular enough to be able to receive a different code generation backend
> besides
> > Boost.Python (Roman, feel free to comment :).Although I like Py++ a lot,
> I
> really hate Boost.Python.  Maybe it's because of my lack of skill in
> understanding C++ templates, but I feel like Boost.Python hides too many
> details
> underneath a layer of cryptic to follow set of C++ templates, while I need
> to
> see the generated code in order to check that memory management details
> are
> being declared and implemented correctly.  In addition, to compile
> > Boost.Python based bindings your users need to have the boost python
> library
> and header files installed.  In contrast, PyBindGen generated extensions
> only
> require python development header files in order to compile, nothing
> more.  I
> also think
> > Boost.Python extensions compile to rather large modules...Regards,--
> Gustavo
> J. A. M. CarneiroINESC Porto, Telecommunications and Multimedia Unit"The
> universe is always one step beyond logic." -- Frank Herbert
> >
> >
> > _______________________________________________
> > C++-sig mailing list
> > C++-sig <at> python.org
> > http://mail.python.org/mailman/listinfo/c++-sig
> >
>
> Let me chime in on the code generation side too.  Just taking a look at
> your
> example, you have to write almost twice as much python wrapping code as
> there is
> C++ in the header you are wrapping.


But the generated code is nearly 10 times as large as the Python code the
generates it, while still being relatively compact (I think it's very much
smaller than an equivalent boost.python module in terms of code size,
although I have not bothered yet to create the same project with both
boost.python and pybindgen to compare accurately).

  Is this case for all headers you wish to
> wrap, or is it because you were overexercising your library?


No overexercising; it's like this.

I welcome a project that removes the longer compile times of Boost.Python
> .  Yet
> one of those reasons for the long compile times is because its hard to
> understand template magic is doing quite a bit of work for you.


I think Boost.Python has compile-time introspection for function/method
parameters, and so you only have to tell Boost.Python a list of class names
and method names; that's the main reason the BP interface description file
is smaller.

Admittedly, PyBindGen could use some introspection itself, but that can be
an additional layer.  I would like to have a layer that uses pygccxml, or
something like that.  Some day when I have more time... In the mean time I
believe the PyBindGen Python API is already rather useful, if a bit more
verbose than boost.python.

-- 
Gustavo J. A. M. Carneiro
INESC Porto, Telecommunications and Multimedia Unit
"The universe is always one step beyond logic." -- Frank Herbert
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/cplusplus-sig/attachments/20070930/c186d4a2/attachment.htm>