I started off looking for a request time compiler of LESS for Django and initially found django-css which seems to serve the purpose great. Compressing static files on the fly is definitely a nice added bonus as well. It does so by containing a fork of django_compressor. But on further inspections, I jumped ship. The original project, django_compressor, sees a more regular update and is now Django 1.3 ready while the ‘successor’ isn’t. Funny thing is django_compressor supports compiling any CSS formats compilable via command line. With a better documentation overall, seems like the original has beat the sequel.

In the official Django logging docs, it wasn’t very clear about how to log to files. As you can understand, Django can use any Python logging classes that are all listed here. One of them is FileHandler. To use it, just add this to your settings.py

LOGGING = {
    ...
    'handlers': {
        ...
	'file':{
	    'level': 'DEBUG',
	    'class': 'logging.FileHandler',
	}
    },
    ...
}

But the FileHandler class constructor needs more parameters. To add them, you have to add the parameter name key with its value into the dictionary.

LOGGING = {
    ...
    'handlers': {
        ...
	'file':{
	    'level': 'DEBUG',
	    'class': 'logging.FileHandler',
            'filename': 'debug.log',
	}
    },
    ...
}

A quickie:

import ipdb; ipdb.set_trace()

This puts a breakpoint in the code using ipdb. It has the advantage of having better formatted output, tab completion etc over the vanilla pdb

If you load a GIF file with PIL via Image.open(‘giffile.gif’) and then try to look at its pixels, you would get integers instead of tuples since the GIF pixels refers to one of the 256 colours in the GIF colour palette. The palette would then contain the RGB value of the pixel.

To avoid all this hassle and just get RGB tuple directly:

gif = Image.open('giffile.gif')
rgbimage = GIF.convert ('RGB')
rgbimage.getpixel((0,0))
>>>(231, 10, 54)

Used a NumPy array. Doesn’t work if the diagonal+1s are white of course.

import Image
from numpy import array, zeros, uint8
 
line = Image.open('wire.png')
# third dimension is for colours
a = zeros((100, 100, 3), dtype=uint8)
 
step = array([0, 1])
position = array([0, 0])
count = 0
 
# continue until when the next spot expected to be unfilled is filled
while not max(a[tuple(position)]):
	# paint colour
	a[tuple(position)] = array(line.getpixel((count, 0)))
 
	# if reached a wall
	if max(position + step) > 99 or min(position + step) < 0 or max(a[tuple(position + step)]):
		# change direction
		step = (abs(step) ^ 1) * (-step[0] if step[0] else step[1])
 
	# advance
	position += step
	count += 1
 
# convert to image
Image.fromarray(a).save('swirl.jpeg')

a = array((1, 2, 3))
print a
>>> array([1, 2, 3])
tuple(a)
>>> (1, 2, 3)

Pretty lame right?

If you just picked up a generic OBD-II – USB interface on eBay and have a Mac, it is true that it is generally more convenient to access these hardware on Windows. Even embedded device developers tend to use Windows to develop against these generic FT232R chip based USB-UART devices simply because of more available supports. But worry not, it can be done on Mac (really on Linux with a more open-platform framework than Windows), it’s just a bit more complicated since it tends to come in be open-source source code rather than prepackaged self-sufficient binaries.

But in this case, it’s not too bad. You can use pyOBD, an Python open-source project. You just need some packages from MacPorts

sudo port install py26-serial
sudo port install py26-wxpython

Download and unpack the source code. And run directly with

pythonw pyobd

p.s. you need X11

Ok, I looked this up twice now… once too many

Suppose you have a datetime of the form “2010-05-08T23:41:54.000Z” and you want a local datetime object

import pytz, dateutil.parser
utctime = dateutil.parser.parse("2010-05-08T23:41:54.000Z")
localtime = utctime.astimezone(pytz.timezone("Canada/Eastern"))

Boom

The interweb seem to incline on py2app when it come to deploying applications on mac. I’ve tried to make a single deployable .app file for my application for a long time trying to follow these instructions from ars technica. I’m not a hacker and just want to produce a deployable usable application for others to use. And it seems py2app from MacPorts wasn’t able to surmount the Snow Leopard’s 64-bit compatibility issue.

And then, I was slacking off while studying for my final and out of nowhere I found PyInstaller‘s explicit support for PyQt and its recent support for the mac. And after trying, almost everything works out without much of a kink. Credit goes to ChrisWayg who produced an amazingly complete and up-to-date set of instructions to follow. I’m merely telling how my application did using his instructions (April 2010) and hopefully doing my part to draw more attention to the excellent PyInstaller.

My Application

A PyQt application to help photographers apply custom watermarks in a manual but in an assisted way.

Uses:

• PIL 1.1.7
• Qt4 4.6.2
• PyQt4 4.7.2
• SIP 4.10.1

All from MacPorts on Python 2.6.5, OSX 10.6.3.

Prepare PyInstaller

PyInstaller is kinda special in that it’s not installed anywhere. It’s just a bunch of Python scripts that work on stuff in place. While you’re at it, read the manual.

svn co http://svn.pyinstaller.org/trunk ~/PyInstaller

Or put it somewhere you want.

Then you need to build the bootloaders (no longer necessary with the newest version!). If you’re making PyQt applications, you probably have XCode already. Anyway, you need it.

cd source/linux
python Make.py
make
cd ..
python Configure.py

Making your Application

So far, PyInstaller has a problem of not showing your application at the front when you run it. You can fix it in your own code by adding

form.raise_()

right after

form.show()

with “form” being whatever you called your instance of MainWindow().

Like with py2app, you gotta first make a “spec file”.

python Makespec.py --onefile /path/to/YourApplication.py

This will make a YourApplication/YourApplication.spec file in your PyInstaller folder.
To make it work on mac, add

import sys
if sys.platform.startswith("darwin"):
    app = BUNDLE(exe,
                 appname='WhateverYouWantToCallIt',
                 version=1)

at the bottom.

For my application, it made 70 files inside the .app file on default. –onefile makes it more neat and 3 times smaller in size! but it does make it a bit slower. If you care to make it as fast as possible, leave out that option but you have to fix a bug yourself.

Finally, build the application!

python Build.py YourApplication/YourApplication.spec

This will make your application and leave a YourApplication.app in your PyInstaller folder.

Fix the Application

Put your own nice icon on the application. Copy your graphic, right-click your application and choose Get Info, click the icon and paste the graphic.

Open the content of your application, open Contents/Info.plist, uncheck “Application is background only” and save. If you’re using a plain text editor, change LSBackgroundOnly to false.

There is only one last problem to deal with on mac. You have to copy the qt_menu.nib file.

locate qt_menu.nib

to find it. If you use MacPorts, it’s probably somewhere like /opt/local/libexec/qt4-mac/lib/QtGui.framework/Versions/4/Resources/qt_menu.nib

Copy it to your YourApplication.app/Contents/Resources

Boom, you can double click your application and it will run!

Ok, one last problem, I swear. When you run, it shows 2 icons on the dock… pretty ugly. This hack can fix it, but it’s not perfect as it leaves junk on your computer. Hopefully PyInstaller can address it soon.

Conclusion

The program is beautiful! You don’t have to worry about your Python plug-ins, your 64-bitness, anything (mostly). It just works. I have yet to figure out how to make 32-bit binaries on 64-bit systems and how to make upx work properly to reduce executable size. I’m currently running at 32mb for an application that really should be 1mb. But then again, it’s packaging a whole new GUI framework that doesn’t exist on the target computer with the application. Consider Skype (yes, it’s infinitely more complex than my thing), it is still 43mb.

So you want a variable that stays between different calls of a function. Not the sexiest thing ever but always handy in small programs.

There’s tons of ways of doing this. You can embark on a quest to find the meaning of Pythonic or take this method that’s relatively simple:

def a():
    if not hasattr(a, "b"): a.b = 0
    a.b += 1
    print a.b

Calling a(), you’ll get 1, 2, 3, …

Note attribute ‘b’ of ‘a’ does not exist until you declare it for a first time. My main preference here is that ‘static’ variables used this way does not spill onto the rest of your code. Also, it’s clean, no classes, no data structures.

When you run Scapy without a default IPv6 routing gateway, Scapy will display this annoying warning:

WARNING: No route found for IPv6 destination :: (no default route?)

You definitely don’t want to see it every time you run the script you built with Scapy. To get rid of it, simply add

import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)

before importing Scapy to suppress all messages below error messages

Python has the ability to alter its sys.stdout as to redirect its print commands to pretty much anything.

If, for instance, you want to print to both standard output and to a log file, you can create a class to handle the stdout like such:

class MyOutput():
    def __init__(self, logfile):
        self.stdout = sys.stdout
        self.log = open(logfile, 'w')
 
    def write(self, text):
        self.stdout.write(text)
        self.log.write(text)
        self.log.flush()
 
    def close(self):
        self.stdout.close()
        self.log.close()
 
sys.stdout = MyOutput("log.txt")
print "blah blah blah"

This class would implement stdout’s write and close functions. We then assign the stdout to an instance of this class. Inside the write/close implementations, we also add functionalities to write the texts in a log file as well. We flush the file buffer on each write because otherwise, we would only be able to see the file content when sys.stdout (therefore MyOutput) closes.

With this, outputs of print will both show in the screen and in the file log.txt

There are some 64-bit related issues when using PyQt and Snow Leopard. There’s the way to resolve it by reverting to 32-bits:

1. Get the latest versions of PyQt and SIP. You need Qt installed of course.
2. Configure SIP using

python configure.py --arch i386

3. Configure PyQt using

python configure.py --use-arch=i386

4. Finally, make sure your python is running in 32-bit mode because current Qt doesn’t support 64-bit mode. Add

   export VERSIONER_PYTHON_PREFER_32_BIT=yes

   to your .bash_profile in your home directory

5. If your Python still refuses to run in 32 bit mode, try

   arch -i386 python

This simple tutorial shows how you can create a program with Python and Qt to allow for image files from Explorer/Finder/Nautilus to be dropped in a list widget and create list items with thumbnails

First we subclass a QListWidget to handle events

class DragDropListWidget(QListWidget):
	def __init__(self, type, parent=None):
		super(DragDropListWidget, self).__init__(parent)
		self.setAcceptDrops(True)
		self.setIconSize(QSize(72, 72))
 
	def dragEnterEvent(self, event):
		if event.mimeData().hasUrls:
			event.accept()
		else:
			event.ignore()
 
	def dragMoveEvent(self, event):
		if event.mimeData().hasUrls:
			event.setDropAction(Qt.CopyAction)
			event.accept()
		else:
			event.ignore()
 
	def dropEvent(self, event):
		if event.mimeData().hasUrls:
			event.setDropAction(Qt.CopyAction)
			event.accept()
			l = []
			for url in event.mimeData().urls():
				l.append(str(url.toLocalFile()))
			self.emit(SIGNAL("dropped"), l)
		else:
			event.ignore()

The initialiser simply allows drops into the widget. It also makes sure thumbnails are well visible.

Then each event performs a check to make sure the object being dropped is indeed a file. Finally, at the drop, the class sends an event with a list of local files dropped. Of course all handling could be done within the class but I will eventually need to manage dropped files in a parent form so an event is used here.

self.connect(self.pictureListWidget, SIGNAL("dropped"), self.pictureDropped)

In the parent class, I first connect the signal I defined in the custom list widget.

def pictureDropped(self, l):
	for url in l:
		if os.path.exists(url):
			picture = Image.open(url)
			picture.thumbnail((72, 72), Image.ANTIALIAS)
			icon = QIcon(QPixmap.fromImage(ImageQt.ImageQt(picture)))
			item = QListWidgetItem(os.path.basename(url)[:20] + "...", self.pictureListWidget)
			item.setStatusTip(url)
			item.setIcon(icon)

Here the Image and ImageQt modules of PIL are used to process the images. The Image class can help to create a thumbnail of the opened image. ImageQt can then convert the Image class into an ImageQt class which is a subclass of QImage. QIcons can only be constructed from QPixmap so we build one from the ImageQt class and send it to make a QIcon.

There you go, you now have a working list widget which allow image files to be dropped and can list them with thumbnail.

Of course, this snippet doesn’t check for other file types being dropped. More code would take away the focus.