root/trunk/djedna/catalog/util.py

# (c) Copyright 2008 Thomas Bohmbach, Jr.
# 
# This file is part of DJ Edna.
# 
# DJ Edna is free software: you can redistribute it and/or modify it under the
# terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
# 
# DJ Edna is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
# more details.
# 
# You should have received a copy of the GNU General Public License along with
# DJ Edna.  If not, see <http://www.gnu.org/licenses/>.

import os, math, md5, operator, pickle, sys
import logging as log

from django.conf import settings
from django.utils.encoding import smart_str, smart_unicode


def is_music_file(filename):
    root, ext = os.path.splitext(filename)
    # if we have a valid root and ext is an audio file ext, we'll assume this is a music file
    if len(root) > 0 and root[0] != '.' and ext[1:] in settings.AUDIO_FILE_EXTENSIONS:
        return True
    return False

def is_same_image(first_image, second_image, tolerance=settings.IMAGE_MATCH_TOLERANCE):
    return get_images_rms(first_image, second_image) < tolerance

def get_images_rms(first_image, second_image):
    h1 = first_image.histogram()
    h2 = second_image.histogram()
    rms = math.sqrt(reduce(operator.add, map(lambda a,b: (a-b)**2, h1, h2))/len(h1))
    return rms
   
####
#   Display names
####
display_name_saved_dict = None   

def find_display_name(name):
    # first, see if we have a previously saved display name
    display_name = display_name_from_saved(name)
    
    # otherwise, try to calculate it
    if not display_name:
        display_name = display_name_from_name(name)
        
    return display_name

def set_display_name(name, display_name):
    global display_name_saved_dict
    is_dict_modified = False
 
    ensure_display_name_saved_dict_loaded()

    # first let's see what we'd get if we calculated this display name
    calc_display_name = display_name_from_name(name)
    
    # if the calculated name is the same as the passed display name, we don't need to save it
    if calc_display_name == display_name:
        # we should remove it from the dict if it's there
        if name in display_name_saved_dict:
            del display_name_saved_dict[name]
            is_dict_modified = True
    else:
        # if this doesn't match what we already have in the dict, then let's save it
        if name not in display_name_saved_dict or display_name != display_name_saved_dict[name]:
            display_name_saved_dict[name] = display_name
            is_dict_modified = True
            
    if is_dict_modified:
        try:
            display_name_file = open(settings.DISPLAY_NAME_DICTIONARY_FILE, mode='w')
            pickle.dump(display_name_saved_dict, display_name_file, pickle.HIGHEST_PROTOCOL)
            display_name_file.close()
        except Exception, e:
            log.error(u'Error pickling display name dictionary: %s' % smart_unicode(e, errors='replace'))
    
display_name_english_articles = ['the', 'a', 'an']
display_name_spanish_articles = ['el', 'la', 'los', 'las', 'un', 'una', 'unos', 'unas'] 
display_name_articles = display_name_english_articles + display_name_spanish_articles
def display_name_from_name(name):
    display_name = ''
    remaining = name
    
    # look for commas in name
    comma_list = remaining.split(',', 1)
    while len(comma_list) > 1:
        # if post comma portion is an article, move it to the front and we're done (no more commas)
        if comma_list[1].strip().lower() in display_name_articles:
            if display_name:
                display_name = ' '.join((comma_list[1].strip(), display_name.strip(), comma_list[0].strip())).strip()
            else:
                display_name = ' '.join((comma_list[1].strip(), comma_list[0].strip())).strip()
            return display_name
        else:
            # otherwise, we swap the words before and after the comma and then continue checking the rest
            pre_comma_list = comma_list[0].strip().split(' ')
            post_comma_list = comma_list[1].strip().split(' ')
            
            display_name_list = [display_name.strip()]      
            display_name_list.extend(pre_comma_list[:-1])   # add all but word before comma
            display_name_list.append(post_comma_list[0])    # add word after comma
            display_name_list.extend(pre_comma_list[-1:])   # add word before comma
            display_name = ' '.join(display_name_list).strip()
            
            remaining = ' '.join(post_comma_list[1:]).strip()   # remain is all after comma except first word
                        
        comma_list = remaining.split(',', 1)
        
    display_name = ' '.join((display_name, comma_list[0].strip())).strip()
    
    return display_name

def display_name_from_saved(name):
    global display_name_saved_dict
    
    ensure_display_name_saved_dict_loaded()
            
    # if this name has a previously saved display name, return it
    if name in display_name_saved_dict:
        return display_name_saved_dict[name]
    
    # nope, return empty string
    return ''

def ensure_display_name_saved_dict_loaded():
    global display_name_saved_dict
    
    # if this is our first time through, load dict
    if display_name_saved_dict == None:
        try:
            display_name_file = open(settings.DISPLAY_NAME_DICTIONARY_FILE)
            display_name_saved_dict = pickle.load(display_name_file)
            display_name_file.close()
        except Exception, e:
            log.error(u'Error unpickling display name dictionary: %s' % smart_unicode(e, errors='replace'))
            if display_name_saved_dict == None:
                display_name_saved_dict = {}

def make_secret_key():
    from random import choice
    secret_key = ''.join([choice('abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)') for i in range(50)])
    return secret_key

####
# security token
####
def get_usertoken(user, object_id):
    usertoken = md5.new()
    usertoken.update(settings.SECRET_KEY)
    usertoken.update(smart_str(user.id, errors='ignore'))
    usertoken.update(user.password)
    usertoken.update(smart_str(object_id, errors='ignore'))
    return usertoken.hexdigest()
def check_usertoken(user, object_id, usertoken):
    return usertoken == get_usertoken(user, object_id)

def splitall(path):
    allparts = []
    while 1:
        parts = os.path.split(path)
        if parts[0] == path:
            allparts.insert(0, parts[0])
            break
        elif parts[1] == path:
            allparts.insert(0, parts[1])
            break
        else:
            path = parts[0]
            allparts.insert(0, parts[1])
    return allparts