Jun 26, 2012

Twitter official client for Mac problem "Unauthorized" solving.

I had a problem "Unauthorized" in official twitter client for Mac.

Tried several instal/reinstall. Deleted/Downloaded again from Apple App Store. It all didn't help. They seem to change something in authentication. So I've tried deleting all the config files in ~/Library/
Main solution that helped me:
1. Switch off the client. (be sure to Close an app)
2. Delete:

3. Launch Twitter app and login from scratch.

I have revoked access this twitter client too in my https://twitter.com/settings/applications but it seem to make no effect.

Making similar actions to TweetDeck for Mac does not help. So it seems like problem is somewhere deeper. Hope it will help you solve similar issue.

Jun 25, 2012

Users, Groups and their Permissions in Django + Recipes

Django supports security models and methods out of the box. They are Group and Permission objects. Permission is m2m related to internal Django User. I helps you relay on request.user later in your code.

You often come to situations where you may need a view to be accessed only by certain group of users.  For example you have the app that has two groups of users. One can search and another one can Index files. Simplest approach is to use Groups here. 

In fact you may use permissions in case your app will have several unique users that might do some stuff. In general best approach is to use Group to specify type of users and Permission to specify the role of users in this group. So if you will have Group called 'search' and it will have permission with name, say 'search stuff'. So when you will call:
def my_view(request):    
    # ... my view actions ...    
    user_permissions = request.user.user_permissions.all()
    for p in user_permissions:
        print p
will print something like 'search stuff'. If this request user is in group 'search'. Because Django User is m2m related to Group and Permission objects. So we can create a Group full of Permissions and User within that group will have all those permissions.

Now that we had main idea in head and may think about some tasty and handy stuff for our "most used" needs.

Group required view decorator.

We have several methods/ways here. Brad Montgomery suggested that we will use user passes test decorator. In his Blog. I'll copy and modify his example a bit to use group name used in this article.
from django.contrib.auth.decorators import login_required
from django.contrib.auth.decorators import user_passes_test

@user_passes_test(lambda u: u.groups.filter(name='search').count() == 0, login_url='/myapp/denied/')
def some_view(request):    
    # Do whatever this view should do
This stuff may suite you well. BUT imho there is much tastier approach.

There is one view decorator. Django Snippets. It is called view decorator and you can use it like so:
def myview(request, id):
     # ...
And in case stuff will disappear in the net. Here is the snippet itself:

Nice and simple isn't it? If takes a grop name from the list that you provide him and checks user authorship in there.

Programmatically creating groups and users.

Note that Django docs is always the best explanation. But sometimes insufficient for new byes. 
from django.contrib.auth.decorators import user_passes_test

def group_required(*group_names):    
    """Requires user membership in at least one of the groups passed in."""    
     def in_groups(u):       
        if u.is_authenticated():            
            if bool(u.groups.filter(name__in=group_names)) | u.is_superuser:
                return True        
            return False    
    return user_passes_test(in_groups)
Let's start from adding a group. You may use groups to define roles of users.
from django.contrib.auth.models import Group, Permission

different_users = Group(name='Different Users')
outstanding_users = Group(name='Outstanding Users')
Now that we have groups set up and ready to go we can setup permissions for them. Django associates permission with model.Models object, but not it's instance. So you need to select a model to operate and  apply a content type to it. Note you may even inven your own content type for those needs.
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType

custom_ct = ContentType.objects.get(app_label='app_name',
                                    name='User Type')
can_search = Permission(name='Can Search',
can_index = Permission(name='Can Index',
We have earlier defined 2 permissions and can now apply them to groups we have created:
outstanding_users.permissions = [can_search, can_index]
Now we can use our request user to apply groups to him:
def my_view(request):
    user = request.user    
    # ... or    
Now it came to:
>>> user.has_perm('app_name.can_search_something')
>>> user.has_perm('app_name.can_index_something')

# .. or in case of second group authorship
>>> user.has_perm('app_name.can_search_something')
>>> user.has_perm('app_name.can_index_something')
You can use it wherever you like this. For e.g. in templates:
{% if perms.app_name.can_search_something %}
    Here is your search form.
{% else %}
    Nothing here. Move along!
{% endif %}

Hope some stuff here helps you like it did to me. May the code be with you! Comment me ;)

Jun 19, 2012

Pretty git Log

SO you dislike git log output in console like me and do not use it... Because it looks like so:
How about this one?

It's quite easy...
Just type:

git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --

It may be hard to enter such an easy command every time. Let's make an alias instead... Copypaste this to your terminal:

git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit --"

And use simple command to see this pretty log instead:

git lg

Now in case you want to see lines that changed use:

git lg -p
In order for this command to work remove the -- from the end of the alias.

May the code be with you!

NOTE: this article is a rewritten copy of http://coderwall.com/p/euwpig?i=3&p=1&t=git and have been put here only in purpose of note to myself.  However you may use for your own needs...

UPD2: And unless you're a contributor of the git project and have written at least part of original code and/or documentation that does this trick... Then you probably stole the idea. ;) (IMHO)

Jun 7, 2012

Python sort() patterns

Python has a lot of sorting patterns. Let's make a short a list.

1. Sorting list by it's element. Simple case. Should simply do:

>>> exmpl_list =['a', 'c', 'B', 'd']
>>> exmpl_list.sort()
['a', 'B', 'c', 'd']
However this example does not take locale into account and works only for ASCII characters.

2. Sorting list of sub elements.

exmpl_list = [{'name':'Homer', 'age':39}, {'name':'Bart', 'age':10}]  
# Sorting by 'name'  
newlist = sorted(exmpl_list, key=lambda k: k['name'])
# Better way to use itemgetter():
from operator import itemgetter
newlist = sorted(exmpl_list, key=itemgetter('name'))
Note that it is equivalent to:

exmpl_list.sort(key=lambda k: k['name'])
# OR:
if you do not need new list in result.

3. Local aware decision

import locale
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') # vary depending on your lang/locale
assert sorted((u'Ab', u'ad', u'aa'), cmp=locale.strcoll) == [u'aa', u'Ab', u'ad']

# Without using locale.strcoll you get:
assert sorted((u'Ab', u'ad', u'aa')) == [u'Ab', u'aa', u'ad']

4. Sorting list of tuples/lists by known element position:

data = [[1,2,3], [4,5,6], [7,8,9]] 
data = [(1,2,3), (4,5,6), (7,8,9)]
sorted_by_second = sorted(data, key=lambda tup: tup[1])
data.sort(key=lambda tup: tup[1])  # sorts in place

BTW. Python How To: Sorting

Jun 6, 2012

Python super() method and class inheritance

There is one more useful method in python. super()

    It helps to handle inheritance of ancestor class. This sounds a bit of messy. So I'll try to explain.

You have class A that does some useful things. And you have to use this class A everywhere in your application with adding some piece of functionality. You may inherit this class B(A) and expand it's functionality. Now you can use class B instead of class A everywhere and get rid of redundant operations.

# Main class (parent)
class A(object):
    def __init__(self):
        print(u'class A constructor')

# Main class ancestor (inheriting main class)
class B(A):
    def __init__(self):
        print(u'class B constructor')

    For live example:
    NOTE! Code is theoretical for you because it is taken from live project. I'm using many own written methods here. Neither document not it's methods are not django standard and given here to get the point of it all in real world example.
    You have Django HttpResponse() object. Your Django application creates (instantiates) this special HttpResponse() object and afterwards populates some file into it. you may often do redundancy in your code. One way: you can create a manager to instantiate HttpResponse() object from scratch and then populate it with your data. But it's making your code use some additional function that instantiates and then operates object. Better (proper from python perspective) to inherit HttpResponse() object and create your own, say DocumentResponse() object that will be in fact standard HttpResponse() that will populate itself with required data from your provided object. This will lead to code simplification.
    Let's provide some code for this object's declaration:

# Using DJango internal object
from django.http import HttpResponse

# Inheriting it and populating with our data.
class DocumentResponse(HttpResponse):
    HttpResponse() object containing file.
    def __init__(self, document):
        # our redundant actions we want to get rid...
        content = document.get_file_object()
        mimetype = document.get_mimetype()
        filename = document.get_full_filename()
        # Instantiating ancestor class HttpResponse()
        # with our special parameters.
        super(DocumentResponse, self).__init__(content=content, mimetype=mimetype)
        # Making some actions with "self" like a new ancestor class instance
        # now: self == HttpResponse() 
        self["Content-Length"] = len(content)

TADA! We have ability now to create our custom HttpResponse() from internal file object (document) everywhere in our imaginary project.
we can now write something like:

response = DocumentResponse(document)

and it will provide a proper HttpResponse() object specially transformed for our needs. Django likes it and returns properly instead of HttpResponse(). It has all of it's methods after all :).
    One more thing to note that python will not run constructor of ancestor here until we will tell him to do it with our super() method. And afterwards we can modify it too.
    Naming this method may sound syntactically "to heavy". This problem is spolved in python 3.0. However there is old implementation, sometimes called 'old school':

# Parrent
class A(object):
    def __init__(self):
        print(u'class A constructor')

# Ancestor
class B(A):
    def __init__(self):
        print(u'class B constructor')

Helped? Improper? Please leave a comment below...