Planet Django

ag clouds are the mullets of web 2.0 · (All times are UTC.)

def my_view(request):
    ....
    return render_to_response('myview.html')

from urlparse import urlparse
from django.http import HttpResponseRedirect

def refer_check(func):
    def decorate(request):
        referer = request.META.get('HTTP_REFERER', '')

        if referer == 'http://www.example.com':
            return func(request)
        else:
            return HttpResponseRedirect('/')
    return decorate

@refer_check
def my_view(request):
    ....
    return render_to_response('myview.html')

from datetime import datetime

def time_it(func):
    def decorator():
        a = datetime.now()
        func()
        b = datetime.now()
        print 'function: %s took %d seconds to run' % (func.__name__, (b-a).seconds)
    return decorator

@time_it
def myfunc():
    for i in range(1,100000):
        print i

{% load lib1 %}
{% tag1 %}
{% tag2 %}

{% load lib1 %}
{% lib1.tag1 %}
{% lib1.tag2 %}

{% load lib1 into lib1 %}
{% lib1.tag1 %}
{% lib1.tag2 %}

{% load lib1.tag1 as my_tag %}
{% my_tag %}

{% load lib1 from app1 into app1 %}
{% load lib1 from app2 into app2 %}
{% app1.tag1 %}
{% app2.tag1 %}

{% import lib1 %}
{% lib1.tag1 %}

{% import * from lib1 %}
{% tag1 %}

{% import lib1 as my_lib %}
{% my_lib.tag1 %}

{% import lib1 from app1 %}
{% lib1.tag1 %}

pip install django-template-repl

class MyView(object):
    thing = 0
    def __call__(self, request):
        self.thing += 1
        return HttpResponse('%s' % (self.thing,))

my_view = MyView()

urlpatterns = patterns('',
    url(r'^my_view/$', 'my_app.views.my_view', name='my_view'),
)

class MyView(object):
    def __call__(self, request):
        self.request = request
        return self.create_response()

    def create_response(self):
        return HttpResponse('Welcome, %s' % (self.request.user,))

my_view = MyView()

def __new__(cls, *args_static, **kwargs_static):
    def view_wrapper(request, *args, **kwargs):
        view = object.__new__(cls)
        view.__init__(*args_static, **kwargs_static)
        return view(request, *args, **kwargs)
    return view_wrapper

class BaseView(object):
    def __new__(cls, request, *args, **kwargs):
        view = cls.new(request, *args, **kwargs)
        return view.create_response()

    @classmethod
    def new(cls, *args, **kwargs):
        obj = object.__new__(cls)
        obj.__init__(*args, **kwargs)
        return obj

    def __init__(self, request, *args, **kwargs):
        raise NotImplementedError()

    def create_response(self):
        raise NotImplementedError()

class MyView(BaseView):
    template = 'path/to/template.html'

    def __init__(self, request):
        self.request = request

    def create_response(self):
        return render_response(self.request, self.template, {'title': 'Home'})

urlpatterns = patterns('',
    url(r'^my_view/$', 'my_app.views.MyView', name='my_view'),
)

ab -n 1000 -c 10 <server-name>

Concurrency Level:      10
Time taken for tests:   68.619 seconds
Sent requests:          1000
Completed requests:     1000
Failed requests:        0
Total transferred:      9660000 bytes
HTML transferred:       9387000 bytes
Requests per second:    14.5732231597662
Transfer rate:          141.610400362873 kb/s received

Connnection Times (ms)
              min     avg   max
Connect:        0    0.12    10
Response:     309  681.65  1330

{% load cache %}
{% cache 500 sidebar %}
    This goes into cache.
{% endcache %}

Concurrency Level:      10
Time taken for tests:   26.19 seconds
Sent requests:          1000
Completed requests:     1000
Failed requests:        0
Total transferred:      9479000 bytes
HTML transferred:       9387000 bytes
Requests per second:    38.1825124093165
Transfer rate:          353.449253054601 kb/s received

Connnection Times (ms)
              min     avg   max
Connect:        0    0.29    10
Response:      90  260.61   490

Concurrency Level:      10
Time taken for tests:   9.07 seconds
Sent requests:          10000
Completed requests:     10000
Failed requests:        0
Total transferred:      130040000 bytes
HTML transferred:       127560000 bytes
Requests per second:    1102.53583241455
Transfer rate:          14001.3437155458 kb/s received

Connnection Times (ms)
              min     avg   max
Connect:        0    0.15    10
Response:       0    9.02   470

location / {
    uwsgi_pass  unix:///tmp/mingus.sock;
    include     uwsgi_params;
}

location / {
    default_type  text/html;
    set $memcached_key nginx.$request_uri;
    memcached_pass 127.0.0.1:11211;
    error_page 404 = @cache_miss;
}
location @cache_miss {
    uwsgi_pass  unix:///tmp/mingus.sock;
    include     uwsgi_params;
}

Concurrency Level:      10
Time taken for tests:   3.699 seconds
Sent requests:          10000
Completed requests:     10000
Failed requests:        0
Total transferred:      130640000 bytes
HTML transferred:       129190000 bytes
Requests per second:    2703.43336036767
Transfer rate:          34489.8959178156 kb/s received

Connnection Times (ms)
              min     avg   max
Connect:        0    0.36    30
Response:       0    3.66   109

Concurrency Level:      10
Time taken for tests:   2.78 seconds
Sent requests:          10000
Completed requests:     10000
Failed requests:        0
Total transferred:      131320000 bytes
HTML transferred:       129190000 bytes
Requests per second:    3597.12230215827
Transfer rate:          46130.2832733813 kb/s received

Connnection Times (ms)
              min     avg   max
Connect:        0    0.67    90
Response:       0    2.66   190

Concurrency Level:      10
Time taken for tests:   2.76 seconds
Sent requests:          10000
Completed requests:     10000
Failed requests:        0
Total transferred:      131230000 bytes
HTML transferred:       129190000 bytes
Requests per second:    3623.1884057971
Transfer rate:          46432.716259058 kb/s received

Connnection Times (ms)
              min     avg   max
Connect:        0    0.60    20
Response:       0    2.74    90

$ python manage.py templateshell
>>> test
test
>>> {% if 1 %}
... It is true!
... {% else %}
... It is false!
... {% endif %}

It is true!

$ python manage.py templateshell --context "{'testvar': 'this is a string'}"
>>> {{ testvar }}
this is a string

$ python manage.py templateshell --url /admin/
>>> {{ title }}
Log in
>>> {{ user }}
AnonymousUser

$ python manage.py templateshell --url /admin/ --pdb
...
ipdb> vars
Out[0]: 
['app_path',
 'error_message',
 'root_path',
 'title',
 'MEDIA_URL',
 'LANGUAGES',
 'LANGUAGE_BIDI',
 'LANGUAGE_CODE',
 'perms',
 'messages',
 'user']
ipdb> title
Out[0]: u'Log in'
ipdb> user
Out[0]: <django.contrib.auth.models.AnonymousUser object at 0x1019d7490>

./manage.py dumpdata package > apps/packages/fixtures/initial_data.json
daemon.*        /var/log/daemon.log
kern.*          /var/log/kern.log
mail.*          /var/log/mail.log

mail.*        /var/log/mail.log
mail.err      /var/log/mail-errors.log

$ModLoad imudp
$UDPServerAddress x.x.x.x
$UDPServerRun 514

*.* @x.x.x.x:514

local0.* @x.x.x.x:514
local1.* @x.x.x.x:514

*.*;auth,authpriv,local0,local1.none        /var/log/syslog

virtualenv
activate
bin
mod_wsgi
manage.py
fcgi
wsgi
import os
import sys
import site

root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))

site.addsitedir(os.path.join(root_dir, 've/lib/python%i.%i/site-packages' % (sys.version_info[0], sys.version_info[1])))

manage.py
ve
from django import template
from coffin import shortcuts as jinja_shortcuts                                                                                                                                                      

register = template.Library()                                                                                                                                                                        

class JinjaInclude(template.Node):
    def __init__(self, filename):
        self.filename = filename                                                                                                                                                                     

    def render(self, context):
        return jinja_shortcuts.render_to_string(self.filename, context)                                                                                                                              

@register.tag
def jinja_include(parser, token):
    bits = token.contents.split()                                                                                                                                                                    

    '''Check if a filename was given'''
    if len(bits) != 2:
        raise template.TemplateSyntaxError('%r tag requires the name of the '
            'template to be included included ' % bits[0])
    filename = bits[1]                                                                                                                                                                               

    '''Remove quotes if used'''
    if filename[0] in ('"', "'") and filename[-1] == filename[0]:
        filename = bits[1:-1]                                                                                                                                                                        

    return JinjaInclude(filename)
{% jinja_include "some_template.html" %}
from django import template

class Empty(template.Node):
    def render(self, context):
        return ''                                                                                                                                                                                    

@register.tag
def django(parser, token):
    return Empty()                                                                                                                                                                                   

@register.tag
def end_django(parser, token):
    return Empty()
from django import template
from coffin.template import Template

register = template.Library()

class Jinja(template.Node):
    def __init__(self, template):
        self.template = template                                                                                                                                                                     

    def render(self, context):
        return self.template.render(context)                                                                                                                                                         

@register.tag
def jinja(parser, token):
    '''Create a Jinja template block                                                                                                                                                                 

    Usage:
    {% jinja %}
    Although you're in a Django template, code here will be executed by Jinja
    {% end_jinja %}
    '''                                                                                                                                                                                              

    '''Generate the end tag from the currently used tag name'''
    end_tag = 'end_%s' % token.contents.split()[0]                                                                                                                                                   

    tokens = []
    '''Convert all tokens to the string representation of them
    That way we can keep Django template debugging with Jinja and feed the
    entire string to Jinja'''
    while parser.tokens:
        token = parser.next_token()
        if token.token_type == template.TOKEN_TEXT:
            tokens.append(token.contents)                                                                                                                                                            

        elif token.token_type == template.TOKEN_VAR:
            tokens.append(' '.join((
                template.VARIABLE_TAG_START,
                token.contents,
                template.VARIABLE_TAG_END,
            )))                                                                                                                                                                                      

        elif token.token_type == template.TOKEN_BLOCK:
            if token.contents == end_tag:
                break                                                                                                                                                                                

            tokens.append(' '.join((
                template.BLOCK_TAG_START,
                token.contents,
                template.BLOCK_TAG_END,
            )))                                                                                                                                                                                      

        elif token.token_type == template.TOKEN_COMMENT:
            pass                                                                                                                                                                                     

        else:
            raise template.TemplateSyntaxError('Unknown token type: "%s"' % token.token_type)                                                                                                        

    '''If our token has a `source` attribute than template_debugging is
    enabled. If it's enabled create a valid source attribute for the Django
    template debugger'''
    if hasattr(token, 'source'):
        source = token.source[0], (token.source[1][0], token.source[1][1])
    else:
        source = None                                                                                                                                                                                

    return Jinja(Template(''.join(tokens), source=source))
def _generate_django_exception(e, source=None):
    '''Generate a Django exception from a Jinja source'''
    from django.views.debug import linebreak_iter                                                                                                                                                    

    if source:
        exception = DjangoTemplateSyntaxError(e.message)
        exception_dict = e.__dict__
        del exception_dict['source']                                                                                                                                                                 

        '''Fetch the entire template in a string'''
        template_string = source[0].reload()                                                                                                                                                         

        '''Get the line number from the error message, if available'''
        match = re.match('.* at (\d+)$', e.message)                                                                                                                                                  

        start_index = 0
        stop_index = 0
        if match:
            '''Convert the position found in the stacktrace to a position
            the Django template debug system can use'''
            position = int(match.group(1)) + source[1][0] + 1                                                                                                                                        

            for index in linebreak_iter(template_string):
                if index >= position:
                    stop_index = min(index, position + 3)
                    start_index = min(index, position - 2)
                    break
                start_index = index                                                                                                                                                                  

        else:
            '''So there wasn't a matching error message, in that case we
            simply have to highlight the entire line instead of the specific
            words'''
            ignore_lines = 0
            for i, index in enumerate(linebreak_iter(template_string)):
                if source[1][0] > index:
                    ignore_lines += 1                                                                                                                                                                

                if i - ignore_lines == e.lineno:
                    stop_index = index
                    break                                                                                                                                                                            

                start_index = index                                                                                                                                                                  

        '''Convert the positions to a source that is compatible with the
        Django template debugger'''
        source = source[0], (
            start_index,
            stop_index,
        )
    else:
        '''No source available so we let Django fetch it for us'''
        lineno = e.lineno - 1
        template_string, source = django_loader.find_template_source(e.name)
        exception = DjangoTemplateSyntaxError(e.message)                                                                                                                                             

        '''Find the positions by the line number given in the exception'''
        start_index = 0
        for i in range(lineno):
            start_index = template_string.index('\n', start_index + 1)                                                                                                                               

        source = source, (
            start_index + 1,
            template_string.index('\n', start_index + 1) + 1,
        )                                                                                                                                                                                            

    exception.source = source
    return exception          

class Template(_Jinja2Template):
    """Fixes the incompabilites between Jinja2's template class and
    Django's.                                                                                                                                                                                        

    The end result should be a class that renders Jinja2 templates but
    is compatible with the interface specfied by Django.                                                                                                                                             

    This includes flattening a ``Context`` instance passed to render
    and making sure that this class will automatically use the global
    coffin environment.
    """                                                                                                                                                                                              

    def __new__(cls, template_string, origin=None, name=None, source=None):
        # We accept the "origin" and "name" arguments, but discard them
        # right away - Jinja's Template class (apparently) stores no
        # equivalent information.
        from coffin.common import env                                                                                                                                                                

        try:
            return env.from_string(template_string, template_class=cls)
        except JinjaTemplateSyntaxError, e:
            raise _generate_django_exception(e, source)                                                                                                                                              

    def __iter__(self):
        # TODO: Django allows iterating over the templates nodes. Should
        # be parse ourself and iterate over the AST?
        raise NotImplementedError()                                                                                                                                                                  

    def render(self, context=None):
        """Differs from Django's own render() slightly in that makes the
        ``context`` parameter optional. We try to strike a middle ground
        here between implementing Django's interface while still supporting
        Jinja's own call syntax as well.
        """
        if not context:
            context = {}
        else:
            context = dict_from_django_context(context)                                                                                                                                              

        try:
            return super(Template, self).render(context)
        except JinjaTemplateSyntaxError, e:
            raise _generate_django_exception(e)                                                                                                                                                      

def dict_from_django_context(context):
    """Flattens a Django :class:`django.template.context.Context` object.
    """
    if isinstance(context, DjangoContext):
        dict_ = {}
        # Newest dicts are up front, so update from oldest to newest.
        for subcontext in reversed(list(context)):
            dict_.update(dict_from_django_context(subcontext))
        return dict_
    else:
        return context
{% ifequal foo bar %}
Django style if...
{% endif %}

{% jinja %}
{% if foo == bar %}
Jinja style if...
{% endif %}
{% end_jinja %}

{% block relbar1 %}
<!--# include virtual="/render_header/" -->
{{ super() }}
{% endblock %}

response['Content-Length'] = len(response.content)

sudo gem install haml

INSTALLED_APPS = (
    ...
    'compressor',
    ...
)

...

COMPILER_FORMATS = {
    '.sass': {
        'binary_path':'sass',
        'arguments': '*.sass *.css'
    },
    '.scss': {
        'binary_path':'sass',
        'arguments': '*.scss *.css'
    }
}

{% load compress %}

...

{% compress css %}
<link rel="stylesheet" href="{{ MEDIA_URL }}css/base.scss" media="screen">
{% endcompress %}

CACHE_BACKEND = 'memcached://127.0.0.1:11211/'

$orange: #EE8529;

ul {
    font-size: 26px;
    li {
        color: $orange;
    }
}

.distinct()
.distinct()
try:
    import json  # Python 2.6+
except ImportError:
    import simplejson as json  # Python 2.5-

bin/buildout-source-release
https://url/to/your/project/tags/1.7 buildout.cfg
deploy.cfg
-n project-1.7
1.7
project-1.7.tgz
python install.py
python
bootstrap.py
bin/buildout
python-2.6.4.exe
.so
django.pth
from matplotlib._path import affine_transform
ImportError: DLL load failed: The specified module could not be found

linkinfo.dll
AccessInit:
hash collision: 3 for both 1 and 1
settings.py
import sys
import PIL.Image
sys.modules['Image'] = PIL.Image

server {
        listen 80;
        server_name  example.com;
        access_log  /var/log/nginx/example.log;

        location / {
                proxy_pass   http://127.0.0.1:1337;
        }
}

from django_open_inviter.open_inviter import OpenInviter
o = OpenInviter()
contacts = o.contacts('example@example.com', 'test')

$ hg clone http://bitbucket.org/mirror/django
$ cd django
$ hg branch my_fixes
$ patch -p1 < /path/to/correct/8426.diff
$ hg commit -m "helptext CSS class for help text in forms"

$ hg pull && hg merge -r default && hg commit -m "Merged from trunk"

Planet Django

About

Tip

Status

Authors

Aggregated blog posts about Django, updated every hour

September 03, 2010

What is a decorator?

A simple example

Another example

Conclusion

September 02, 2010

Tools you can Use

1. Todo List

2. Twitter

3. Image Magick

4. Facebook

5. Google

September 01, 2010

Crawler access

Crawl errors

Crawl stats

Even more…

First Impressions

Results

The Video

August 31, 2010

Why use the command line?

Using JMeter without a GUI

August 30, 2010

Templates

Option 1

Option 2

Media

Template Tags

August 29, 2010

Backwards compatibility

Other features

To make everybody happy

Where to go from here

The Problem

Reducing shared state

Creating the response in __new__

No Caching

Django's template caching templatetag

Django's two-part caching middleware

NGINX's Memcached module

On-disk caching with django-staticgenerator

Varnish

Conclusion

Invoking the REPL

Providing context

Use the same tools with PDB

August 28, 2010

hg and svn support

Whitelisting support

A sweet logo

Subdomain and CNAME support

RTFD.org

LaTeX support

August 27, 2010

Benefits to a centralized logs

Syslog Review

Setting up your central server

Setting up the remote log sending servers

Additional help and features

August 26, 2010

August 25, 2010

August 24, 2010

August 23, 2010

August 22, 2010

Using Nginx Ghetto ESI

The problem

August 21, 2010

August 19, 2010

August 18, 2010

Actual Django project: well-deployable

Installing, installing

cx_Oracle DLL problem

Oracle/geodjango GEOS DLL problem

Creating the response in new