From zero to code hero

Django AJAX Tutorial Part 3 - ajax pagination #2

2011-07-18T07:41:00.001+02:00

Hello. After long time not seen I'm back to finish the topic of pagination in django with AJAX and after few posts also django topic as a whole. The reason is simple - I've switched totally to javascript and ExtJs framework. So let's get started !

Ok, so we'll be using the same 'Friend' model, so I'll skip the code here. Next go the urls :

First address is for the main page of our sample project. We won't be using it anywhere in the code. Next is the address of view which generates the friends list. The index view as well as view for changing page will be sending requests there. Finally the last link is for the change page function. For sake of simplicity we'll be using named urls here.
Next - the views, and we'll start from the index view :

per_page = 4

def index(request):
    template_name = 'pagination/index2.html'
    html,pagination = load_friends_list(request)

    return render_to_response(template_name, {"html": html, 'pagination': pagination}, context_instance=RequestContext(request))

The per_page variable remains the same as previously. In the function itself not much to say about. We assign result of calling load_friends_list function to two variables and then include them in the rendered template.
Can we proceed to the next view ? If yes - the friends list generator comes into scene.

def load_friends_list(request):
    objects = Friend.objects.all()
    template_name = 'pagination/friends2.html'
    paginator = Paginator(objects, per_page)
    p = request.session.get("pagination_page", request.REQUEST.get("page", 1))

    pages = paginator.num_pages
    try:
        page = paginator.page(p)
    except EmptyPage:
        page = 0

    friends = render_to_string(template_name, RequestContext(request, {
        "page" : page,
    }))
    
    pagination = render_to_string('pagination/pagination.html', RequestContext(request, {
        "page" : page,
        "pages": pages        
    }))

    return (friends, pagination)

Now let's go through this code above. First two lines of the function don't need explenations I guess. Then we're creating the Paginator object, calling it's constructor with two arguments - our objects list that we want to paginate and the amount of items per page.
The next line is responsible for getting the current page number. As you'll see in a minute, the change page function can set a session variable for storing the current page value. If that didn't happen we're doing a lookup through REQUEST object ( which is added to each request ) for 'page' variable. And if it's not present - we're picking the first page.
Proceeding further we're storing total number of pages using the built-in Paginator function 'num_pages'(here's the link to docs concerning this topic ). Next we're doing a try-catch check to finally get our paginated objects. By calling the 'page' function of Paginator we're receiving the objects list from the desired page. If this page does not exist we're setting value 0.
Finally we need to render all those things to be used in templates. First goes paginated friends
list object. Next we're rendering pagination sending page object as well and amount of pages (which is not really needed but simplifies the template).
We could have had returned here friends list together with pagination in one template, but I didn't wanted to change the page structure.

Finally the last view, for setting the current page.

def set_friends_page(request):    
    request.session["pagination_page"] = request.GET.get("page", 1)    
    html = load_friends_list(request)[0]
    result = simplejson.dumps({"html" : html}, cls = LazyEncoder)
    return HttpResponse(result)

This view starts with getting the 'page' number from request and storing it in a session variable. If 'page' is not present in the request, we're setting it to the first page. Then we're using previously described function load_friends_list to generate list of paginated objects. As you can see we pick only the first argument from the returned value which is the friends list itself. Finally we can build the result response ( we're using the LazyEncoder described in the first tutorial concerning Ajax) and retunrn it via HttpResponse.

If we already have that we can get to the last part - the templates. First the templates for friends and pagination, as not much is going on there :

{% if page.objects_list %}
 <ul class="friends-list">
  {% for f in page.object_list  %}
   <li>
    <div class="friend-avatar">
     <img src="http://a2.twimg.com/profile_images/1116899230/mb_normal.png" />
    </div>
    <div class="friend-name">
     <p>{{ f.name }}</p>
    </div>
   </li>
  {% endfor %}
 </ul>
{% else %}
 <p>You have no friends.</p>
{% endif %}

'friends' template have basically the same structure as in the previous tutorial. We've just changed the source of paginated objects to objects_list parameter of the page objects (which was generated by Paginator as you already know) and moved here the test for friends existence

Now the pagination template :

<ul id="pagination">
    {% if pages %}
        {% ifequal pages 1 %}
            <li id="{{pages}}">{{pages}}</li>
        {% else %}
            {% for i in page.paginator.page_range %}
                <li id="{{i}}">{{i}}</li>
            {% endfor %}                        
        {% endifequal %}
    {% endif %}
</ul>

First we're checking if pagination will be present at all (if there were no objects to paginate, the amount of pages would be 0 and so there would be no pagination. We could have used page.paginator.num_pages here but it needs much more chars to describe as well as requires a lookup in the page object. So why bother ? :) )
If the amount of pages is one, we just insert one list element. If the amount is greater than one we'll iterate through page.paginator.page_range parameter which has the form of an array (ie. [1,2,3]). And that's all for the pagination. Finally we can get to the index tpl.

<div style=\"margin-top:15px; border-top:1px solid #E1E6EC\">
        <div class=\"friendsList\">
            <div id=\"loading\">
            </div>
            <h2 class=\"div-title\">
                Friends
            </h2>
            <div class=\"div-content\">
                <div id=\"friends-data\">                     
                    {{ html|safe }}
                </div>           
            </div>
            {{ pagination|safe }}
        </div>
    </div>   
<script type=\"text/javascript\">
</script>

First of all I've cut the script out as I want to describe it separately. As for the template itself basically nothing to write here about. Sctructure is mainly the same as previously. We have just inserted our two generated variables : the friends list and pagination. We're using 'safe' filter on them so that html tags won't be escaped. The last code belongs to the javascript required for handling ajax requests.

$(function(){  
 function showLoader(){
     $("#loading").fadeIn(500,0);
  $("#loading").html("");
 }

 function hideLoader(){
  $("#loading").fadeOut('slow');
 };
 
 $("#pagination li:first").addClass('selected');

 $("#pagination li").click(function(){   
  showLoader(); 
  $("#pagination li").removeClass();
  $(this).addClass('selected');
  var pageNum = this.id;

        $.ajax({
            type: "GET",
            url: "{% url set_friends_page %}",
            data: "page="+pageNum,
            async: false,
            dataType: 'json',
            success: function(data){
                el = $('#friends-data');
                $("#friends-data").html(data.html);
                hideLoader();
            }
        });
        return false;        
 });
});

As previously we're using jQuery for the sake of simplicity. Also first two functions are exactly the same - they either hide or show the loader div by changing it's display type. Next line sets the class of first pagination element to 'selected'. Finally the most important function - click event handler for pagination
list elements. So each time user clicks <li> element we call this function. First we show the loader, and remove class from all pagination list <li> elements. Next we add class 'selected' to the currently clicked element by using this variable. Before performing ajax request there's just one last thing to do which is storing the id of clicked element to pageNum variable.
Now the fun part - we will do a proper ajax request using jQuery's built in 'ajax' function. In a nutshell it all just comes down to doing a request at our change page view url and then handle the returned data.
Before doing a request we must set some initial parameters which are: the type of request ('GET', 'POST' etc.) url of request (which in this example is our set_friends_page view url), data that we will send (which is the 'page' variable that we're processing later in our views), asynchronousity (if the request blocks the UI or not. Here we do not need the request to be asynchronous as there's not much for the user to do during page load), type of returned data and callback function called when ajax calls ends with success.
The last parameter is the one responsible for performing the html update operation. As a result of our ajax request we're receiving json (of the following form {"html": "<ul>....</ul>"} ) object containing one parameter : html. This data.html contains the rendered list of friends for proper page number. So we select friends-data div from the DOM and in the next step insert the returned html inside this div with jquery's 'html' function. After that we hide the loader div once again.

So basically that's all for this episode of 'Ajax with Django' tutorial. Hope you liked it and if something is not clear or if you have some other questions, just leave a comment or find me on twitter. I'm aware of the fact, that this code has some bugs like the fact that stored session variable is not being reseted each time we're refreshing the example page which may lead that we have different than first page loaded but first page selected in the navigation but really I've tried to keep it simple.
I've created a demo so you can check how it works :
http://samples.fromzerotocodehero.x14.eu/pagination2/start
, as well as prepared the code for download:
http://ofcjs.x14.eu/pagination2.rar
I will try to put next tutorials in the next few days to finish the series. So stay tooned.

Break

2011-05-09T01:28:00.001+02:00

Sorry for not updating my blog recently, but it's connected to a switch in my interests which now concern more javascript than django/python. Still in the next few days I'm gonna finish my pagination with django 'series' as well as post some nice small chat app which I think you will like. So stay tooned, and for now check those links :

microjs.com - forget about jquery. Use small (up to 5kb) libs containing only what you need.

mibbu.eu - cool small gamedev framework from me mate michalbe

{dev:unplugged} - competition from Microsoft for HTML5 games. Some of them look really nice.

Django AJAX Tutorial Part 2 - ajax pagination #1

2011-02-03T22:24:00.003+01:00

Hello again. For some time now I will continue my tutorials concerning using AJAX with Django. I have received few requests to write about pagination next, so this is the topic for today's post. In the last months I went through few different methods of ajax pagination. I will try to show you at least three but each in different post.
The one I'm going to write about today was the first I've tried. It uses built-in django generic views.

Let's begin with views, as they're most important here :

#!/usr/bin/env python
# encoding: utf-8
#Python
import math

#Django
from django.conf import settings
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.generic.list_detail import object_list

#Project
from models import Friend

#we're importing LazyEncoder written in first part of Django - Ajax tutorial
from tutorial_utils import LazyEncoder

# 'global' variable storing amount of objects per page
per_page = 4

def index(request):
    
    #we take all object's that we want to be paginated
    friends = Friend.objects.all()
    
    #count them
    count = friends.count()
    
    #count amount of pages
    pages = math.ceil(count / float(per_page))
    pages = int(pages)
    
    #create list of pages
    pages = range(1, pages+1)

    #if amount of objects is smaller than per_page variable, we create only one page
    if count <= per_page:
        pages = 1

    return render_to_response('pagination/index1.html', {
            'pages': pages, 'count': count
            }, context_instance=RequestContext(request))

#this view will create us list of friends
def friends_list(request):

    #first take all objects       
    friends = Friend.objects.all()   
    template = 'pagination/friends1.html'
    
    #using generic view display list of objects paginated by 'pagenate_by' elements. Good part about using object_ilst generic view is that it automatically paginates elements and then allows showing the desired page by accessing 'page_with_objects_url' + ?page=number_of_page. we will take advantage of this in our example.

    return object_list(request, 
        queryset = friends,
        paginate_by = per_page,
        template_name = template,
        extra_context = {}
        )

Ok so idea is that we use generic view 'object_list' that paginates objects for us and creates links for each page. So now let's take a look at urls :

from django.conf.urls.defaults import *
from views import *

urlpatterns = patterns('',
    url(r'^start$', index, name="index"),
    url(r'^friends_list/$', friends_list),
)

Nothing complicated here. I'm not using named urls here to make it easier to understand in the javascript part. Next thing are the templates. First I'll present the one responsible for creating list of friends (props go to michalbe for lending me his twitter avatar :)) :

{% for f in object_list %}




{{ f.name }}

{% endfor %}

And main template with the pagination part :


Friends
{% ifequal count 0 %}
                  You have no friends.
{% else %}
                 {% if pages %}                                                   {% ifequal pages 1 %}
{{pages}}

{% else %}                                                           {% for i in pages %}
{{i}}

{% endfor %}{% endifequal %}{% endif %}                  
{% endifequal %}

As you can see here I've included pagination in this template (so that it won't be refreshed each time user changes page). If number of pages is none, we're showing appropriate alert. Else if there is only one page, we're not using loop because we would get two pages in fact (page 0 and 1). If there are more pages, we're just going through a for loop adding each of them and setting their id's to page number. we will need that in the js part which comes next. Once again I'm using jQuery here to keep it simple and take advantage of it's built in function 'load' that reads content under specified address and then includes it html of our page :

Ok, so that's the whole code for today. As previously I've created working example for you under this link :http://samples.fromzerotocodehero.x14.eu/pagination1/startAnd here's a downloadable package (soon I'll move all of this to my git account I promise :) ):http://ofcjs.x14.eu/pagination1.zip

Django AJAX Tutorial Part 1 - adding email to newsletter

2011-01-31T18:32:00.003+01:00

This is something I really wanted to write about since some time - using ajax with django. The cause is simple - internet is lacking good materials concerning this matter. And I remember having many problems with ajax in the beginning. That's why in the next few days I will show typical usage of ajax with django, like form validation, pagination and simple shoutbox.

Ok - the basics. First thing you need to understand - when talking about ajax here we mean a request which is sent from the browser by javascript, usually asynchronously ( meaning user can do other things while we're processing it). So to keep it simple - ajax is the 'request' we're using in our django views. And instead of reloading the whole page after user clicks some link or submits form we can first process it in the background and then refresh only the needed parts of the page. Sounds pretty facebookish doesn't it ? :) And there's no magic in it, really.

Let's start from the simplest possible example - we will allow user to add email to some newsletter. Here is tho code for model, url and form :

class NewsletterForm(forms.Form):
    email = forms.EmailField(label=_("E-mail address"))

class NewsletterEmails(models.Model):
    email = models.EmailField(_(u"E-mail address"),)

urlpatterns = patterns('',
    url(r'^newsletter_add/$', newsletter_add, name="newsletter_add"),
)

Nothing unexpected here I guess. Simple model, simple form with just one field and a link to our view (remember - even though we're not redirecting user to this link, we still need a way to call our view function processing the email).
Next comes the view function :

from django.http import HttpResponse
from django.template.loader import render_to_string
from django.utils import simplejson
from django.utils.functional import Promise
from django.utils.encoding import force_unicode
from models import NewsletterEmails
from forms import NewsletterForm

#here is some magic. We need to write custom JSON encoder, since sometimes
#serializing lazy strings can cause errors. 
#You need to write it only once and then can reuse in any app

class LazyEncoder(simplejson.JSONEncoder):
    """Encodes django's lazy i18n strings.
    """
    def default(self, obj):
        if isinstance(obj, Promise):
            return force_unicode(obj)
        return obj

#here the view function starts
def newsletter_add(request):

    #as usual when processing forms we check if the method was POST/GET
    if request.method == "POST":

        #we get email address from request variables      
        adr = request.POST['email']
        e = None

        #we process address only if it's longer than 6 characters.
        #this assures us than we won't waste server time on
        #addresses like 'oeui' or 'u@u.u' 
        if len(adr) > 6:
            
            #create form instance and fill it with data. In this case it will only be the email address
            form = NewsletterForm(data=request.POST)
            
            #let django perform the validation
            if form.is_valid():

                #check if the email address is not already in our database
                try:
                    e = NewsletterEmails.objects.get(email = adr)
                    message = _(u"Email already added.")
                    type = "error"
                except NewsletterEmails.DoesNotExist:

                    if DoesNotExist exception was caught we add the address 'safe-mode' using try/catch
                    try:
                        e = NewsletterEmails(email = adr)
                    except DoesNotExist:
                        pass
                    message = _(u"Email added.")
                    type = "success"
                    e.save()
            else:
                message = _(u"Bad address.")
                type = "error"                
        else:
            message = _(u"Too short address.")
            type = "error"

    #we don't need to do this but it's good practice to check the source of request. If it comes from ajax call we build the response.

    if request.is_ajax():
        #let built in simplejson package serialize our data. It means we transform everything to simple strings.
        result = simplejson.dumps({
            "message": message,
            "type": type,
        }, cls=LazyEncoder)

        #return the response
        return HttpResponse(result, mimetype='application/javascript')

Now the form. This is really basic so I won't say anything more about it apart of the fact that we explicitly set the action of our form to address of view processing addition of emails :

and finally the javascript part. I'm using jQuery javascript library here as well as jQuery's form plugin for processing forms. It simply adds method that takes all the values from form's fields and sends it to specified address (in this case it'll be "newsletter_add"). We could do this by ourselves, but that's not what this tutorial is about.

And basically that will be all for this part. As you can see the key to using AJAX with django is that our views must return serialized strings with JSON so that we can process them with javascript.

For the first time I have prepared a working example under this link :

http://samples.fromzerotocodehero.x14.eu/newsletter1/start

as well as downloadable code :

http://ofcjs.x14.eu/ajax1.zip

If you have any questions feel free to ask in comments or on my twitter.

Synchronizing youtube user's videos filtered by tags

2011-01-28T21:04:00.001+01:00

Today I will write about synchronizing your app with youtube and then filtering movies of specific user by tags. But let's get back to the beginning. I assume you already have django-syncr installed. I also assume that you're using video as attribute of some other object. Basic usage is pretty straightforward, so I'll proceed to some examples.

First the easiest one - we provide id of video as a string and as a result we receive Video instance :

from django-syncr.youtube import YoutubeSyncr

def sync_video_id(id):
    """ Synchronize single video by given YoutubeID    
    Takes youtube id as a string. Returns Video instance.   
    """
    
    y = YoutubeSyncr()
    try:
        video = y.syncVideo(id)
        return video
    except:    
        return video

That was easy. Let's try something more complicated then. Next there's a synchronization when provided url to video. Using python's built in urlparse module we divide url into components. Because my actual code needed to be compatible with version 2.4 of python, I'm using cgi module here (the same functions just stored in different place). Here's how this looks step by step. Everything is rather self-explanatory so I will not go through it line by line :

>>> url = 'http://www.youtube.com/watch?v=mPXxI1uyVEE&feature=rec-LGOUT-exp_fres
h+div-1r-3-HM'
>>> url
'http://www.youtube.com/watch?v=mPXxI1uyVEE&feature=rec-LGOUT-exp_fresh+div-1r-3
-HM'
>>> import urlparse
>>> url_data = urlparse.urlparse(url)
>>> url_data
ParseResult(scheme='http', netloc='www.youtube.com', path='/watch', params='', q
uery='v=mPXxI1uyVEE&feature=rec-LGOUT-exp_fresh+div-1r-3-HM', fragment='')
>>> query = urlparse.parse_qs(url_data[4])
>>> query
{'feature': ['rec-LGOUT-exp_fresh div-1r-3-HM'], 'v': ['mPXxI1uyVEE']}
>>> id = query["v"][0]
>>> id
'mPXxI1uyVEE'

and that's how we will do this in django :

from django-syncr.youtube import YoutubeSyncr

def sync_video_url(url):
    """ synchronize single video by it's url    
    Takes video url as a string, returns Video object.

    """
    import urlparse
    url_data = urlparse.urlparse(url)
    try:
        query = cgi.parse_qs(url_data[4])
    except:
        query = urlparse.parse_qs(url_data[4])
    id = query["v"][0]
    
    y = YoutubeSyncr()
    try:
        return video = y.syncVideo(id)
    except:    
        return none

When you're finished warm up It's time for more complex functionality. Now we will sync videos of specific users meeting specified tags requirements. First the core function that will do the work here. Because I tried to make it reusable django's ContentType module is used. :

from django.contrib.contenttypes import generic
from django.contrib.contenttypes.models import ContentType
from django-syncr.youtube import YoutubeSyncr

def sync_video_user(parent,model_name,user,tags):
    """ Sync all videos of user matching given tags pattern .
    
    Takes parent object, object to sync videos (as a string), string with username and string with tags.
    Returns list of synchronized videos. Takes care of already existing videos as well as prevents duplication of slugs.
    """
    
    from django.template.defaultfilters import slugify
    
    #first we need to get the actual model for object holding video.
    model_class = ContentType.objects.get(model=model_name).model_class()
    
    #we create a queryset for searching for duplicates of video we're currently worknig on
    queryset = model_class._default_manager.all()
    
    #parse string of tags to get proper validating url string
    fmt_tags = parse_tags(tags)

    #request for youtube feed
    feed = get_youtube_feed_url(user, fmt_tags)
    
    #search for videos parsing returned feed
    sync = search_youtube(feed)

    #create a temporary instance (notice not using save() anywhere here) to get object methods available as well as queryset
    instance = model_class()

    for vid in sync:
        
        #if our queryset does not already contain object with this video id
        if not queryset.filter(**{"yt_video_id": vid.video_id}):

            #check if slug is free
            free = try_slug(instance, slugify(vid.title))
            if not free:
                
                #if not use function which we had already discussed some time ago - unqiue_slugify
                free = unique_slugify(instance, slugify(vid.title))
            else:
                free = slugify(vid.title)

            #create new object
            new = model_class(parent=parent,
                               slug=free,
                               name = vid.title,
                               yt_video_id=vid.video_id,
                               video=vid,
                               publication_date=vid.published, active=True,
                              )
            new.save()

    return 1

Now that we have the main part of the code, we can look on the smaller pieces :

def parse_tags(tags):
    """
    Parse received string of tags to tags list. Then append them to yt search API address.
    Return path to search api.    
    
    parse_tags(tags):
        url(string)        
    """

    tags_list = tags.split(',')
    tags_list = [tag.strip() for tag in tags_list]
    tags_list = [re.sub(r"\s+", "+", tag) for tag in tags_list
    parse_string = '&category=%s&v=2' % '%2C+'.join(tag.strip() for tag in tags_list)

    return parse_string

Not much magic going on here. We split string of tags and use simple regex to get single tags from it (tags are either separated by commas or more than two whitespaces. Multi-words tags allowed). We then put all tags to query url in the proper form.

Next function adds our tags to the rest of the query string containing youtube username :

def get_youtube_feed_url(user, url):
    """ Add username to youtube feed address.
    """
    
    feed = '/feeds/api/videos?author=%s&alt=rss' % user
    feed += url
    return feed

Finally when we have the whole query url we can perform the search using youtube api :

def search_youtube(path):
    """ Search videos on youtube
    
    If path is given, connects to youtube feed returns any videos matching query.
    All videos are then synched.
    
    """
    
    if path:
        import feedparser
        import urlparse
        
        YTSearchFeed = feedparser.parse("http://gdata.youtube.com" + path)
        videos = []
        for yt in YTSearchFeed.entries:

            #the only new part is here. Because returned feed is a really complex json file, we search for 'link' keys that store url to our desired videos       
            url_data = urlparse.urlparse(yt['link'])
            try:
                query = cgi.parse_qs(url_data[4])
            except:
                query = urlparse.parse_qs(url_data[4])
            id = query["v"][0]
            videos.append(id)
        
        synched = []
        for video in videos:
            try:
                sync = sync_video_id(video)
                synched.append(sync)
            except:
                pass
        return synched
    else:
        return []

And basically we're finished.

Using ProxyPass with django project

2011-01-09T23:53:00.002+01:00

Once again I need to postpone my post about django-syncr and youtube since I came across interesting problem recently. Here's the deal : user has his django app running on some server under some link. Application itself is visible under different link. So apache conf got 'ProxyPass' and 'ProxyPassReverse' added. All seemed to work fine apart of links created with '{% url %}' templatetag (and from what I was able to test also get_absolute_urls could cause problems depending on the method used to create them). Url tag was adding original django application name to the link. Because I'm no good in setting apache I've came up with different solution. After skimming through django/template/defaulttags and django/core/urlesolvers I've realized that rewriting both 'reverse' function and 'url' tag would be tedious and probably unnecessary. Instead I've just added this 'try' block that replaces first unwanted occurence of our app name (which is defined in settings under PROJECT_NAME variable) with empty sign to 'url' templatetag and saved it as custom tag named 'urlc'. Not sure if overriding default tags works, gotta check it some day.

else:
                if self.asvar is None:
                    raise e
        
        #code starts here
        try:
            url = url.replace(settings.PROJECT_NAME+'/', '', 1)
        except:
            pass
        #code ends here    

        if self.asvar:
            context[self.asvar] = url
            return ''

Not sure if it works for OP, but worked at my test config without bigger problems.

Provide unique slugs for model class

2011-01-08T01:55:00.000+01:00

Sorry my dear readers for this long break between posts, but I have had lots of work lately finishing previous jobs. Recently I've shown you how to synchronize your app with Twitter and also parse list of tweets changing hash tags to proper links. Today I wanted to show you how to synchronize application with youtube but for this purpose I need a way to provide unique slugs for models. So here's the whole code which I'll comment below :

import re

from django.template.defaultfilters import slugify

def try_slug(instance, slug):
    """Check if the slug is free for corresponding model instance
    """
    queryset = instance.__class__._default_manager.all()
    if not queryset.filter(**{"slug": slug}):
        return True
    else:
        return False

def unique_slugify(instance, value, slug_field_name='slug', queryset=None, slug_separator='-'):
    """Create unique slug
    
    Creates unique slug across model class.
    
    """
    slug_field = instance._meta.get_field(slug_field_name)
    slug_len = slug_field.max_length

    slug = slugify(value)
    slug = slug[:slug_len]
    slug = _slug_strip(slug, slug_separator)
    original_slug = slug
    
    if queryset is None:
        queryset = instance.__class__._default_manager.all()
    if instance.pk:
        queryset = queryset.exclude(pk=instance.pk)
 
    next = 2
    while not slug or queryset.filter(**{slug_field_name: slug}):
        slug = original_slug
        end = '%s%s' % (slug_separator, next)
        if slug_len and len(slug) + len(end) > slug_len:
            slug = slug[:slug_len-len(end)]
            slug = _slug_strip(slug, slug_separator)
        slug = '%s%s' % (slug, end)
        next += 1
    return slug

def _slug_strip(value, separator='-'):
    """
    Cleans up a slug by removing slug separator characters that occur at the
    beginning or end of a slug.
    """
    separator = separator or ''
    if separator == '-' or not separator:
        re_sep = '-'
    else:
        re_sep = '(?:-|%s)' % re.escape(separator)

    if separator != re_sep:
        value = re.sub('%s+' % re_sep, separator, value)

    if separator:
        if separator != '-':
            re_sep = re.escape(separator)
        value = re.sub(r'^%s+|%s+$' % (re_sep, re_sep), '', value)
    return value

So now some explanations to the code. First function gives us possibility to check if slug is free for specific model class. It takes object instance and slug and returns boolean value. Inside the code we take default 'all' manager of the model and filter queryset with slug.
Second function is the key to solving our problem. The unique_slugify function takes shown parameters. At first we check the max length of the slug field, so that we won't exceed its value. Then we slugify our slug with built in django function, cut it if needed and strip of sepparators different than '-' or 'separator' parameter received by function. Next step is to get the queryset on which we will be working, excluding our model instance. Finally the fun begins. In our while loop condition we check existence of newly created slug or result of filtering our queryset. If both are none we take the separator and add next integer to it.
If the length of concatenated slug and identifier is too long, we cut it off. Finally we're creating slug that will be used in while loop condition filter.
Last function is stripping our slug by separators appearing at the beginning and end of slug. Because it uses many regexes I will leave in your hands work of decyphering it :)

And now for some short sample usage :

free = try_slug(self.instance, self.cleaned_data['slug'])
if not free:
    self.cleaned_data['slug'] = unique_slugify(self.instance, self.cleaned_data['slug'])

Parsing tweets links, users and hash tags with django and python-twitter.

2010-12-09T22:56:00.000+01:00

Hello again. Today I'm going to continue my previous post concerning django and twitter. Last time we've finished after synchronising with twitter. This time I'm gonna show you how to parse list of received tweets for rendering it in our template so that links,hash tags and users mentions are treated as clickable links. So here's the code, I've added some comments to clarify what we're doing currently:

def parse_tweets(tweets):
    import re
    
    result = []
    for tw in tweets:
        tweet = tw.text;
        #compile regexes as objects
        hash_regex = re.compile(r'#[0-9a-zA-Z+_]*',re.IGNORECASE) 
        user_regex = re.compile(r'@[0-9a-zA-Z+_]*',re.IGNORECASE)
        
        #first deal with links. Any http://... string change to a proper link
        tweet = re.sub('http://[^ ,]*', lambda t: "%s" % (t.group(0), t.group(0)), tweet)
        
        #for all elements matching our pattern...
        for usr in user_regex.finditer(tweet):
            
            #for each whole match replace '@' with ''
            url_tweet = usr.group(0).replace('@','')

            #in tweet's text replace text with proper link, now without '@'
            tweet = tweet.replace(usr.group(0),
                ''+usr.group(0)+'')

        #do the same for hash tags
        for hash in hash_regex.finditer(tweet):
            url_hash = hash.group(0).replace('#','%23')
            if len ( hash.group(0) ) > 2:
                tweet = tweet.replace(hash.group(0),
                    ''+hash.group(0)+''); 

        #append each tweet to our list. Here I'm creating a dict containing tweet's text and date
        posts.append({'tweet': tweet, 'date': s.pub_time})   
    return posts

And now to show it in template :

{% for t in tweets %}


{% for k, v in t.items %}

{% ifequal k 'summary' %}

{{ v|safe }}

{% else %}

{% ifequal k 'date' %}

{{v|timesince}} ago

{% endifequal %}

{% endifequal %}

{% endfor %}


{% endfor %}

Probably there are better ways of doing this, but this one works for me. If you have any questions just write a comment or follow me via twitter

Check object's parameter value in django template

2010-12-08T03:30:00.002+01:00

I'm just finishing probably the most complexed project I'll ever build in django, at least by myself. During the development I've encountered numerous problems, some of without satisfying solutions on the web. So now for the next few posts I will share the results of my research, thinking and developing. Topic for today is :

How to check value of object's parameters in a template ?

Why do I ever need to do this kind of thing you may think. Yeah that's what I thought till now. But just think of my exact example - We have a site with some objects, that people can vote on. If someone has already voted we show him the result - if not, we render a voting button. Things are easy when rendering static page that is refreshed after each vote. But what if we need (just as I did) it to be dynamic ? I'm pretty sure that this problem can be solved using custom templatetag. But I've thought about a simpler solution using filters. So let's start.
I have created a context processor storing IP address of user. In my template I'm returning list of objects in a for loop, and on each object I'm using my filter, with IP as parameter:

{{ submission|check_voting:IP_ADDRESS|safe }}

And now the filter part :

@register.filter
def check_voting(obj, ip):
    result = obj.check_vote(ip)
    if result:
        result = "%s votes
" % obj.votes
    else:
        result =  "" % (settings.SITE_URL, obj.get_absolute_url() )    

    return result

As you can see my filter takes two arguments - object on which it was called, and ip. Then I'm doing some processing on my object's method 'check_vote' that returns me boolean value depending on query result for vote by ip. According to it's value I'm either showing a facebook like button used for voting, or just plain vote counter.
Hope you'll find this useful.

Providing uniqueness of different objects across one database

2010-11-08T12:34:00.000+01:00

Recently I needed to add facebook comments box for different pages (which were showing models of different classes). All of them needed some unique ID, to provide unique comments for each object. So at first I was thinking about applying GUUID for the db, but it looked like overcomplicating the problem. So I came up with this:

class GUUID(models.Model):
    guuid = models.PositiveSmallIntegerField(_(u"Dummy GUUID"), default=1)

It's a dummy model class with only one field (set to 1, but you can use it to provide some additional functionality). Ok, but where's our uniqueness ?

class Celebrity(BaseObject):
    uniq = models.IntegerField(blank=False, editable=False)

Here it is. Each model has a 'uniq' field set to integer field (u can use PositiveInteger if you want to). Then in save method of each object we add this :

    def save(self, *args, **kwargs):
        if not self.uniq:
            guuid = GUUID()
            guuid.save()
            self.uniq = guuid.id            
        super(Celebrity, self).save(*args, **kwargs)

Now when we save object, we check fo existence of 'uniq' field. If it is null, then we create a new GUUID object and set it's id as the value of 'uniq'.

Synchronizing django with twitter using django-syncr

2010-10-18T20:56:00.002+02:00

Ok so you have your first django powered application running (let me guess - CMS ? Blog ? :) ) and now you'd like to make it more "web 2.0"-ish by adding your twitter feeds. Althought I personally think this app is useless and dumb people who pay me think differently. So let's start. First you'll need some python's dependencies.

python-oauth2
python-twitter and stay alert, cause you need the latest build (so don't use easy_install as you'll get the deprecated 0.6 version)
django-syncr

Then go to dev.twitter and (if you already haven't) register a new application. This will generate you "consumer_key" and "consumer_secret". Write them down. Now let's get back to our application.
Iinstall both python dependencies but django-syncr add as an application in settings.INSTALLED_APPS. The reason for this is that you need to edit a bit of code, since currently available syncr does not support OAuth recently introduced on Twitter. Next either find "get_access_token.py" in python-twitter package, or download this function from sources and send somewhere within the scope of python. Before sending it though, open and edit :

AUTHORIZATION_URL = 'https://api.twitter.com/oauth/authorize'
SIGNIN_URL        = 'https://api.twitter.com/oauth/authenticate'

consumer_key    = None
consumer_secret = None

if consumer_key is None or consumer_secret is None:

In place of consumer_key and consumer_secret insert proper (previously saved) values as strings. Save and close and execute it with :

"python get_access_token.py run"

You will get a unique link printed in the console, that you need to visit. Visit it and press "Enter". Now you will get two more values to store somewhere : "access_token_key" and "access_token_secret".

Okay, now open syncr.app.tweet and change `__init__` function to this :

def __init__(self, username, key, secret, token_key, token_secret):

        self.username = username
        self.api = twitter.Api(
                            consumer_key=key, 
                            consumer_secret=secret, 
                            access_token_key=token_key,
                            access_token_secret=token_secret)
        self.user_cache = dict()

Here you can have different approach of course. You can hardcode your key values in it, add them to settings or send them each time when synchronizing with Twitter. Decision is up to you. Okay, last improvements to django-syncr. Open syncr.twitter folder, and edit models.py file. Here change Tweet.tweeter_id field from PositiveIntegerField to either IntegerField(if you're running < 1.2) or BigIntegerField. We're finished with edits, so sync your database and add this code to the view/context_processor that will serve your tweets :



#1. create TwitterSyncr object

t = TwitterSyncr('twitter_username', 

'your_consumer_key',

'your_consumer_secret',

'your_access_token_key',

'your_access_token_secret',)

#2. synchronize your TwitterSyncr object with existing Twitter user

t.syncUser('twitter_username')

#3. get tweets for the Twitter user (so it will import tweets from Twitter to your DB)

t.syncTwitterUserTweets('twitter_username')



#4. grab user from database and it's tweets

user = TwitterUser.objects.get(screen_name="twitter_username")

tweets = Tweet.objects.filter(user=user)

And voila ! You have a list of your most recent tweets available. Of course you can limit the amount of parsed tweets with [:number].

Recent months list in django

2010-10-11T18:08:00.001+02:00

After a while I'm back with hot new stuff for you and me :) Recently I needed to select blog entries from 5 consecutive months (counting from current) to my footer archive list. The biggest problem was with the range of months in different years. After a lot of struggle I've came across a python module (probably you will have it in your default setup) `dateutil`, which gives new functionality to date related functions. Ok, so let's get to the code. My function was added to context processors to provide me functionality across whole site. Then we build a date object from current date. Next step is to run a generator expression (which I will speak about some more in the future as they're one of the most important features of python language together with coroutines and generator functions) for a increasing range of months (you can also use a list comprehension here if you need some additional lists functionality or a generator function. but I've tried to keep it simple). This gives us a generator object so we create a dictionary of it, with years as keys and corresponding months as dates. Because this dictionary provides us with numbers only, I've added additional function to translate them to string months values (note the brilliant Python's switch-case funcionality) here shown with Polish dictionary.

from datetime import datetime
from dateutil.relativedelta import relativedelta

def get_blog_archive(request):
    now = datetime.today()
    first_month = datetime(now.year, now.month, 1)
    previous_months = (first_month - relativedelta(months = months) for months in range(0, 5, 1))
    
    news_archive = {}
    for pm in previous_months:
        m = translate_month(pm.month)
        if news_archive.has_key(pm.year):
            news_archive[pm.year].append(m)
        else:
            news_archive[pm.year] = [m]
    m = translate_month(current_month)
    news_archive[current_year].append(m)
    
    return {'NEWS_ARCHIVE': news_archive,}

def translate_month(month):
    ret_month = ""
    months = {
            1: "Styczeń",
            2: "Luty",
            3: "Marzec",
            4: "Kwiecień",
            5: "Maj",
            6: "Czerwiec",
            7: "Lipiec",
            8: "Sierpień",
            9: "Wrzesień",
            10: "Październik",
            11: "Listopad",
            12: "Grudzień",
        }
    ret_month = months.get(month)
    return ret_month

Okay this code is nice but not really functional, beacuse we get months names as String (here with utf-8 chars) and its troublesome to parse them as urls. So here's a bit more functional approach :

    news_archive = []
    for pm in previous_months:
        d = datetime(pm.year,pm.month,1)
        news_archive.append(d)
    
    return {'NEWS_ARCHIVE': news_archive,}

And now in our template we just parse with for loop through list elements.
So that's all and stay tooned for some more advanced django examples. I'm doing a really big project right now but there's a ready shoutbox for django example, few implementations of django-registration, something about handling files and more :)

Conditional context processor for authenticated users

2010-07-29T17:57:00.000+02:00

Recently I needed a context processor to display friends of my logged user. Userprofile is the name for extended user model. Here's the code :

def friends_list(request):
    try:
        user = request.user
    except User.DoesNotExist:
        user = AnonymousUser()
    
    userprofile = None
    try:
        userprofile = UserProfile.objects.get(user=request.user)
    except UserProfile.DoesNotExist:
        pass
    if userprofile:
        friends = Friend.objects.filter(friend_of=userprofile)
    else:
        friends = {}
    return {'friends': friends}

Python's lambda

2010-07-28T04:26:00.000+02:00

Because I don't quite get what and when python's lambda function's can be of any use - I did some research. Then I've found this sleek way of calling one lined function with unnamed parameter :

>>> (lambda x: x*2)(3)
6

Pretty cool.

Scroll to top - the new way

2010-07-27T23:43:00.001+02:00

Thing you will find useful at some point - how to scroll from random part of page to the top ? Here's a way how to obtain it with jQuery :

$(document).ready(function(){
  $('a[href=#]').click(function(){
    $.scrollTo(0,'slow');
    return false;
  });
});

But remember to include jQuery ScrollTo plugin in your imports. Now every link with hash as target will scroll your page back to the top with nice jquerish effect. Cooll huh ?

Random sort of array elements

2010-07-02T14:05:00.000+02:00

Recently I came across problem of sorting randomly elements of some array. Here's what I came up with :
Pseudocode :

for each element in the array
calculate a random number with index range from 0 to array size -1
store the current element in a temporary variable
replace the current element in the array with the element at the random index
replace the element at random index with the element at temporary variable

Solution :

        int[] buttons = new int[16];

        for(int i=0; i<16; i++){
            buttons[i] = i;
        }

        int rand;
        int temp;
        Random random;

        random = new Random(System.currentTimeMillis());
        for (int i = 0; i < buttons.length; i++) {
            rand = (random.nextInt() & 0x7FFFFFFF) % buttons.length;
            temp = buttons[i];
            buttons[i] = buttons[rand];
            buttons[rand] = temp;
        }

Threads in Java

2010-06-11T00:35:00.000+02:00

"Dining Philosophers" problem solved with Java and Semaphores.

import java.util.concurrent.Semaphore;
import java.util.Random;
import java.util.Vector;

public class Philosopher extends Thread
{
    private static final Random rand = new Random();
    private static int event=0;
    private static String binary="";
    private int id;
    private Semaphore sem;
    private static Vector vector = new Vector();

    public Philosopher(int i, Semaphore s)
    {
        id = i;
        sem = s;
        binary = binary + "0";
    }

    private void busy()
    {
        try
        {
            sleep(rand.nextInt(1000));
        } catch (InterruptedException e){}
    }

    private void thinking()
    {
        String str = "Philosopher " + id + " is thinking";
        vector.add( this.addToObject(System.currentTimeMillis(), event , str) );
        event++;
        busy();
    }

    private void eating()
    {
        String str ="Philosopher " + id + " is hungry and is trying to pick up his chopsticks";
        vector.add( this.addToObject(System.currentTimeMillis(), event , str) );
        event++;
        busy();
        str = "Philosopher " + id + " is eating";
        this.oneToBinary(id);
        vector.add( this.addToObject(System.currentTimeMillis(), event , str) );
        event++;
        busy();
        str = "Philosopher " + id + " finished eating, and puts away his chopsticks";
        this.zeroToBinary(id);
        vector.add( this.addToObject(System.currentTimeMillis(), event , str) );
        event++;
    }

    private Object[] addToObject(long t, int i,String s ){
        Object[] o = new Object[4];
        o[3] = s;
        o[2] = i;
        o[1] = binary;
        o[0] = t;
        return o;
    }

    private void oneToBinary(int i){
        binary = binary.substring(0,i) + "1" + binary.substring(i+1);
    }

    private void zeroToBinary(int i){
        binary = binary.substring(0,i) + "0" + binary.substring(i+1);
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 10; ++i)
        {
            thinking();
            try
            {
                sem.acquire();
            } catch (InterruptedException e){}
            eating();
            sem.release();
        }
    }

    public static void main(String[] args)
    {
        final int N = 5;
        Semaphore sem = new Semaphore(N, true);
        Philosopher[] philosopher = new Philosopher[N];

        // Start the philosophers
        for (int i = 0; i < N; i++) {
          philosopher[i] = new Philosopher(i, sem);
          philosopher[i].start();
        }
        // Wait for them to finish
        for (int i = 0; i < N; i++) {
          try {
            philosopher[i].join();
          } catch(InterruptedException ex) {
            return;
          }
        }

        for (int i = 0; i < vector.size(); i++) {
            Object[] o = vector.get(i);
            System.out.printf("%d %d %s %s\n", o[0], o[2], o[1], o[3]);
        }
    }
}

Tip of the Day #2 - pointers

2010-06-08T00:13:00.000+02:00

Remember

int* ptr;
*ptr = 10;
#but
ptr = new int;
#without ampersand and dereference !!

Constant pointers, pointers to constants ?

2010-06-07T21:14:00.000+02:00

What is the difference between:

float fVar = 3.14;
const float* ptr1 = &fVar;

and:

float fVar = 3.14;
float* const ptr2 = &fVar;

? The first one is pointer to constant value, so we can't change the value of variable the pointer points to :

*ptr1 = 10;

The second one in contrary is a constant pointer to a value, and because of that we can't readdress it to point at different variable :

float fVar2;
*ptr2 = &fVar2;

Django Contrib Revealed - Flatpages

2010-06-03T01:56:00.000+02:00

Very often while creating big portals there are static pages just wasting your time to be created. Django has a solution for this problem also - the Flatpages application inside Contribution package. This application allows you to manage such static pages from django-admin, and it let's you create templates using Django's template system. How to get started ?
- Add 'django.contrib.flatpages' to INSTALLED_APPS. Also you need to have django.contrib.sites activated since flatpages depend on this package.
- Add 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware' to MIDDLEWARE_CLASSES.
This is how the flatpage model looks like :

from django.db import models
from django.contrib.sites.models import Site

class FlatPage(models.Model):
    url = models.CharField(max_length=100, db_index=True)
    title = models.CharField(max_length=200)
    content = models.TextField(blank=True)
    enable_comments = models.BooleanField()
    template_name = models.ChorField(max_length=70, blank=True)
    registration_required = models.BooleanField()
    sites = models.ManyToManyField(Site)

Okay so everything looks clear here I guess. For every flatpage we can specify either custom template, or use flatpages/default.html template (still creating the default template is also our responsibility !). Flatpage templates get a single context variable passed - flatpage, so we can use the Flatpage object's fields ie. {{ flatpage.title }}, {{ flatpage.content }}. Simple, but can spare lots of time :)

Django Contrib Revealed - Sites

2010-05-28T01:42:00.000+02:00

Ok so the first element from django.contirbution I'm goin to write here about will be Sites package. What is Sites used for and what it's all about anyway ?
Let's say you have two sites connected together and sharing one database (i.e. community portal, and news site). You're using one login and authentication system there, one folder with uploaded pictures but different views for sites and different templates.
In settings file, community site has ID of 1 and news site's ID is equal to 2. How we would now build shared News model for both sites ?

from django.db import models
from django.contrib.sites.models import Site
from django.contrib.sites.managers import currentSiteManager

class News(models.Model):
    title = models.CharField(max_length=100)
    # ...
    site = models.ForeignKey(Site)
    objects = models.Manager()
    current_site = CurrentSiteManager()

As we can see from the code, we must add a field related to Site model in our class declaration (in this example it is many-to-one relationship). We can also notice two managers. The default objects is well known to us. It just serves .objects.all() . And for the second one it's a built in manager for serving objects specific to each site. So now News.objects.all() gives us all news (for example to feeds), and News.current_site.all() will return only News from current site. One thing to remember is that if our site-related field has different name than 'site' in CurrentSiteManager we need to specify this handler :
current_site = CurrentSiteManager('site_related_field')
And now for the views :

from django.conf.import settings

def simple_view(request):
    if settings.SITE_ID == 1:
        # code here
    else:
        # code here

But as you can see it's not the cleanest solution. It would be better if we had current site stored somewhere for the future use. Also, there is no need for refering to settings each time, because every Site model has a method .get_current() :

from django.contrib.sites.models import Site

def simple_view(request):
    current_site = Site.objects.get_current()
    #here we're using one of Site models field - domain.
    if current_site.domain == 'example.com':
        #code here
    else:
        # code here

Just to finish things up. Other field of Site model is name (which returns name of current site). And if you still prefere to use settings instead of get_current method, here's the code for that :

from django.conf import settings
from django.contrib.sites.models import Site

def simple_view(request):
    current_site = Site.objects.get(id=settings.SITE_ID)
    #here we're using one of Site models field - domain.
    if current_site.id == 1:
        #code here
    else:
        # code here

Parsing string

2010-05-27T01:12:00.001+02:00

Yesterday I was checking my marks from C++ Programming subject (as it turned out, there's almost no chance I will pass it :/). Points from each lab are stored in spreadsheet, and when copied they looked like this :

"1 1 3 2 1 1 1 2 1 1 1 1 1 1 1 1,5 0,33 0,66 1 0,33 0,66 1 1 2 1 1 2 1 1 2 0,5 0,66 2 1 2 1 1 1 0 1"

Because exams are closing, I'm starting to get lazy. That's why instead of copying and summing all the values in google, I thought about using Python to parse through this string to get their sum. That's what I came up with :

#note using fsum to preserve float loss
fsum(float(n) for n in str.replace(',','.').split())

And here's second solution, since ',' is a legitimate decimal point for many people.

import locale
locale.setlocale(0,"po")
sum(map(locale.atof, s.split()))

Generic views part 1

2010-05-26T00:30:00.000+02:00

Problem with start page of your web app is most common: "Do I need to create view for index.html, just to allow loading the page ?". Well you don't. Take a look at the code below :

from django.conf.urls.defaults import *
from django.views.generic.simple import direct_to_template

urlpatterns = patterns('',
      (r'^/$', direct_to_template, { 'template': 'index.html' })
)

What is this 'direct_to_template' import ? It's django's built-in view, that allows us to load template without specifying any view for it. More to come soon...

Tip of the Day #1 - in or not ?

2010-05-25T14:28:00.000+02:00

I really love those small python's built in functions and operators. How to check if variable is in some collection ?

>>> z = x in s
>>> z
True

z will return True if x is in s. Isn't that cool or what ?

Faking URL values

2010-05-25T00:21:00.000+02:00

Let's say we have a shop, with product urls looking like this:

http://myshop.com/motorbikes/choppers
http://myshop.com/bikes/bmx
http://myshop.com/skates/aggresive

But also we have a page for top selling products:

http://myshop.com/topsellers

, that uses the same view:

def products_list(request, parent_category, child_category):

How we can avoid writing another view for top sellers, that don't send either parent_ or child_ categories in URL's ?

urlpatterns = patterns('',
    (r'^topsellers/$', views.products_list, {'parent_category': 'topsellers', 'child_category': 'topsellers'}),
    (r'^(?P\w)/(?P\w)/$', views.products_list),
)

Also I've taken request to create application for simple management of orders, stocks, warranty operations from some hospital-stuff oriented company. So generally in about two months I need to learn how to write market-ready applications in python, with generating pdf's. I'm still not sure if that was a good idea (but you know how it is when pal asks you to do him a favour - especially if he is your former boss :P ).

Don't add unnecessary Context Processors

2010-05-22T15:53:00.000+02:00

I guess we've all came across problem of using some attributes of our models in the templates. We know the solution for this : create your own context processor, add necessary values there, and voila ! We can use them across our site. But do we really always need to do this ?

Probably the most commonly used object is our User. We often need to check if the user is logged etc. But do we really have to add our user to a new Context Processor like this :

def user(request):
    if hasattr(request, 'user'):
        return {'user':request.user }
    return {}

?

Let's just take a look at our settings.py file. By default (in Django 1.2) TEMPLATE_CONTEXT_PROCESSORS variable looks like this :

TEMPLATE_CONTEXT_PROCESSORS = (
"django.contrib.auth.context_processors.auth",
"django.core.context_processors.debug",
"django.core.context_processors.i18n",
"django.core.context_processors.media",
"django.contrib.messages.context_processors.messages"
)

And looking into documentation we can find :

"user -- An auth.User instance representing the currently logged-in user (or an AnonymousUser instance, if the client isn't logged in)."

Voila again ! Orly ? Well not exactly. Yes, this gives us ability to check {{ user.username }} and check if a User is authenticated. But what if we have another Model defining our user, with additional fields (and inheriting from contrib User)? Don't panic. There's also solution concerning this fact. Let's say our extended user model is called UserProfile. Open settings.py once again and insert this line :

AUTH_PROFILE_MODULE = 'accounts.UserProfile',

where 'accounts' is the name of the app where you're storing your extended model. And now as Django Docs say :

"When a user profile model has been defined and specified in this manner, each User object will have a method -- get_profile() -- which returns the instance of the user profile model associated with that User."

Beginning C++

2010-05-20T00:28:00.000+02:00

Two solutions for counting average of x < 100 numbers.
#1

int tab100];
    int n=0;
    int number=0;
    char input[10];

    while (n++ < 100)
    {     
       cout << "Give " << n << " number : ";
       memset(input, 0x00, 10);
       cin.getline(input, 10);
       number = atoi(input);
       if (number > 0)
           tab[n-1] = number;
       else
           break;
    }
    cout << average(tab, n-1) << endl; 
    getch(); 
    return 0;

int main()
{
    const size_t COUNT = 100;
    int tab[COUNT];
    size_t n;   

    cin.tie(&cout);

    for (n = 0; n < COUNT; ++n ) {
        cout << "Give " << n+1 << " number : ";
        cin >> tab[n];

        if (!cin)
            break;
    }

    if (n > 0)
        cout << average(tab, n) << endl;
    
    getch();
    return 0;
}

Which one do you prefer ?

Python's all() function usage.

2010-05-19T09:27:00.000+02:00

Recently I've came across superb python function all(). What it does is just selecting all items,variables,objects,etc fulfilling some requirements. Usage :

all(our_requirement)

Here's my code from Django-LFS (used on purple-cow.pl website). It's a function deactivating products if they have no stocks (also using my function get_stock_amount, which simply returns stocks of product). Still in development though, gotta add some control from management panel.

def deactivate(self):
        """If there are no stocks, deactivate the product. Used in last step of checkout.
        """

        inactive = False
        
        if self.is_variant():
            prod = self.parent
            inactive = all(var.get_stock_amount() == 0 for var in prod.variants.filter(active=True))
            if inactive:
                prod.active = 0
            prod.save()
        else:
            if self.get_stock_amount() == 0:
                self.active = 0
        
            self.save()

[Python] Joining two lists in a dictionary

2010-05-19T02:42:00.000+02:00

Hello and welcome everybody.
First entry, so something pythonic for starters. Simple function for joining two lists in a dictionary. If anyone has better idea, leave a comment.


def mapper(keys, values):
  n = len(keys)
  return [dict(zip(keys, values[i:i + n]))
  for i in range(0, len(values), n)]