What's Cooking!? (without imported items)

[dokterbob] Finally: human friendly testing :)

Mon, 25 Oct 2010 22:39:42 GMT

http://fakeapp.com/

[dokterbob] Ordering related objects in Django

Fri, 22 Oct 2010 11:21:50 GMT

http://james.wheare.org/notes/2007/11/ordering-related-objects-in-django.php

[dokterbob] django-multilingual-model

Fri, 22 Oct 2010 11:06:11 GMT

A very simple abstract base class, enabling translation of (specific) model fields with only about 33 lines of code.

Example:

models.py

    from django.db import models
    from multiling import MultilingualModel
    
    class Language(models.Model):
        code = models.CharField(max_length=5)
        name = models.CharField(max_length=16)
        
    class BookTranslation(models.Model):
        language = models.ForeignKey("Language")
        title = models.CharField(max_length=32)
        description = models.TextField()
        model = models.ForeignKey("Book")
        
    class Book(MultilingualModel):
        ISBN = models.IntegerField()
        
        class Meta:
            translation = BookTranslation
            multilingual = ['title', 'description']

>>> lang_en = Language(code="en", name="English")
>>> lang_en.save()
>>> lang_pl = Language(code="pl", name="Polish")
>>> book = Book(ISBN="1234567890")
>>> book.save()
>>> book_en = BookTranslation()
>>> book_en.title = "Django for Dummies"
>>> book_en.description = "Django described in simple words."
>>> book_en.model = book
>>> book_en.save()
>>> book_pl = BookTranslation()
>>> book_pl.title = "Django dla Idiotow"
>>> book_pl.description = "Django opisane w prostych slowach"
>>> book_pl.model = book
>>> book_pl.save()
>>> 
>>> # now here comes the magic
>>> book.title_en
u'Django for Dummies'
>>> book.description_pl
u'Django opisane w prostych slowach'

To have it interated with Django Admin nicely, try this:

admin.py

from django.contrib import admin
import models

class BookTranslationInline(admin.StackedInline):
   model = models.BookTranslation
   extra = 1
   min_num = 1


class BookAdmin(admin.ModelAdmin):
   list_display = ["ISBN"]
   inlines = [BookTranslationInline]

admin.site.register(models.Book, BookAdmin)

http://code.google.com/p/django-multilingual-model/

[dokterbob] django-mobile

Mon, 18 Oct 2010 23:51:32 GMT

django-mobile provides a simple way to detect mobile browsers and gives you tools at your hand to render some different templates to deliver a mobile version of your site to the user.

http://pypi.python.org/pypi/django-mobile/0.1.1

[dokterbob] Hg-Git Mercurial Plugin

Mon, 18 Oct 2010 09:54:26 GMT

This is the Hg-Git plugin for Mercurial, adding the ability to push to and pull from a Git server repository from Mercurial. This means you can collaborate on Git based projects from Mercurial, or use a Git server as a collaboration point for a team with developers using both Git and Mercurial.

http://hg-git.github.com/

[dokterbob] django-fileprocessor: efficient, scalable processing of files (ie. scaling images)

Thu, 30 Sep 2010 14:02:20 GMT

This is a prototype project for something we have been wanting to make: efficient file processing - from within templates!

Right now, if you are like me, you probably use something like easy_thumbnail for scaling of images for your website. You might even have written some code to extract thumbnails from PDF files or from video files. All really great work!

BUT. As our applications relying on this stuff might actually scale up a bit, the amount of work our application servers are doing WHILE RENDERING THE TEMPLATE can quickly become excessive. At the same time, if these servers were just doing what they should be, namely data <-> view interactions, this would not be happening.

Moreover: if your server is, in principle, able to handle a mentioning on some lame but immensely popular blog - why should it not be in practice? Because, right now - if you use easy_thumbnails - your server will block while rendering templates until your thumbnails are gone.

So here is my concept solution: When we need to do something with a file, while rendering a template, we first put out a request. This request can be put out to some other server, but for small instances it can easily be the same server - just some other CPU doing the work. This 'remote tag' basically passes any contents between the {% fileprocessor %} and {% endfileprocessor %} along to this other server as a parameter (so far called instructions), telling it what to do and where to get stuff from.

The remote server writes this to the database, generates a checksum thereof and parses the instructions just well enough to generate some kind of representation (ie. and image tag) of the stuff that will be rendered later.

After the HTML has been sent out to the client, the client will start making individual requests for the URL's referred to in the representation code generate while rendering the template. Calling these URL's directly triggers processing the file in any possible way, according to the instructions in the database. When this is done, the file is written to some kind of storage, somewhere and a redirect to this file is generated.

On subsequent requests, all the 'file processing server' does is blurt out redirects to that some old file. But as these are permanent redirects, they should also be cached by the client which ought to be quite efficient. Furthermore, the template rendering results can and should also be cached: we do not have to reach out to the server all of the time to retreive the same kind of data.

So that's it. A work in progress. Feel free to join in. :)

http://github.com/dokterbob/django-fileprocessor

[dokterbob] django-newsletter released in the Cheese Shop

Sun, 26 Sep 2010 15:11:10 GMT

After a long time of though work we have finally released this app for managing multiple mass-mailing lists with both plaintext as well as HTML templates (and TinyMCE editor for HTML messages), images and a smart queueing system all right from the admin interface. And what's more: it's all fully integrated into the Django admin.

Stay tuned for some screenshots - or perhaps even a screencast of our (Dutch) presentation of the project this wednesday at the Django Meeting in Amsterdam.

http://pypi.python.org/pypi/django-newsletter

[dokterbob] (Image)

Sun, 11 Jul 2010 18:39:30 GMT

[dokterbob] LESS

Tue, 06 Jul 2010 19:30:02 GMT

Less extends CSS with: variables, mixins, operations and nested rules.

http://lesscss.org/

[dokterbob] (Video)

Sat, 29 May 2010 13:17:33 GMT

[dokterbob] Introduction to Surlex

Tue, 13 Apr 2010 09:52:43 GMT

Surlex (Simple URL Expression) is a language for matching and extracting text, similar to regex (regular expression). It works by generating a regular expression from a more concise syntax that is designed to produce easy-to-read url patterns.

http://codysoyland.com/2009/sep/6/introduction-surlex/

[dokterbob] Git Repository Basics Guide

Fri, 24 Jul 2009 14:23:50 GMT

http://wiki.sourcemage.org/Git_Guide

[dokterbob] Setting up a new remote git repository

Fri, 24 Jul 2009 13:50:32 GMT

To collaborate in a distributed development process you’ll need to push code to remotely accessible repositories.

http://toolmantim.com/articles/setting_up_a_new_remote_git_repository

[dokterbob] Django Guestbook application

Tue, 23 Dec 2008 12:07:38 GMT

The other day I've written a pluggable guestbook application for Django. It is fully functioning and loosely based on the Django comments contrib. Currently, I am using it on a small website (hansenpaul120.nl, Dutch) but more websites are soon to follow.

Current features:

Fully translatable (currently, only English and Dutch are available)
Fully integrated with the admin
Some barebone templates are supplied

More features will be added as soon as I am going to use this in more sites, or when you do so. Some of these features may include:

(Better) documentation.
Integration with Django syndication
Integration with Django email confirmation
Integration with Django User authentication

Installation should be pretty straight-forward for anyone who's installed a Django app before:

Get the source from GitHub by either cloning or downloading the archive.
Link the guestbook app into your project's tree:
```
ln -s django-guestbook/guestbook guestbook
```

Add the app to your INSTALLED_APPS in settings.py:

INSTALLED_APPS = (
    ...
    'django.contrib.admin',
    'guestbook',
)

Add the guestbook app to your urls.py:

urlpatterns = patterns('',
    ...
    (r'^guestbook/', include('guestbook.urls')), 
)

Update the database structure:
```
./manage.py syncdb
```
You're done! Go and test your app by running:
```
./manage.py runserver
```

Feel free to provide feedback on the current state of the project, and perhaps on what features you might like. In any case, expect a more complete HOWTO here.

The app's source code can be found here on GitHub and the source for the hansenpaul120.nl website is here. The latter might be a good place to see how the guestbook application can be used.