Robert's blog

django-sorting a generic way of queryset sorting

2009-07-05T14:39:00.000-07:00

Just found a great project django-sorting. It's a generic way of queryset sorting.
It's based on middleware, and templatetag.

Please read the README.txt of the project.

In couple easy steps you get sorting:

1. Download & install django-sorting
2.In your settings.py
- add 'django-sorting' to INSTALLED_APPS
- add 'django_sorting.middleware.SortingMiddleware' to MIDDLEWARE_CLASSES
(make sure 'django.core.context_processors.request' is in your TEMPLATE_CONTEXT_PROCESSORS
3. In your template code: (the one below goes directly from README.txt

...


{% anchor first_name "First Name" %}

{% anchor last_name "Last Name" %}

{% anchor creation_date Creation flojax my_container %}

...

The first argument is a field of the objects list, and the second

one(optional) is a title that would be displayed. The previous

snippet will be rendered like this:

...
First Name
Last Name
Creation
...

It's BRILLIANT!

You should also use django-pagination for pagination support written by Eric as well.

Thank you ERIC!

Ps. Big thanks go to Karim (first author of django-sorting code) and other contributtors of these 2 great projects.

[PL] Authinfo i transfer domeny

2009-01-26T05:30:00.000-08:00

Postanowiłem przenieść swoje domeny *.pl do innego registrara.

Jak wszyscy wiemy, niedawno NASK obniżył opłaty za przedłużenie domen,
która w przypadku domen *.pl wynosi 40 PLN netto. Obniżka cen miała miejsce niedawno.
Mowa o obniżce cen dla partnerów. Zwykły zjadacz domen dalej płaci 200 PLN netto, a raczej 244 pln brutto.

Jak można się domyśleć, nie przełożyło się to na obniżki cen domen u popularnych u nas firm rejestrujących domeny, jak home.pl itd - cena 99 pln netto (stan na 26.01.2009).

Wiadomo, każdy chce zarabiać.

Wcześniej transferowałem domenę *.com z firmy godaddy. Tam w 10 sekund, po wybraniu opcji "wyślij kod authinfo" otrzymałem emailem kod. Proste i przyjemne.

Niestety nie w Polsce.
Pierw wypełnienie formularza, wpisanie telefonu i powodu, dla którego chcemy authinfo. Można się domyśleć - bo chcę dokonać transferu (nie kłamałem, wpisałem).

Otrzymałem po 2 dniach emaila, z propozycją obniżenia opłaty za przedłużenie ze 100 do 80 pln netto. W emailu załączony był również wniosek. Wypełniłem, podpieczętowałem, przefaxowałem.

Następnie dostałem emailem info, że wniosek przyjęty i że mam zalogować się znowu do innej strony (podano mi login/hasło). Tam się zalogowałem i znowu kolejne 2 wnioski do wypełniania, podpisania, podpieczętowania i przefaxowania wraz dokumentami: NIP, regon, wpis do ewidencji.

Uwaga: wniosek dotyczy tylko jednej z dwóch domen *.pl
Do jednej dostałem już kod authinfo! Widocznie chcą mocnych dowodów, że ja to ja.

Szkoda tylko papieru, drzew. Zarabia na tym chociaż operator telekomunikacyjny,
bo faxy wysyłać trzeba.

Ćwicz po pracy!

2009-01-13T07:02:00.000-08:00

Uważam, że człowiek może dostać kręćka od monotonnego trybu życia, w skład którego wchodziłyby tylko praca i sen.

Zachęcam każdego gorąco do aktywności ruchowej minimum 2 razy w tygodniu.
Gorąco polecam basen, piłkę nożną oraz sztuki walki :)

Dla mieszkających w okolicy Gdyni polecić mogę gdyńską szkołę TaiChi, oraz KungFu (a także Qigong) - YMAA GDYNIA.

Treningi odbywają się w poniedziałki oraz środy.
W pozostałe dni polecam basen :)

SAY NO TO FLASH POPUPS!

2008-10-16T11:17:00.000-07:00

I've been a Firefox user for a long time.

After Google Chrome has been published I decided to check it out.
After 1 day I had to switch back to Firefox.

The reason?
https://addons.mozilla.org/firefox/addon/10 (Firefox AdBlock plugin)

It's IMPOSSIBLE to watch the web without this plugin.
Flash plugins everywhere ... This is horrible.

People! Use this plugin, do not let manipulate and waste your time on
pages using this harmful type of advertising.

Boycote it! Let others know to not use it!
Admins, block ad hosts too!

I do not mean to fight with ads. I can watch ads, as long as it does not eat 100% of my CPU and some fuckin* flash poup appears! AARGH!!

THIS IS CRAZY!

django-tables generic way for displaying tables (pagination included)

2008-10-09T05:21:00.001-07:00

In thnis short post I would like to let you know about the great project

django-tables.

You can read more about it at:
http://blog.elsdoerfer.name/2008/07/09/django-tables-a-queryset-renderer/

In a couple of words it lets you:
- display the table using one template which lets you sort & paginate easily (filtering in plans!)

By reading the text below you will find out how to create table with sort & pagination quickly.

In usage it's very similar do django newforms (forms as of 1.0)
Example: (views.py)

class MyTable(tables.ModelTable):

  class Meta:
      model = SomeModel

def view_something(request):
  table = MyTable(queryset, order_by=request.GET.get('sort','some_field))

  return render_to_response('templates/table.html', {'table': table, 'rows' : table.rows})
# we need to return table, and  rows separately to use django-pagination (though django-tables provides its own pagination mechanism)

Now let's get to template:

{% load pagination_tags %}
{% autopaginate rows 10 %}



  {% for column in table.columns %}

  {% endfor %}


{% for row in rows %}

  {% for value in row %}

{% endfor %}




  

{% if column.sortable %}


        {{ column }}
      

{% if column.is_ordered_reverse %}



{% else %}



{% endif %}

{% else %}

{{ column }}

{% endif %}
    {{ value }} 

{% endfor %}

{% paginate %}

{% if column.sortable %} {{ column }} {% if column.is_ordered_reverse %} {% else %} {% endif %} {% else %} {{ column }} {% endif %}
{{ value }}	{% endfor %}

That's it!

This way you get generic way of displaying tables + sorting ability.
By default, django-tables takes field names for table headers when using ModelTable (verbose_name is in plans as well).
You can exclude displaying fields too!

As for now, you can specify your own names in MyTable class.

Let's get back to our class:

class MyTable(tables.ModelTable):
  class Meta:
      model = SomeModel

  field1 = tables.Column(name="Name")
  field_we_want_to_exclude = tables.Column(visiable=Fale, sortable=False)

NOTE:
Django tables is also aware of ForeignKey relations.

Check it out!

Django ModelForm - replacement for form_for_model & form_for_instance

2008-03-03T11:09:00.001-08:00

Each commit, Django gets more amazing.

I wrote about newforms library before. The library was a big step in Django form displaying and validating.

The first approach was to use forms.form_for_model() and forms.form_for_instance() respectively.

As Django programmer I found this a little confusing. Both were similar. The only difference was that form_for_instance() took an object instance for saving instead
of creating a new one. Recently django developers came up with a great idea - forms.ModelForm which combines both into one. It's great!

Just take a look at the example below.
Assume you want to create a new view function for creating & editing an object.
You only want to edit 3 fields (name, last_name, status). Also, you've created a
customized field type for "status", and want to use that.

Scenario #1: (forms.form_for_model && forms.form_for_instance)


def f_callback(field, **kwargs):
    if field.name == "status":
        return MyStatusField(**kwargs)
    else:
        return field.formfield(**kwargs)

def create_edit_customer(request, customer_id=None):

    # check if object_id is None and if object exists
    if object_id is None:
        CustomerForm = forms.form_for_model(Customer,
        formfield_callback=f_callback,
        fields=('name','last_name','status')
    else:
        customer = get_object_or_404(Customer, id=customer_id)
        CustomerForm = forms.form_for_instance(customer,
        formfield_callback=f_callback,
        fields=('name','last_name','status')

    if request.method == "POST":
        form = CustomerForm(request.POST)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect('customer/added/')
    else:
        form = CustomerForm()

    return render_to_response("customers/customer_form.html", {'form' : form })

You could create your own form_for_model & form_for_instance subclass (using forms.BaseForm for example), but it would be too complicated. Hope you don't use this form often :-)

Scenario #2 (ModelForm)

1. Longer version.


class CustomerModelForm(forms.ModelForm):

    class Meta:
        model = Customer
        fields = ('name','last_name','status')

        status = MyCustomerField()

def create_edit_customer(request, customer_id=None):

    if customer_id is not None:
        customer = get_object_or_404(Customer, id=customer_id)
    else:
        customer = None


    if request.method == "POST":
        form = CustomerModelForm(data=request.POST, instance=customer)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect("/customer/added/")
        else:
            form = CustomerModelForm(instance=customer)

    return render_to_response("customers/customer_form.html", {'form' : form })

2. Shorter version.


class CustomerModelForm(forms.ModelForm):

    class Meta:
        model = Customer
        fields = ('name','last_name','status')

    status = MyCustomerField()

def create_edit_customer(request, customer_id=None):

    if customer_id is not None:
        customer = get_object_or_404(Customer, id=customer_id)
    else:
        customer = None

    form = CustomerModelForm(data=request.POST or None, instance=customer)

    if form.is_valid():
        form.save()
        return HttpResponseRedirect("/customer/added/")

    return render_to_response("customers/customer_form.html", {'form' : form }

We are using one form class for editing & creating objects.
We can also subclass CustomerModelForm and edit/change the way the form looks
and behave (by adding field clean() method.

Django forms library looks better each day :-)

Vote for Gdynia in Monopoly Game

2008-03-02T07:27:00.001-08:00

I was born in Gdynia, I grew up in Gdynia.. and I am happy to live in Gdynia.

Now it's chance for anybody to vote for Gdynia in the Worldwide Monopoly
city competition.

Log in at:
http://www.monopolyworldvote.com/pl_PL/world and vote.
You can give your vote once a day.

Thanks!

---
Urodziłem się w Gdyni, dorastałem w Gdyni i nadal mieszkam w Gdyni.
To cudowne miasto ma teraz niepowtarzalną okazję zaistnieć w
ogólnoświatowej wersji gry Monopol, w którą grają miliony
ludzi na świecie.
To niepowtarzalna szansa dla promocji naszego miasta, ale też i kraju,
czy też rejonu.

Oddaj swój głos na stronie:
http://www.monopolyworldvote.com/pl_PL/world

Możesz głosować codziennie 1 raz!

Dzięki !

FreeBSD 7.0 arrived

2008-02-29T10:32:00.000-08:00

FreeBSD 7.0 offers new great features. You can read about them all here

With this release we can see a huge performance
improvements. Just take a look at these MySQL tests! It looks very promising.

It would be great if ULE scheduler was stable enough to be included in 7.1 release.

During my work at the company where MySQL was widely used, I had to use linuxthreads
package to get similar to linux performance (well, that's because we used FreeBSD 4.X then). Linux (mostly 2.6) is treated as a better
Operating system for MySQL. Is it high time to change it? :-). Go FreeBSD!

Take a look at graphs at:

http://people.freebsd.org/~kris/scaling/mysql.html

Some very usable django apps

2008-02-25T06:30:00.000-08:00

I was looking for some easy to plug-in django apps
for my new service.

Here are some I decided to use:

django-tagging
django-registration
django-threadedcomments
django-voting

They seem to be rock stable, and easy to use.

Check back soon for more info about the new website.

[EN] FreeBSD QOS with FreeBSD DUMMYNET

2007-06-15T03:10:00.000-07:00

The latest released FreeBSD version 6.2 comes with 3 firewall systems:

- pf (ported from OpenBSD)
- ipfw
- ipfilter

All these three are stable as of this release. I've recently needed to run a QOS system, and chosen
ipfw "DUMMYNET" for this purpose.

My network is about couple hundreds computers and I needed limit bandwidth for each user.

I chose DUMMYNET because of it's simplicity, and "dynamic pipe" creation. I know "pf" (especially HFSC alghoritm) is a good solution too, but natively it supports up to 64 queues
per interface, and you need to patch the source in order to enable more. It's safe to use hundreds of queues, but I simply don't like patching.. (at least by now).

DUMMYNET provides FreeBSD users with dynamic pipe creation.

Suppose you want to create a new 256Kbit pipe for incoming, and 128Kbit pipe for outgoing traffic.

# ipfw pipe 1 config bw 256Kbit/s mask dst-addr 0xffffffff
# ipfw pipe 1 config bw 128Kbit/s mask src-addr 0xffffffff

Now, you need to put the traffic into these pipes.

# ipfw add pipe 1 ip from any to 192.168.0.0/24, 192.168.1.0/24
# ipfw add pipe 2 ip from 192.168.0.0/24, 192.168.1.0/24 to any

By these 4 lines of code you will get hunderds of pipes for each ip in the network for
both incoming and outgoing traffic.

You could write it this way as well:

# ipfw pipe 1 config bw 256Kbit/s
# ipfw pipe 2 config bw 256Kbit/s
...
# ipfw pipe 345 config bw 256Kbit/s

and appropriate rules:
# ipfw add pipe 1 ip from any to 192.168.0.2
# ipfw add pipe 2 ip from any to 192.168.0.3
....
# ipfw add pipe 345 ip from any t0 192.168.1.23

I think the first solution is better!

Now that we stand with another problem - some users have more bandwidth enabled, some less.

You could write pipes with mask-src (dynamic), and put hosts into these.. which would cause lots of rules written.

ipfw (ipfw2 for FreeBSD 4.X) comes with lookup tables, which are extremely fast!

There are 2 values stored in each record of the table:
ip address or network, integer

To create a new table and put the record you would:

# ipfw table 1 add 192.168.0.2 23
# ipfw table 1 add 192.168.0.3,345

These 2nd values lets filter by these in the rules.

# ipfw add allow ip from table\(1\,23) to any # ( = ipfw add allow ip from 192.168.0.2 to any)

Now, in order to create more complex ruleset for pipe assigning look at the example below:

# incoming traffic
# ipfw pipe 1 config bw 1024Kbit/s mask dst-addr 0xffffffff
# ipfw pipe 2 config bw 512Kbit/s mask dst-addr 0xffffffff
# ipfw pipe 3 config bw 256Kbit/s mask dst-addr 0xffffffff

# outgoing traffic
# ipfw pipe 11 config bw 1024Kbit/s mask src-addr 0xffffffff
# ipfw pipe 12 config bw 512Kbit/s mask src-addr 0xffffffff
# ipfw pipe 13 config bw 256Kbit/s mask src-addr 0xffffffff

# Create 2 lookup tables, one with values (IP,INCOMING_BANDWIDTH), second with (IP, OUTGOING_BANDWIDTH)
# TABLE 1 (incoming)
# ipfw table 1 add 192.168.0.2 1024
# ipfw table 1 add 192.168.0.3 1024
# ipfw table 1 add 192.168.1.0/24 512 # each host in network 192.168.1.0/24 gets 512 Kbit/s)
....
# ipfw table 1 add 192.168.2.23 256

# TABLE 2 (outgoing)
# ipfw table 2 add 192.168.0.2 512
# ipfw table 2 add 192.168.0.3 512
# ipfw table 2 add 192.168.1.0/24 256 # yeah, network 192.168.1.0 got too much traffic last month, now they will get less

# RULES
# rule for incoming pipe 1024kbit (pipe #1)
# ipfw add pipe 1 ip from any to table$1,1024$
# rule for incoming pipe 512 (pipe #2)
# ipfw add pipe 2 ip from any to table$1,512$
# rule for incoming pipe 256 (pipe #3)
# ipfw add pipe 3 ip from any to table$1,256$

# outgoing traffic
# fule for outgoing pipe 1024Kbit (pipe #11)
# ipw add pipe 11 ip from table$2,1024$ to any
# rule for outgoing pipe 512Kbit (pipe #12)
# ipfw add pipe 12 ip from table$2,512$ to any
# rule for outgoing pipe 256Kbit (pipe #13)
# ipfw add pipe 13 ip from table$2,256$ to any

That's all! No more hundreds of static pipes, hundreds of rules.

Keep in mind, that this example is a strcitly pipe related.
Depending on the NAT you are using, make sure these rules are evaluated
before being nated (if using "natd") for outgoing traffic, and after being nated (if using "natd")
for incoming traffic.

You can get this by using rules like:

# ipfw add 100 divert natd ip from any to any in recv $OUTGOING_INTERFACE

Put all the pipe rules here

# ipfw add 4000 divert natd ip from any to any out xmit $OUTGOING_INTERFACE

NOTE:
1. Remember to set sysctl variable "net.inet.ip.fw.one_pass" to 0, which prevents packets from
not being reinjected into the firewall.

2. You may also want to put a "skipto" rule after ip to pipe assigning (if you are using lots of such rules).

3. Personally I'm using ipnat+dummynet, which works fine for bigger networks. natd is not
fast, as it works in userland. ipnat is entirely kernel attached, so it's faster.

4. If using FreeBSD 4.x make sure you apply the ipfw/ipfilter order patch (lookup for "ipfw ipnat order patch" in google)

5. Assign appropriate "queue" values for each pipe depending on the pipe bw parameter.

6. In FreeBSD 5.5? 6.X you can even simplify the ruleset, read about "tablearg" parameter for ipfw!

7. Tune all "net.inet.ip.dummynet.*" sysctls if there are lots of hosts in your network, and there's a danger of creating lots of dynamic pipes.

8. Some guys use pf+dummynet for FreeBSD 6.X nat. I think it's tricky too, as pf is a great firewall too!

Some useful links:
http://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/firewalls-ipfw.html
http://info.iet.unipi.it/~luigi/ip_dummynet/

[EN] FreeBSD multiple Jails with "ezjail"

2007-05-20T01:43:00.000-07:00

Linux has a great support for VPS systems, so that you can easily create
multiple virtual environments using xen f.e.

As my favourite OS is FreeBSD I've decided to look for a similar solution.
I've been aware of great "jail" feature, but managing multiple jails
is not that handy as it is in linux.

Recently, I found a great solution , "ezjail". ( /usr/ports/sysutils/ezjail )

"ezjail" is a shell script which lets you easily:

- create new jails
- running/shutting down jails
- update existing jails

You can create jail environment as:
- file system in your existing os
- file system in either plain, gdbe or geli encrypted image

Before you begin, make sure you are familiar with jails by reading:

http://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/jails.html

A very interesting note is that "ezjail" doesn't create a completely new base system for new jails.
Instead it makes use of mount_nullfs and create "ro" mounts of the main base system
dirs like "/bin", "/sbin" etc.

When you create a new jail, it creates the "basejail" which in my case was 114MB size.
Any other jails (in case you don't do any other customizations) is 2MB large!.

Let's get started with "ezjail" !

First, create the base jail system.

# ezjail-admin install

This will fetch files needed for base system according to your current os version (`uname -r`)

# ezjail-admin create testjail 192.168.3.1
where IP is the IP you assing to your jail. Make sure it's already existing and set up.

Let's list existing jails now.

# ezjail-admin list
STA JID IP Hostname Root Directory
--- ----- --------------- ---------------------------- -------------------------
DS N/A 192.168.3.21 testjail /usr/jails/testjail
#

"DS" flags mean that it's a Directory Based jail and it's Stopped.

To create a geli encrypted image you would:

# ezjail-admin create -s 200M -c eli gelibasedjail 192.168.3.22
200+0 records in
200+0 records out
209715200 bytes transferred in 12.010512 secs (17460971 bytes/sec)
Initialising crypto device. Enter a new passphrase twice...
Enter new passphrase:
Reenter new passphrase:

Your jails is ready!
You can easily attach your jail filesystem:

# ezjail-admin config -i attach gelibasedjail
Attaching eli device for image jail ...
Enter passphrase:

Let's check the system mounts
# mount
...
/dev/md0.eli on /usr/jails/gelibasedjail (ufs, local)
...

and go into your jail file system:

# cd /usr/jails/gelibasedjail

# ls
.snap bin etc media rescue sys var
COPYRIGHT boot lib mnt root tmp
basejail dev libexec proc sbin usr

To start your jails on reboot, add ezjail_enable="YES" entry into your /etc/rc.conf file.

After reboot all your jails (which do not require password) will start.

You can also start/shutdown particular jails with:

# /usr/local/etc/rc.d/ezjail.sh start|stop gelibasedjail

You would ask "What if I want some customizations when creating new jails?".

"ezjail" comes with "flavours" functionality.

Let's say you want to create a new bunch of jails for HTTP web serving.
Your customers will put the Web data in /web/sites, and you want to avoid creating
this directories anytime you create a new jail.

With ezjail it's simple!

# cd /usr/jails/flavours/
# mkdir httpd
# cd httpd
# mkdir -p /web/sites

Now when creating new jail let "ezjail" know about the flavour:
# ezjail-admin create -f httpd newjail JAILIP

This will create a new jail with /web/sites directory created within your new jail!
The directory tree will recursively be copied to your new jail.

You can also perform other desired actions like running script when initiating a new jail install.
Create users, fetch packages.. do whatever you want.

Put the "ezjail-flavour" script in your new flavour jail definition (/usr/jails/httpd/ezjail-flavour) in my example.

Hope I convinced you to try "ezjail".

Some notes:
- it does create/delete /etc/fstab.jailname entries, so you don't have to worry about filesystem mountpoints after reboot. (you can avoid running specified jail at startup by `ezjail-admin config -r run|norun jailname` command)
- it's about creating/deleting/running/shutting down jails at the moment. It does not allow you
to manage jail f.e. resource usage. Look at: http://wiki.freebsd.org/JailResourceLimits for more information.

Look at the URL below, to find out more about the functionality of "ezjail".
Also, consider donation :)

http://erdgeist.org/arts/software/ezjail

[EN] Django extending User, custom User methods

2007-04-26T01:30:00.003-07:00

Django doesn't allow to subclass the User model yet.

Each Django model lets you easily create model methods.
Behind the scene, each django model has its own methods, f.e. save()
which saves the model data into the database.

Django provides the lightweight User framework in "django/contrib/auth/",
where "User" model is defined with fields:

username, password, is_staff, first_name, last_name, email, date_joined, last_login,
is_superuser, is_active

What if we need the user model with additional data like: age, location ?

The answer is: "extending the User model" by creating a new model
and linking it with "User" model via ForeignKey.

Example:

from django.contrib.auth.models import User

class Userprofile(models.Model):
        user = models.ForeignKey(User, unique=True)
        age = models.IntegerField()
        location = models.CharField(maxlength="100", verbose_name"Country")

To create a new user, django comes with a special "create_user" method.

user = User.objects.create_user('robert', 'rsome@email', 'somepassword')
user.save()

You could do this also using the standard model create like:

user = User(username='someusername', is_active=True, email='some@email', first_name='john', last_name='doe')
user.save()
user.set_password('somepassword')
user.save()

As we have a new User record, to create a new "linked" UserProfile you would:

user = User.objects.get(name='someusername')
user.userprofile_set.create(age=22, location='Poland')

Django will automagically create the new UserProfile with "user" ForeignKey pointing
to the right User instance. Cool !

Question! How do I work on two separated models? Do I need to grab the UserProfile
instance for each request.user I operate in my views ?

Answer: Normally, you woule have to use the code below:

userprofile = Userprofile.objects.get(user=request.user)

Django comes with a special settings.py variable "AUTH_PROFILE_MODULE' which should point to your Userprofile model.

Example:
AUTH_PROFILE_MODULE = 'yourapp.Userprofile'

which lets you easily get into the "UserProfile" by using the "get_profile()" method.

Example: (in your either views.py or template):

location = request.user.get_profile().location
{{ user.get_profile.location }}

Note:
user_profile() does not only allows you to get the model data.
It allows you to get the model methods as well.

Example:

class Userprofile(models.Model):
        user = models.ForeignKey(User, unique=True)
        age = models.IntegerField()
        location = models.CharField(maxlength="100")

        def __str__(self):
                return self.location

        def is_of_age(self):
                if self.age < 18:
                        return False
                else:
                        return True

This lets you do some conditioning in your views:

if request.user.get_profile().is_of_age():
        print "Yes, I will sell you this beer"

Delicious!

Another +1 for Django !

Links for reading:
http://www.djangoproject.com/documentation/authentication/

[EN] Django model managers, Do Not Repeat Yourself !

2007-04-25T04:55:00.000-07:00

I've recently come up with a great django feature "model Managers".

Each django model has it's own manager class, which can be overriden by your custom class.

Let's say there's a model containing fields:

class Person(models.Model):
        name = models.CharField(maxlength="100", blank=False, verbose_name="Your name")
        age = models.IntegerField(verbose_name="Your age")

        def __str__(self):
                return self.name

You need to use this model in many places, and you need to select people by age and mark
them as child, teen, older.

Each time you select them you would need to crate a queryset like:

children = Person.objects.filter(age__lt=13)
teen = Person.objects.filter(age__gte=13).filter(age__lt=18)
older = Person.objects.filter(age__gte=18)

Anytime you use this function, you would need to write the filter statements.

Thanks to model managers, you can do it once, and use it in your code anywhere.

class PersonManager(models.Manager):
        def get_children(self):
                return self.filter(age__lt=13)
        def get_teens(self):
                return self.filter(age__ge=13).filter(age_lt=18)
        def get_olders(self):
                return self.filter(age__gte=18)

and put:
objects = PersonManger() in your model class so the class looks like:

from django.db import models

class Person(models.Model):
        name = models.CharField(maxlength="100", blank=False, verbose_name="Your name")
        age = models.IntegerField(verbose_name="Your age")

        objects = PersonManger()

                def __str__(self):
                        return self.name

To select teens, you can use: Person.objects.get_teens().
You can use any standard queryset options like .filter, .exclude etc, for example:

To get teens, with name not starting with "s".
Person.objects.get_teens.exclude(name__startswith: "s")

Also, you can change parameters for model managers functions.

Let's say you want to select teens, olders, children with name starting with some letter.

Modify your model manager functions, so they look like (I will modify just the one here).

def get_teens(self, name_filter_letter=None):
        if name_filter_letter is None:
                return self.filter(age__ge=13, age_lt=18)
        else:
                return self.filter(age__ge=13).filter(age__lt=18).filter(name__startswith=name_filter_letter)

And use it like:
Person.objects.get_teens("s")

Custom managers can do many other things, they are a standard python methods.

Note that you don't need to use the name:
objects = PersonManager()

You can use your own name as well:
persons = PersonManager()

which results in:
Person.persons.get_teens()

One more thing:
You can go deeply and override the models.Manager get_query_set() method, for example:

You want to grab teens from the model:

Create model subclass like:

class PersonTeensManager(models.Manager):
        def get_query_set(self):
                return super(PersonTeensManager, self).get_query_set().filter(age__lt=18).filter(age__gte=3)

and put:

teens = PersonTeensManager() in your model class.

In your views, use the queryset:

teens = Person.teens.all()

Isn't that simple?!

For more documentation take a look here:
http://www.djangoproject.com/documentation/models/custom_managers/
http://www.djangoproject.com/documentation/models/get_object_or_404/