python - 1.3.2010 - 15.9.2010

home | Disco Project - yesterday I already had mincemeat, disco is similar but more advanced if the simple model of mincemeat is not enough.

octopy - Project Hosting on Google Code - and a small and simple implementation of mapreduce in Python.

mincemeat.py: MapReduce on Python - stupidly simple map-reduce framework. Just a Python file and minimal code and you have a map-reduce cluster.

NodeBox for OpenGL | City in a Bottle - builds on Pyglet and provides a 2D animation library for Python.

objgraph - Drawing Python object reference graphs - I'll definitely check this out, even though I fear my memory structures are too wild to be represented graphically (many such tools assume that everything more complex is encapsulated in objects, but with a more functional programming approach, standard data structures are used much more heavily). It would be worth a try, though.

pyglet - interesting small graphics library for Python. Looks nice and is multi-platform and should be easy to install (no dependencies).

Plac - a very nice option parser for command-line tools. The special feature: the parameters are simply determined from the function definitions and the whole thing works from Python 2.3 onwards (with some limitations in syntax, as there were no decorators in Python 2.3 and annotations only exist from Python 3 onwards). Seems to be a good way to build tools that should run on multiple Python versions (because otherwise only getopt remains and that is really very primitive).

Python Datastructures Backed by Redis @ Irrational Exuberance - Redis itself is already very interesting because it is not just a simple key-value store, but structured data (lists, sets) are allowed as values. And with this library, Redis structures are accessible as normal Python data types, making programming with Redis even simpler. Combined with replication in Redis, this could be very interesting in clustered environments.

Paver: Easy Scripting for Software Projects - interesting small replacement for Make. Especially in connection with Python projects, it sounds very useful.

Pysistence - just checked if something like this exists or if I should write it myself. Pysistence implements functional persistent data structures for Python. This means that there are no side effects, but rather that each function provides a new version of the data, with common substructures shared across different versions (in order to be able to work efficiently with them both in terms of runtime and space requirements). I definitely need to take a look at this, as in many cases the lack of proper implementations of functional data structures in Python has bothered me.

The Official web2py Book - I'm a Djangonaut, but here's an online web2py book. And it doesn't hurt to look over the horizon.

Meliae python memory analysis in Launchpad - sounds very interesting, bookmarked for later problems, could help with one or the other problem. Installation is quite simple via pip install meliae or easy_install meliae, it is also listed on pypi.

[Cython] ANN: Cython 0.13 released!](http://www.mail-archive.com/cython-dev@codespeak.net/msg09503.html) - There's a new release for Cython (formerly PyRex). And the language for Python extensions is becoming increasingly complete. This makes it much easier to create performance-critical parts of the code because you can work in a very Python-like language.

Scribes - Simple And Powerful Text Editor for GNOME - interesting project, an editor that is expandable in Python. Since I work with Linux at work, I could take a look at it after the vacation.

PEP 380 -- Syntax for Delegating to a Subgenerator - a very interesting point for extending Python. So interesting that Guido could imagine implementing this PEP even now, bypassing the moratorium. Generators in Python are becoming a very pleasant language feature for me - code often becomes much more compact and readable. If only Django were also available for Python 3, I could use some of the new features there. Python 2.7 somewhat alleviates the pain.

saucelabs's monocle at master - GitHub - interesting package for easier programming of asynchronous routines in Python. Particularly interesting: it supports not only Twisted but also Tornado.

Valued Lessons: Monads in Python (with nice syntax!) - very interesting hack that can indeed have practical use. Found at Schockwellenreiter.

Python IDE with Django support : JetBrains PyCharm - the JetBrains people (who make IntelliJ) have now built a pure Python IDE based on IntelliJ and it has a lot of interesting features. I should take a look at it, especially since it also includes support for Django and Google App Engine.

Lightweight Approach to AOP in Python - and while we're on the topic of AOP: there is also a library for Python.

jessenoller.com - PEP 3148 Accepted: “futures – execute computations asynchronously” - the PEP is a bit too oriented towards the Java world, I would have preferred a leaner and more Python-specific implementation, but at least. Particularly interesting are the considerations to look at concurrency stuff again and sort it out.

Dropbox API - and this could become quite an important toy for me in the near future - an API for Dropbox. Of course, most of the time I just need to send files back and forth, so simply using Dropbox is sufficient. But for some things, an API to access the metadata on Dropbox would indeed be interesting (one of my projects that has been on the back burner for a while would be an implementation of the Simpletext.ws service from Google App Engine on a normal Python service with Dropbox as the backend, for example).

Python 2.7 Release - some good stuff in it, especially the set and dictionary comprehensions I like - so far I have made do with generator comprehensions, but the dict comprehensions just look better and more readable. Due to various dependencies, I am probably still tied to Python2 at work for some time to come, so it's nice that some of the Python3 features are also becoming available in Python2. However, I am one of those who really want Python3 - just for the much cleaner string handling with Unicode as default. But as long as Django does not run on Python3, I am reluctantly stuck with Python2.

jessemiller's HamlPy - I need to check this out, an implementation of HAML (basically a shorthand notation for HTML) with integration for Django. This could be interesting for the many small internal templates, as they are created by programmers and not designers. However, I would first have to see how well (or how poorly) I can integrate JavaScript with it. But definitely interesting - HTML is not really Diff/Merge-friendly and simply annoying to write and read.

Nicholas Piël » ZeroMQ an introduction - a brief overview of how asynchronous messaging with ZeroMQ and Python looks and how the different messaging scenarios can be represented. I should take a closer look, because it's something like a deconstructed framework for messaging - so only the building blocks to be able to build your own, optimally tailored to the problem, messaging system.

PyFilesystem 0.3 released - looks interesting, filesystems in and with Python. You can write FUSE filesystems in Python or simply access Amazon S3 or FTP with the same code.

PyPy Status Blog: A JIT for Regular Expression Matching - this is the reason why I firmly believe that the future of Python is PyPy (or something similar) and why I want something like PyPy. An environment where all language elements are reduced to a common base, where I can work at all levels of abstraction - if necessary even at the level of code generation. This offers significantly more pleasant optimization options than the CPython model, where higher performance beyond a certain point is only achievable through C extensions. However, I also come from Lisp, where it is quite common to work with a language family from high-level language elements down to code generation. My Xerox Lisp machine had a TCP/IP stack written in a subset of Interlisp - this is quite comparable to the situation of PyPy and RPython.

nutshell — Lettuce v0.1.2 (barium release) documentation - lettuce is cucumber for Python. cucumber is BDD for Ruby. BDD is behaviour driven development - first you write BDD stories, then you write the code and a small Python module that connects the story with the code. This automatically generates the test code. It looks a bit silly at first glance, but has the advantage that test cases actually orient themselves towards specified behavior and are not simply abstractly programmed into the woods. In combination with testcase-pro-bugreport, this provides a quite usable test environment.

Plac: Parsing the Command Line the Easy Way - interesting library for parsing parameters for Python tools. Much more compact than other libraries. Parameters are automatically derived from defined functions using inspect.

Python Package Index : Baker 1.1 - and yet another alternative of a more declarative command line parser.

Aeracode :: On Django And Migrations - South core libraries may move to the Django core in the near future (possibly targeting Django 1.4). I approve. Having the basis for migrations already in the Django core would not only be helpful for migrations but also for projects that require higher dynamics in the data models - my current hack with sqldiff and some self-made code is just that: a hack. It's probably time to take a closer look at South (so far only briefly looked at it, but what I've seen I liked) and consider whether I should already now put my hack on a more powerful basis.

HackageDB: berp-0.0.1 - someone is programming a Python 3 compiler and interpreter in Haskell. At least intellectually quite interesting.

daemon 1.0 - the first of the usual suspects for Unix daemons with Python.

pyquery: a jquery-like library for python - definitely check it out, because this is something that has been bothering me for a long time, the libraries for accessing XML data in Python are somewhat primitive. And I really like jQuery, I find its access patterns simply extremely practical.

python-daemon 1.5.5 - and the second of the usual suspects (this one is almost official, at least it is oriented towards a PEP) for writing Unix daemons with Python.

Spring Python - no idea what it's worth, I haven't used Spring under Java so far (well, I hardly ever use Java anyway, at most the JVM occasionally), but you read a lot of positive comments about Spring. Here someone has transferred the ideas to Python - there's even a book about it. I don't know, however, whether a framework for a bondage-and-discipline language translates so well to a highly dynamic language like Python. But you could take a look at it in a quiet hour.

Turkmenbashi 1.0.0 - a library to write Unix daemons. Brings a few more features than the other usual suspects (daemon and python-daemon).

parsedatetime - a very practical library that converts "normal" date specifications (unfortunately only in English as far as I can see) into Python datetime objects.

PyPy Status Blog: Running wxPython on top of pypy - PyPy is really making huge strides towards being usable. It's already faster than CPython in some cases and now even larger C extensions like wxPython are running. Cool.

Zoolander - a small Python library that allows you to use Python as a DSL for generating CSS. Sounds silly at first, but if you want or need to produce CSS dynamically and then embed it in a web framework, it can be quite practical.

django-pagination - I need to take a closer look at this, it looks interesting. Pagination is not really difficult, but it's annoying to build it yourself every time - and Django's built-in tools are not always optimal for this (especially with large amounts of data).

Markdoc - interesting project, a simple wiki with a special feature: it is not edited via the web, but via a DVCS like Mercurial or Git. So simply normal text editors, Markdown as the format and a DVCS for versioning, rsync for distributing the generated - static! - content to the server and done. And it is written in Python.

Writing a non-relational Django backend - Django nonrel / NoSQL blog - All buttons pressed - I'm not a big fan of NoSQL (in my opinion, many NoSQL approaches reflect a lack of understanding of relational databases rather than actual shortcomings or weaknesses of relational databases), but if you're going to use NoSQL, I'd prefer to do it through the Django ORM, which I quite like. And here's how you can build a Django ORM wrapper for NoSQL databases with relatively little effort.

NLTK Home (Natural Language Toolkit) - and if you want something more powerful and flexible, this is so to speak the grab bag for parsers. Focus is on the analysis of natural languages, hence also things like stemmers (stem finding for word forms) are included. Could be overkill for simple embedded languages, though.

Python Package Index : Esrapy 0.5 - a parser and lexer toolkit completely in Python. Might become interesting in some projects later, at least for smaller configuration languages.

Building Skills in Python - Online book about Python for programmers who simply don't know the language yet. Looks very well made at first glance.

Bottle: Python Web Framework - super-simple Python web framework that comes as a single Python file. No dependencies other than the standard library. No built-in ORM, but very lean and perhaps interesting for projects where you don't need or want a database (or use the file system as a database).

clojure-python - an interesting project that aims to simplify interoperability between Jython and Clojure and raise it to a similar level as it already is between Clojure and Java. Particularly interesting for me, as it would allow me to rely more on Clojure as an alternative - Jython is already a planned component of the toolkit, but has some performance issues that Clojure does not have through more direct Java integration. Moreover, I prefer to write compact Lisp code rather than verbose Java ...

digg's lazyboy at master - GitHub - because key-value datastores are currently all the hype (and because they are really more practical for some things than classic databases), I will probably take a look at Cassandra. Simply because reports on the web suggest it offers the best scaling possibilities. And because it is used in some large websites - specifically, for example, at Digg (which I find as a site to be stupid, but hey, they have a lot of traffic and run relatively stably) with lazyboy as the Python binding.

17.6. multiprocessing - much better than external modules for process communication are the tools included with Python since version 2.6 in multiprocessing.

rfc1437 / lazypy / source — bitbucket.org - and another project of mine (again) online. Lazypy is a small library that makes lazy evaluation and futures (thread and process based) available for Python. Very practical for simple concurrent programming. Ok, you can do everything by hand, but I prefer the more functional approach. It's actually from 2004, but I modernized it (the process-based futures to bypass the GIL) and uploaded it again.