Flake8

2 files changed, 164 insertions, 138 deletions

diff --git a/chimere/templatetags/chimere_tags.py b/chimere/templatetags/chimere_tags.py
index c6fe569..a5ce9c0 100644
--- a/chimere/templatetags/chimere_tags.py
+++ b/chimere/templatetags/chimere_tags.py
@@ -9,7 +9,7 @@ from django import template
 from django.conf import settings
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
-from django.db.models import Q, Count
+from django.db.models import Q
 from django.template import defaultfilters
 from django.utils.translation import ugettext as _
 from django.template.loader import render_to_string
@@ -21,6 +21,7 @@ log = getLogger(__name__)
 
 register = template.Library()
 
+
 @register.inclusion_tag('chimere/blocks/areas.html', takes_context=True)
 def display_areas(context):
     """
@@ -33,45 +34,50 @@ def display_areas(context):
         context_data['area_name'] = context["area_name"]
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/submited.html', takes_context=True)
 def submited(context):
     """
     Submited message.
     """
-    return {"edit_url":reverse('chimere:edit'),
-            "index_url":reverse('chimere:index'),
-            'contact_email':settings.CONTACT_EMAIL \
-            if hasattr(settings, 'CONTACT_EMAIL') else None}
+    return {"edit_url": reverse('chimere:edit'),
+            "index_url": reverse('chimere:index'),
+            'contact_email':
+            settings.CONTACT_EMAIL if hasattr(settings, 'CONTACT_EMAIL')
+            else None}
+
 
 def get_news(area=None):
     # Retrieve news
     news = News.objects.filter(available=True, is_front_page=True)
     if area:
-        news = news.filter(Q(areas__isnull=True)|Q(areas__in=[area.pk]))
+        news = news.filter(Q(areas__isnull=True) | Q(areas__in=[area.pk]))
     news = list(news.all())
     if settings.CHIMERE_DAYS_BEFORE_EVENT:
         # Retrieve active markers
         today = date.today()
         after = today + timedelta(settings.CHIMERE_DAYS_BEFORE_EVENT)
-        q = Marker.objects.filter(status='A', start_date__lte=after).filter(
-             Q(end_date__gte=today)|
-            (Q(end_date__isnull=True) & Q(start_date__gte=today)))
+        q = Marker.objects.filter(
+            status='A', start_date__lte=after).filter(
+                Q(end_date__gte=today) |
+                (Q(end_date__isnull=True) & Q(start_date__gte=today)))
 
-        if not 'CHIMERE_ALL_DATED_ARE_FRONT' in dir(settings)\
+        if 'CHIMERE_ALL_DATED_ARE_FRONT' not in dir(settings)\
            or not settings.CHIMERE_ALL_DATED_ARE_FRONT:
             q = q.filter(is_front_page=True)
         if area:
             q = q.filter(area.getIncludeMarker())
         news += list(q)
-    news.sort(key=lambda x:x.date)
+    news.sort(key=lambda x: x.date)
     return news
 
+
 @register.inclusion_tag('chimere/blocks/welcome.html', takes_context=True)
 def display_welcome(context, display=False, title=''):
     """
     Welcome message and active news.
     """
-    context_data = {'display':display}
+    context_data = {'display': display}
     area = None
     if "area_name" in context:
         try:
@@ -90,16 +96,17 @@ def display_welcome(context, display=False, title=''):
     context_data['news_lst'] = get_news(area)[:3]
     context_data['STATIC_URL'] = settings.STATIC_URL
     context_data['title'] = title if title \
-                            else _(u"Welcome to the %s") % settings.PROJECT_NAME
+        else _(u"Welcome to the %s") % settings.PROJECT_NAME
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/news.html', takes_context=True)
 def display_news(context, title=''):
     """
     All news.
     """
     area = None
-    context_data = {'STATIC_URL':settings.STATIC_URL}
+    context_data = {'STATIC_URL': settings.STATIC_URL}
     if "area_name" in context:
         try:
             area = Area.objects.get(urn=context["area_name"])
@@ -110,27 +117,28 @@ def display_news(context, title=''):
     context_data['news_lst'] = get_news(area)
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/head_jquery.html', takes_context=True)
 def head_jquery(context):
     """
     Create context and display head elements (js, css, etc.) for jquery.
     """
     context_data = {
-            "JQUERY_JS_URLS": settings.JQUERY_JS_URLS,
-            "JQUERY_CSS_URLS": settings.JQUERY_CSS_URLS,
-             }
+        "JQUERY_JS_URLS": settings.JQUERY_JS_URLS,
+        "JQUERY_CSS_URLS": settings.JQUERY_CSS_URLS,
+    }
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/head_jme.html', takes_context=True)
 def head_jme(context):
     """
     Create context and display head elements (js, css, etc.) for jme.
     """
-    context_data = {
-            "STATIC_URL": settings.STATIC_URL,
-             }
+    context_data = {"STATIC_URL": settings.STATIC_URL}
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/head_chimere.html', takes_context=True)
 def head_chimere(context):
     """
@@ -143,64 +151,71 @@ def head_chimere(context):
             area = Area.objects.get(urn=area_name)
         except ObjectDoesNotExist:
             pass
+    action_selected = context.get('action_selected', None)
+    is_edit = action_selected and action_selected[0] == "contribute"
     context_data = {
-            "STATIC_URL": settings.STATIC_URL,
-            "MEDIA_URL": settings.MEDIA_URL,
-            "DYNAMIC_CATEGORIES": 'true' if area and area.dynamic_categories \
-                                  else 'false',
-            "EXTRA_URL": reverse("chimere:index"),
-            "EPSG_DISPLAY_PROJECTION": settings.CHIMERE_EPSG_DISPLAY_PROJECTION,
-            "EPSG_PROJECTION": settings.CHIMERE_EPSG_PROJECTION,
-            "DEFAULT_CENTER": settings.CHIMERE_DEFAULT_CENTER,
-            "DEFAULT_ZOOM": settings.CHIMERE_DEFAULT_ZOOM,
-            "MAP_LAYER": settings.CHIMERE_DEFAULT_MAP_LAYER,
-            "MAP_CSS_URLS": settings.MAP_CSS_URLS,
-            'MOBILE':context['MOBILE'],
-            'routing': settings.CHIMERE_ENABLE_ROUTING \
-                      if hasattr(settings, 'CHIMERE_ENABLE_ROUTING') else False,
-            'enable_clustering':settings.CHIMERE_ENABLE_CLUSTERING,
-            }
+        "is_edit": is_edit,
+        "STATIC_URL": settings.STATIC_URL,
+        "MEDIA_URL": settings.MEDIA_URL,
+        "DYNAMIC_CATEGORIES": 'true' if area and area.dynamic_categories
+                              else 'false',
+        "EXTRA_URL": reverse("chimere:index"),
+        "EPSG_DISPLAY_PROJECTION": settings.CHIMERE_EPSG_DISPLAY_PROJECTION,
+        "EPSG_PROJECTION": settings.CHIMERE_EPSG_PROJECTION,
+        "DEFAULT_CENTER": settings.CHIMERE_DEFAULT_CENTER,
+        "DEFAULT_ZOOM": settings.CHIMERE_DEFAULT_ZOOM,
+        "MAP_LAYER": settings.CHIMERE_DEFAULT_MAP_LAYER,
+        "MAP_CSS_URLS": settings.MAP_CSS_URLS,
+        'MOBILE': context['MOBILE'],
+        'routing':
+            settings.CHIMERE_ENABLE_ROUTING
+            if hasattr(settings, 'CHIMERE_ENABLE_ROUTING') else False,
+        'enable_clustering': settings.CHIMERE_ENABLE_CLUSTERING,
+    }
     context_data['MAP_JS_URLS'] = settings.MAP_JS_URLS
     if context['MOBILE']:
         context_data['MAP_JS_URLS'] = settings.MAP_MOBILE_JS_URLS
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/head_form.html')
 def head_form():
     """
     Manualy add forms header (necessary in case of ajax load)
     """
-    context_data = {
-            "TINYMCE_URL": settings.TINYMCE_URL,
-             }
+    context_data = {"TINYMCE_URL": settings.TINYMCE_URL}
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/map_menu.html', takes_context=True)
 def map_menu(context):
-    context_data =  {'routing': settings.CHIMERE_ENABLE_ROUTING \
-                     if hasattr(settings, 'CHIMERE_ENABLE_ROUTING') else False,
-                     'simple':context.get('simple')}
+    context_data = {
+        'routing': settings.CHIMERE_ENABLE_ROUTING
+        if hasattr(settings, 'CHIMERE_ENABLE_ROUTING') else False,
+        'simple': context.get('simple')}
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/routing.html', takes_context=True)
 def routing(context):
     if not hasattr(settings, 'CHIMERE_ENABLE_ROUTING') or \
        not settings.CHIMERE_ENABLE_ROUTING:
-        return {'routing':False}
-    context_data =  {
-         'routing':settings.CHIMERE_ENABLE_ROUTING,
-         'itinerary_form':context['itinerary_form'],
-         'routing_fail_message':_(settings.CHIMERE_ROUTING_FAIL_MESSAGE
-                                ).replace('\n', '\\n'),
-         'routing_transport':context['routing_transport']}
+        return {'routing': False}
+    context_data = {
+        'routing': settings.CHIMERE_ENABLE_ROUTING,
+        'itinerary_form': context['itinerary_form'],
+        'routing_fail_message':
+        _(settings.CHIMERE_ROUTING_FAIL_MESSAGE).replace('\n', '\\n'),
+        'routing_transport': context['routing_transport']}
     context_data['STATIC_URL'] = settings.STATIC_URL
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/map.html', takes_context=True)
 def map(context, map_id='map'):
-    context_data =  {'map_id':map_id,
-                     "STATIC_URL": settings.STATIC_URL,
-                     "enable_clustering":settings.CHIMERE_ENABLE_CLUSTERING}
+    context_data = {'map_id': map_id,
+                    "STATIC_URL": settings.STATIC_URL,
+                    "enable_clustering": settings.CHIMERE_ENABLE_CLUSTERING}
     context_data['icon_offset_x'] = settings.CHIMERE_ICON_OFFSET_X
     context_data['icon_offset_y'] = settings.CHIMERE_ICON_OFFSET_Y
     context_data['icon_width'] = settings.CHIMERE_ICON_WIDTH
@@ -208,12 +223,12 @@ def map(context, map_id='map'):
     context_data['MOBILE'] = context['MOBILE']
     context_data['routing'] = 'true' \
         if hasattr(settings, 'CHIMERE_ENABLE_ROUTING') and \
-           settings.CHIMERE_ENABLE_ROUTING \
+        settings.CHIMERE_ENABLE_ROUTING \
         else 'false'
     area_name = context['area_name'] if 'area_name' in context else 'area_name'
     map_layers, default_area = get_map_layers(area_name)
     context_data['js_map_layers'] = ", ".join(
-                                      [js for name, js, default in map_layers])
+        [js for name, js, default in map_layers])
     context_data['map_layers'] = map_layers
     if default_area:
         context_data['selected_map_layer'] = default_area
@@ -244,15 +259,15 @@ def map(context, map_id='map'):
             context_data['single_category'] = True
             context_data['checked_categories'] = area.subcategories.all()[0].pk
         elif area.default_subcategories.count():
-            context_data['checked_categories'] = [s.pk
-                                      for s in area.default_subcategories.all()]
+            context_data['checked_categories'] = [
+                s.pk for s in area.default_subcategories.all()]
         if area.restrict_to_extent:
-            context_data['restricted_extent'] = """
-var bounds = new OpenLayers.Bounds();
-bounds.extend(new OpenLayers.LonLat(%f, %f));
-bounds.extend(new OpenLayers.LonLat(%f, %f));
-""" % (area.upper_left_corner.x, area.upper_left_corner.y,
-       area.lower_right_corner.x, area.lower_right_corner.y)
+            context_data['restricted_extent'] = \
+                "var bounds = new OpenLayers.Bounds();\n"\
+                "bounds.extend(new OpenLayers.LonLat(%f, %f));\n"\
+                "bounds.extend(new OpenLayers.LonLat(%f, %f));\n" % (
+                area.upper_left_corner.x, area.upper_left_corner.y,
+                area.lower_right_corner.x, area.lower_right_corner.y)
     context_data['subcat_layer'], c_cat = [], None
     for subcat in subcat_layer.order_by('category__order', 'category').all():
         if subcat.category != c_cat:
@@ -267,15 +282,17 @@ bounds.extend(new OpenLayers.LonLat(%f, %f));
                 cat = unicode(SubCategory.objects.filter(available=True
                                                          ).all()[0].pk)
             context_data['checked_categories'] = cat
-    context_data['dynamic_categories'] = 'true' \
-                            if area and area.dynamic_categories else 'false'
+    context_data['dynamic_categories'] = \
+        'true' if area and area.dynamic_categories else 'false'
     if settings.CHIMERE_ROUTING_TRANSPORT:
-        context_data['p_routing_transport'] = settings.CHIMERE_ROUTING_TRANSPORT[0][0]
+        context_data['p_routing_transport'] = \
+            settings.CHIMERE_ROUTING_TRANSPORT[0][0]
         if settings.CHIMERE_ROUTING_SPEEDS and \
-           context_data['p_routing_transport'] in settings.CHIMERE_ROUTING_SPEEDS:
+           context_data['p_routing_transport'] \
+           in settings.CHIMERE_ROUTING_SPEEDS:
             context_data['p_routing_speed'] = \
                 settings.CHIMERE_ROUTING_SPEEDS[
-                                    context_data['p_routing_transport']][0][0]
+                    context_data['p_routing_transport']][0][0]
     if 'request' not in context:
         return context_data
     request = context['request']
@@ -283,31 +300,34 @@ bounds.extend(new OpenLayers.LonLat(%f, %f));
     context_data['p_current_route'] = context.get('current_route')
     if request.GET:
         for key in ('zoom', 'lon', 'lat', 'display_submited',
-                    'current_feature', 'routing_start_lon', 'routing_start_lat',
-                    'routing_end_lon', 'routing_end_lat', 'routing_steps',
-                    'routing_transport', 'routing_speed'):
+                    'current_feature', 'routing_start_lon',
+                    'routing_start_lat', 'routing_end_lon', 'routing_end_lat',
+                    'routing_steps', 'routing_transport', 'routing_speed'):
             p_key = 'p_' + key
             if key in request.GET and request.GET[key]:
                 context_data[p_key] = request.GET[key]
             elif p_key not in context_data:
-                context_data['p_'+key] = None
+                context_data['p_' + key] = None
         if 'checked_categories' in request.GET \
            and request.GET['checked_categories']:
             cats = request.GET['checked_categories'].split('_')
             context_data['checked_categories'] = cats
     return context_data
 
+
 @register.inclusion_tag('chimere/blocks/multimedia_file.html',
                         takes_context=True)
 def multimedia_render(context, multimedia_file):
     context['multimedia_item'] = multimedia_file
     return context
 
+
 @register.inclusion_tag('chimere/blocks/alternate_multimedia.html')
 def alternate_multimedia(formset_multi, formset_picture):
-    return {'formsets':[formset_multi, formset_picture],
+    return {'formsets': [formset_multi, formset_picture],
             "STATIC_URL": settings.STATIC_URL,
-            'auto_type_id':MultimediaType.objects.get(name='auto').pk}
+            'auto_type_id': MultimediaType.objects.get(name='auto').pk}
+
 
 @register.simple_tag
 def get_tinyfied_url(marker, area_name=''):
@@ -316,6 +336,7 @@ def get_tinyfied_url(marker, area_name=''):
     url = marker.get_absolute_url(area_name)
     return url
 
+
 @register.inclusion_tag('chimere/blocks/share_bar.html',
                         takes_context=True)
 def share_bar(context, name='', email_only=False, rss=True):
@@ -323,17 +344,19 @@ def share_bar(context, name='', email_only=False, rss=True):
     context['name'] = name
     context['rss'] = rss
     context['email_only'] = email_only
-    context['share_networks'] = [(defaultfilters.slugify(name), url, icon)
-                for name, url, icon in settings.CHIMERE_SHARE_NETWORKS]
+    context['share_networks'] = [
+        (defaultfilters.slugify(nme), url, icon)
+        for nme, url, icon in settings.CHIMERE_SHARE_NETWORKS]
     return context
 
+
 @register.filter(name='ol_map')
 def ol_map(item, arg='map_id'):
-    geom, geom_type = None, None
+    geom = None
     if hasattr(item, 'point'):
-        geom, geom_type = item.point, 'point'
+        geom = item.point
     elif hasattr(item, 'route'):
-        geom, geom_type = item.route, 'route'
+        geom = item.route
     rendered = render_to_string('chimere/blocks/ol_map.html', {'geom': geom,
-                                                               'map_id':arg})
+                                                               'map_id': arg})
     return rendered
diff --git a/chimere/views.py b/chimere/views.py
index 88619ce..562688d 100644
--- a/chimere/views.py
+++ b/chimere/views.py
@@ -27,20 +27,18 @@ Views of the project
 import datetime
 from itertools import groupby
 import re
-import simplejson as json
 
 from django.conf import settings
 from django.contrib.gis.geos import GEOSGeometry
 from django.contrib.gis.gdal.error import OGRException
 from django.contrib.gis.measure import D
 from django.contrib.sites.models import get_current_site
-from django.core import serializers
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 from django.db.models import Q
 from django.http import HttpResponseRedirect, HttpResponse, Http404
 from django.shortcuts import get_object_or_404, redirect, render_to_response
-from django.template import loader, RequestContext, defaultfilters
+from django.template import RequestContext, defaultfilters
 from django.utils import simplejson as json
 from django.utils.http import urlquote
 from django.utils.translation import ugettext as _
@@ -48,14 +46,13 @@ from django.views.generic import TemplateView, ListView
 
 from chimere.actions import actions
 from chimere.models import Category, SubCategory, PropertyModel, Page,\
-     Marker, Route, News, SimpleArea, Area, Color, TinyUrl, RouteFile,\
-     AggregatedRoute
+    Marker, Route, SimpleArea, Area, Color, TinyUrl, RouteFile,\
+    AggregatedRoute
 
-from chimere.widgets import getMapJS, PointChooserWidget, \
-                            RouteChooserWidget, AreaWidget
+from chimere.widgets import PointChooserWidget, RouteChooserWidget, AreaWidget
 from chimere.forms import MarkerForm, RouteForm, ContactForm, FileForm, \
-     FullFileForm, MultimediaFileFormSet, PictureFileFormSet, notifySubmission,\
-     notifyStaff, AreaForm, RoutingForm, getStaffEmails
+    FullFileForm, MultimediaFileFormSet, PictureFileFormSet, notifySubmission,\
+    notifyStaff, AreaForm, RoutingForm
 
 from chimere.route import router
 
@@ -333,10 +330,10 @@ def edit(request, area_name="", item_id=None, submited=False):
     if request.POST and request.POST.get('point'):
         point_value = request.POST.get('point')
     response_dct.update({
-        'actions':actions(response_dct['area_name']),
-        'action_selected':('contribute', 'edit'),
-        'map_layer':settings.CHIMERE_DEFAULT_MAP_LAYER,
-        'form':form,
+        'actions': actions(response_dct['area_name']),
+        'action_selected': ('contribute', 'edit'),
+        'map_layer': settings.CHIMERE_DEFAULT_MAP_LAYER,
+        'form': form,
         'formset_multi':formset_multi,
         'formset_picture':formset_picture,
         'dated':settings.CHIMERE_DAYS_BEFORE_EVENT,
@@ -935,10 +932,10 @@ def route(request, area_name, lon1, lat1, lonlat_steps, lon2, lat2,
                 message = ''
     data = '{"properties":{"transport":%s, "total":%s, "description":%s}, '\
            '"type": "FeatureCollection", "features":[%s]%s}' % (
-            jsonencoder.encode(transport), total, desc, ",".join(jsons),
-            message)
+        jsonencoder.encode(transport), total, desc, ",".join(jsons), message)
     return HttpResponse(data)
 
+
 def rss(request, area_name=''):
     '''
     Redirect to RSS subscription page
@@ -946,15 +943,15 @@ def rss(request, area_name=''):
     response_dct, redir = get_base_response(request, area_name)
     if redir:
         return redir
-    response_dct.update({'actions':actions(response_dct['area_name']),
-                         'action_selected':('rss',),
-                         'category_rss_feed':'',})
+    response_dct.update({'actions': actions(response_dct['area_name']),
+                         'action_selected': ('rss',),
+                         'category_rss_feed': ''})
     # If the form has been submited
     if request.method == "POST":
         # User has defined the kind of POI he is interested in : POI in a area
         # (GET method is used for the link with RSS icon in the browser)
         if 'rss_category' in request.POST:
-            #User wants to follow all the new POI
+            # User wants to follow all the new POI
             if request.POST['rss_category'] == 'global':
                 feeds_link = reverse('chimere:feeds-global')
                 return redirect(feeds_link)
@@ -962,59 +959,60 @@ def rss(request, area_name=''):
             elif request.POST['rss_category'] == 'poi':
                 response_dct['category_rss_feed'] = 'category'
                 response_dct['sub_categories'] = SubCategory.getAvailable()
-                return render_to_response('chimere/feeds/rss.html',
-                                  response_dct,
-                                  context_instance=RequestContext(request))
+                return render_to_response(
+                    'chimere/feeds/rss.html', response_dct,
+                    context_instance=RequestContext(request))
             # User wants to follow all the new POI situated in a defined area
             elif request.POST['rss_category'] == 'area':
                 # An unbound form
                 form = AreaForm()
                 area_widget = AreaWidget().render('area', None)
                 response_dct.update({
-                    'map_layer':settings.CHIMERE_DEFAULT_MAP_LAYER,
-                    'extra_head':form.media,
-                    'form':form,
-                    'category_rss_feed':'area',
-                    'area_id':Area.getAvailable(),
-                    'area_widget':area_widget
+                    'map_layer': settings.CHIMERE_DEFAULT_MAP_LAYER,
+                    'extra_head': form.media,
+                    'form': form,
+                    'category_rss_feed': 'area',
+                    'area_id': Area.getAvailable(),
+                    'area_widget': area_widget
                 })
-                return render_to_response('chimere/feeds/rss.html',
-                                  response_dct,
-                                  context_instance=RequestContext(request))
+                return render_to_response(
+                    'chimere/feeds/rss.html', response_dct,
+                    context_instance=RequestContext(request))
             # Error when submitting the form
             else:
                 error = _("Incorrect choice in the list")
-                response_dct.update({'error_message':error,
-                    'category_rss_feed':'',
-                    'sub_categories':SubCategory.getAvailable()})
-                return render_to_response('chimere/feeds/rss.html',
-                                  response_dct,
-                                  context_instance=RequestContext(request))
+                response_dct.update({
+                    'error_message':error,
+                    'category_rss_feed': '',
+                    'sub_categories': SubCategory.getAvailable()})
+                return render_to_response(
+                    'chimere/feeds/rss.html', response_dct,
+                    context_instance=RequestContext(request))
 
         # User has specified the category or subcategory he wants to follow =>
         # we redirect him towards the related rss feed
         if 'subcategory' in request.POST and request.POST['subcategory'] != '':
             cat_id = request.POST['subcategory']
-            if cat_id.find("cat_") != -1 :
+            if cat_id.find("cat_") != -1:
                 cat_id = cat_id.split('_')[1]
                 feeds_link = reverse('chimere:feeds-cat',
-                                     kwargs={'category_id':cat_id})
+                                     kwargs={'category_id': cat_id})
                 return redirect(feeds_link)
 
             else:
                 feeds_link = reverse('chimere:feeds-subcat',
-                                     kwargs={'category_id':cat_id})
+                                     kwargs={'category_id': cat_id})
                 return redirect(feeds_link)
 
         # User has specified the ID of the area he wants to follow
         if 'id_area' in request.POST and request.POST['id_area'] != '':
             feeds_link = reverse('chimere:feeds-areaid',
-                                 kwargs={'area_id':request.POST['id_area']})
+                                 kwargs={'area_id': request.POST['id_area']})
             return redirect(feeds_link)
 
         # User has specified the area  he wants to follow => we redirect him
         # towards the related rss feed (using upper left and lower right
-        # coordinates)
+        # coordinates)
         elif 'upper_left_lat' in request.POST and \
              request.POST['upper_left_lat'] != '' and \
              'upper_left_lon' in request.POST and \
@@ -1022,13 +1020,13 @@ def rss(request, area_name=''):
              'lower_right_lon' in request.POST and \
              request.POST['lower_right_lon'] != '' and \
              'lower_right_lat' in request.POST and \
-             request.POST['lower_right_lat'] != '' :
+             request.POST['lower_right_lat'] != '':
             coords = request.POST['upper_left_lat'] + '_' + \
-                     request.POST['upper_left_lon'] + '_' + \
-                     request.POST['lower_right_lat'] + '_' + \
-                     request.POST['lower_right_lon']
+                request.POST['upper_left_lon'] + '_' + \
+                request.POST['lower_right_lat'] + '_' + \
+                request.POST['lower_right_lon']
             feeds_link = reverse('chimere:feeds-area',
-                                 kwargs={'area':coords})
+                                 kwargs={'area': coords})
             return redirect(feeds_link)
 
     # GET method is used for linking with the RSS icon in the browser when user
@@ -1039,18 +1037,20 @@ def rss(request, area_name=''):
             return redirect(feeds_link)
         if request.GET['rss_category'] == 'poi':
             response_dct['category_rss_feed'] = 'category'
-            response_dct['sub_categories'] = SubCategory.getAvailable(['M','B'])
+            response_dct['sub_categories'] = SubCategory.getAvailable(
+                ['M', 'B'])
             return render_to_response('chimere/feeds/rss.html', response_dct,
                                       context_instance=RequestContext(request))
         if request.GET['rss_category'] == 'area':
             # An unbound form
             form = AreaForm()
-            response_dct.update({'map_layer':settings.MAP_LAYER,
-                            'extra_head':form.media,
-                            'form':form,
-                            'category_rss_feed':'area',
-                            'area_id':Area.getAvailable(),
-                            'area_widget':AreaWidget().render('area', None)})
+            response_dct.update({
+                'map_layer': settings.MAP_LAYER,
+                'extra_head': form.media,
+                'form': form,
+                'category_rss_feed': 'area',
+                'area_id': Area.getAvailable(),
+                'area_widget': AreaWidget().render('area', None)})
             return render_to_response('chimere/feeds/rss.html', response_dct,
                                       context_instance=RequestContext(request))
 
@@ -1067,25 +1067,28 @@ if hasattr(settings, 'CHIMERE_SEARCH_ENGINE') \
    and settings.CHIMERE_SEARCH_ENGINE:
     from haystack.views import SearchView as HaystackSearchView
     from haystack.query import SearchQuerySet
+
     class SearchView(HaystackSearchView):
         def extra_context(self, *args, **kwargs):
             context = super(SearchView, self).extra_context(*args, **kwargs)
-            context["autocomplete"] = settings.HAYSTACK_AUTOCOMPLETE \
-                    if hasattr(settings, 'HAYSTACK_AUTOCOMPLETE') else False
+            context["autocomplete"] = \
+                settings.HAYSTACK_AUTOCOMPLETE \
+                if hasattr(settings, 'HAYSTACK_AUTOCOMPLETE') else False
             return context
+
     def autocomplete(request):
         sqs = SearchQuerySet().autocomplete(
-                                content_auto=request.GET.get('q', ''))[:5]
+            content_auto=request.GET.get('q', ''))[:5]
         suggestions = [result.object.name for result in sqs if result.object]
         spelling = []
         if not suggestions:
             spelling = SearchQuerySet().spelling_suggestion(
-                                            request.GET.get('q', '')) or []
+                request.GET.get('q', '')) or []
             # convert to list spelling...
         # make sure it returns a JSON object, not a bare list.
         # otherwise, it could be vulnerable to an XSS attack.
         the_data = json.dumps({
             'results': suggestions,
-            'spelling':spelling,
+            'spelling': spelling,
         })
         return HttpResponse(the_data, content_type='application/json')