In the embedded world where C/C++ are the predominantly used languages, the enum data type is heavily used. It’s quick and easy to use and understand for specifying flags and register values.  Not yet understanding that Python’s real strength is hash-able data types and that a switch statement didn’t exist, I found myself wanting to use traditional C/C++ enumerated data types when I first started learning Python.

Even though there is no “enum” keyword in Python, there are a few easy ways to create an enumerated data type. The following snippet uses the Python argument packer to create a new data type that is just a key value paired dictionary.

def enum(*args):
    enums = dict(zip(args, range(len(args))))
    return type('Enum', (), enums)

Thats it. This simple function takes a list of items and auto-completes the value. It can easily be used like the following.

alignment = enum("left","center","right")

def alignText(text, pos):
    if pos == alignment.left:
        pass

alignText("some text", alignment.left)

Another object oriented approach I came across is to overload the existing Python set( ) data type and override the __getattr__() method.

class Enum(set):
    def __getattr__(self, name):
        if name in self:
            return name
        raise AttributeError

    def __setattr__(self, name, value):
        pass

    def __delattr__(self, name):
        pass

Neither approach fully addresses all the functionality of the C/C++ enum type. The missing functionality is the ability to specify a value for an entry and having all sequential entries be incremented by one (below). However, both solutions do offer a quick enumerated data type that can be used in most scenarios.

enum alignment = {	LEFT,		// 0 
					CENTER=10,	// 10
					RIGHT		// 11 
		 		 };

For anyone contemplating writing a multi-touch application, PyMT can be a fun and easy way to see instant results. Its API offers several useful widgets that allows for fast prototyping. With that said, PyMT should not be used for a commercial or high performance applications, as it has some major limitations with its inheritance architecture and screen paint logic (plus it comes with a GPL license). Some of these issues have been addressed in the teams rewrite of PyMT called Kivy. Although Kivy appears promising, it is still in its infancy and will need a few more release iterations before being adopted by the masses.

The weakest PyMT widget is by far the video player. Its integration with gstreamer is not nearly as complete as PyQt and it doesn’t have full multi-touch support. To address the multi-touch issue I wrote the following code snippet for one of Immersive’s first early stage in store product browser. It adds a default picture when the video is at position 0 and superimposes a “play” button when paused. In addition it uses the MTScatter widget as its base class which allows the user to manipulate the video using full multi-touch gestures when playing.

class scatVid(MTScatter):
    def __init__(self, filename, image, **kwargs):
        # image is a pre-constructed Image( ) object to be used at start of video
        super(scatVid, self).__init__(**kwargs)
        self.image = MTImage(image)
        self.play = MTImage(Image('./play_button.png'))
        self._posXY = None
        self.video = MTVideo(filename=filename, eos='loop')
        self.video.hide_controls()
        self.video.player.position = 10
        self.size=self.video.size
        connect(self.video, 'on_resize', self, 'size')
        connect(self.video, 'on_resize', self.image, 'size')
        connect(self.video, 'on_resize', self.play, 'size')

        self.add_widget(self.video)
        self.add_widget(self.image)
        self.add_widget(self.play)
        self._state = ""

    def stop(self):
        self.video.player.stop()

    def play(self):
        self.video.player.play()

    def hide(self):
        self.video.player.stop()
        super(scatVid, self).hide()

    def show(self):
        self.video.player.load()
        super(scatVid, self).show()

    def _get_state(self):
        return self.video.player.state

    def _get_posXY(self):
        return self._posXY
    def _set_posXY(self, x, y):
        print "setting posXY: %dx%d" %(x,y)
        self._posXY=(x,y)
        self.pos=(x,y)

    def draw(self):
        super(scatVid, self).draw()
        if self.state != "playing":
            if self.video.player.position < 2:
                self.image.show()
            else:
                self.play.show()
        else:
            self.image.hide()
            self.play.hide()

    state = property(lambda self: self._get_state(),
            doc='Get the video playing status')

To see the above code in action look here. You can use any play button piece of artwork, but for your convince here is the one I used.

Visit the Redux page for most recent information on python-jsocket package.