Advanced C++ / Python integration with Boost.Python (Part 3)

In this final part of the series I’m going to look at one further way we can use Boost.Python to help when using a C++ class within Python.

In the previous part we built a wrapper for a C++ class, exposing a number of class methods to Python.

However, in Python, it’s quite typical for a class to use properties as well as methods.

So to begin – let’s take a moment to look at properties within the context of classes in Python.

For example, if we had a Python class which looks like this:

class simple:
    def __init__ (self):
        self._data = None

    def set_data(self, data):
        self._data = data

    def get_data(self):
        return self._data

We could then use it, something like this:

import example

s = example.simple()
s.set_data(7)

print(s.get_data())

Whilst this works, we might reasonably say that the necessity to use getter and setter functions directly is not especially Pythonic – as it’s not how most built-in objects behave.

Instead we’d expect to be able to use it more like this:

import example

s=example.simple()

s.data = 7

print(s.data)

We can do exactly this; if we use properties…

Continue reading “Advanced C++ / Python integration with Boost.Python (Part 3)”

Advanced C++ / Python integration with Boost.Python (Part 2)

Last time we looked at how to use Boost.Python to wrap a very simple piece of C++ code. This time we’re going to take that one step further along, and do the same thing for a more complex C++ example – which includes a C++ Class.

For the purposes of this example – let us assume that we have a “legacy” C++ class (i.e. one that we’re not going to change): which looks something like this:

class ExampleClass
{
public:

  ExampleClass();
  void print_state();
  unsigned char* exporter();
  void set_data(uint8_t, uint8_t, uint8_t);
  void importer(unsigned char*, int);

private:
  uint8_t a;
  uint8_t b;
  uint8_t c;

};

This (deliberately, slightly contrived) class has three methods (and a constructor). We can set the three 8-bit unsigned integers (uint8_t) directly using the set_data() method; we can print the data to the screen; or we can either import from or export to an unsigned char*.

In order to be able to use the importer & exporter methods with Python (via Boost.Python) we’ll need to further wrap these – as Boost.Python won’t let us use unsigned char* directly.

Continue reading “Advanced C++ / Python integration with Boost.Python (Part 2)”

Advanced C++ / Python integration with Boost.Python

In a previous post, I described how you could use the ctypes Python library to import a C++ class to make it usable from within Python. There is however, another way to do this; and that’s by using Boost.Python (which as the name suggests is a part of the Boost C++ library suite).

Whilst this method makes our code on the C++ side slightly more complicated; it significantly simplifies the Python code – and it let’s us use some more powerful features.

To begin let’s start with a simple example.

// hello.cpp

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

char const* greet()
{
   return "hello, world";
}

std::string multi_bob(int n)
{
   std::string name = "Bob";
   std::string r = "";
   for (int i=0;i<n;i++)
      r += name;
   return r;
}

BOOST_PYTHON_MODULE(hello)
{
    using namespace boost::python;
    def("greet", greet);
    def("multibob", multi_bob);
}

Everything above the BOOST_PYTHON_MODULE line is perfectly ordinary C++ code. The clever bit comes in when we call the BOOST_PYTHON_MODULE macro (which is defined within the Boost.Python header)…

In this case we’re creating a Python module – with two methods: one based on our very simple greet() function (which we’re also going to call greet); and one based on the more complex multi_bob(int) function. Note that for this second function, to show the fact that the linkage between the C++ & Python code can be very flexible, we give it a different name on the Python side. Also note that we don’t need to tell the macro about the signature of the function as this is handled for us by Boost.Python.

Continue reading “Advanced C++ / Python integration with Boost.Python”

Calling C++ Classes from Python, with ctypes…

I recently found myself needing to call a C++ class from within Python. I didn’t want to call a separate process (as I had previously when using Thrift – see Using Apache Thrift for Python & C++); but rather to call a C++ library directly.

Before I go on I should say that there are a lot of different ways to do this is Python – and I’ve picked one that worked for me. Other techniques are available – and opinion seems quite divided as to which (if any) technique is ‘best’.

To start with we have our C++ class, written in the usual way.

Continue reading “Calling C++ Classes from Python, with ctypes…”

Using Apache Thrift for Python & C++

Apache Thrift is a software framework for cross-language: providing what is essentially a remote-procedure call interface to enable a client application to access services from a service — which can be written in the-same, or another language. Thrift supports all of the major languages that you’d expect to use: including Python, C++, Java, JavaScript / Node.js, and Ruby.

Unfortunately, whilst there are quite a few tutorials on how to use Thrift: some of them concentrate on explaining how Thrift is working behind the scenes (which is important, of course): rather than on how to use it. There also aren’t that many that concentrate on using C++. So having spent some time working through some of the tutorials (and the book Learning Apache Thrift), I though I’d have a go at writing something of a practical guide. I’m quite deliberately not going to focus on how Thrift works: if you want that, let me suggest the Apache Thrift – Quick Tutorial. I’m also going to assume that you have Thrift installed on your computer already (again, there are lots of sets of instruction on how to do this — Google will be your friend), and that you’re using a Linux or MacOS computer. You should be able to follow-along with most of this if you’re using Windows: but there will be a few differences, especially when it comes to compiling C++ files.

Continue reading “Using Apache Thrift for Python & C++”

RegEx Golf

RegEx Golf
Inspired by the famous XKCD cartoon that started it and by Google’s Peter Norvig over on O’Reilly.com I decided to play some RegEx Golf myself this Easter…

If you’re not familiar with the game – the idea is to write the shortest regular expression possible that will select every element of a list, without selecting any elements from a second list. But what are regular expressions, you ask? Well, they’re a special sequence of characters that specify a particular textual patter – so you can use the appropriate regular expression when programming to automatically extract specific text from a list, file, or other text. There are some great tutorials on the web if you want to learn regular expressions (and you really should – because they’re great) – for example regexone.com

I didn’t want to use lists of Presidents of the United States (as that had been done) – so I decided to have a go at the age-old challenge: animal, mineral, or vegetable

Continue reading “RegEx Golf”

Google Chromebook

Google & Samsung have announced the details of the first generation of Chromebooks – thin-client laptops running Google’s Chrome OS & reliant on a web connection for all of their capabilities. But can they succeed in a competitive market-place?

The Chromebook is a nice idea. Thin-client (cloud) computing is becoming (if not yet the norm) common-place in many corporate data centres; but (to date) it’s not really been a viable option for the home-user. Chrome OS changes that – by putting a cloud-based OS (and thin-client laptop) into the hands of home users.

The question is – are home user’s ready for cloud computing?

Google claim that the Chromebook can still be used without a constant network connection, because off-line versions of Google Docs, GMail, and Google Calendars. This will redress one of the major concerns – especially in the UK where the prevalence of wifi isn’t nearly as common as it could be. Even a 3G-based Chromebook won’t guarantee a network connection – especially when travelling by train.

The other problem with cloud-computing, is the question of whether people trust the cloud… Web-based email has been around for a long-time now, and (in fact) lots of people use webmail as their primary means of reading their email. This is the first example of cloud-services that most people will have experienced. We trust the internet with our email – since it’s intended to travel over the internet anyway… But do we trust the cloud – be it google or Amazon, or anyone else for that matter with our data? Our spreadsheets? Our banking records? Our letters?

And that’s a real question. It’s not at all clear if people do… Yes there are quite a few advantages to using a cloud (your data is accessible from multiple locations, it’s backed up, and it’s not dependant on any specific user’s hardware); but are these outweighed by the dangers  – and (perhaps more importantly) the perception of danger that comes from not owning one’s own data?

And then there’s the price…

At £350 for the wifi only Samsung Chromebook, these machines aren’t cheap. In fact, apart from the battery-life (claimed to be around 8-hours) they stack up pretty unfavourably when compared to cheap laptops. £350 will buy you a Windows 7 laptop, with hundreds of Gb of local storage; and the ability to run real applications.

Alternatively it’ll go a long way towards buying an iPad or an Android tablet; and it’ll be these, I think, that’ll be the main competitors for the Chromebooks (at least as far as home users go). Given the choice between a portable tablet with all-day battery life, and a laptop – with less capability & (arguably worse usability for many tasks) – are people going to choose the Chromebook?

The US prices for the Chromebooks translate rather nearer to £250 – and at that price (less than £300) the Chromebook becomes a very different prospect; but at £350, its a far harder choice.

Now none of this means that Chromebooks won’t be successful. For business users (especially small to medium sized businesses) already using Google Apps, Chromebook can be a great platform; but for home users – where there’s so much competition – I think it’s going to come down to the price…

Ed Roberts (1941-2010)

I was saddened today to hear (albeit rather belatedly) about the death of the some-time pioneering micro-computer engineer Ed Robterts.  Roberts died on 1st April 2010: aged just 68.

Roberts’ creation, the Altair 8800 was, arguably, the most important personal micro-computer ever made.  It was the machine that made the dream of a personal computer viable…  Yes, of course, the Apple ][ was the machine that brought “personal” computing to the masses – but there wouldn’t have been the Apple ][, had it not been for the market that the Altair created.

Roberts was a true pioneer – leaving behind the industry he created, long before it became the billion-dollar industry it would become; and instead taking up the white-coat of a doctor of medicine…

RIP