included changes by Adolfo and Chaitanya and found temporary fix for languages

3 files changed, 229 insertions, 229 deletions

diff --git a/utils/cache.py b/utils/cache.py
index bc1cb1af..410c0662 100644
--- a/utils/cache.py
+++ b/utils/cache.py
@@ -1,92 +1,92 @@
-"""Utilities for working with Django Models."""

-import itertools

-

-from django.contrib.contenttypes.models import ContentType

-

-from lanai.utils.lists import flatten

-

-def fetch_model_dict(model, ids, fields=None):

-    """

-    Fetches a dict of model details for model instances with the given

-    ids, keyed by their id.

-

-    If a fields list is given, a dict of details will be retrieved for

-    each model, otherwise complete model instances will be retrieved.

-

-    Any fields list given shouldn't contain the primary key attribute for

-    the model, as this can be determined from its Options.

-    """

-    if fields is None:

-        return model._default_manager.in_bulk(ids)

-    else:

-        id_attr = model._meta.pk.attname

-        return dict((obj[id_attr], obj) for obj

-            in model._default_manager.filter(id__in=ids).values(

-                *itertools.chain((id_attr,), fields)))

-

-def populate_foreign_key_caches(model, objects_to_populate, fields=None):

-    """

-    Populates caches for the given related Model in instances of objects

-    which have a ForeignKey relationship to it, specified as a list of

-    (object list, related attribute name list) two-tuples.

-

-    If a list of field names is given, only the given fields will be

-    looked up and related object caches will be populated with a dict of

-    the specified fields. Otherwise, complete model instances will be

-    retrieved.

-    """

-    # Get all related object ids for the appropriate fields

-    related_object_ids = []

-    for objects, attrs in objects_to_populate:

-        related_object_ids.append(tuple(tuple(getattr(obj, '%s_id' % attr)

-                                              for attr in attrs)

-                                  for obj in objects))

-    unique_ids = tuple(set(pk for pk in flatten(related_object_ids) if pk))

-    related_objects = fetch_model_dict(model, unique_ids, fields)

-

-    # Fill related object caches

-    for (objects, attrs), related_ids in itertools.izip(objects_to_populate,

-                                                        related_object_ids):

-        for obj, related_ids_for_obj in itertools.izip(objects,

-                                                       related_ids):

-            for attr, related_object in itertools.izip(attrs, (related_objects.get(pk, None)

-                                                               for pk in related_ids_for_obj)):

-                setattr(obj, '_%s_cache' % attr, related_object)

-

-def populate_content_object_caches(generic_related_objects, model_fields=None):

-    """

-    Retrieves ``ContentType`` and content objects for the given list of

-    items which use a generic relation, grouping the retrieval of content

-    objects by model to reduce the number of queries executed.

-

-    This results in ``number_of_content_types + 1`` queries rather than

-    the ``number_of_generic_reL_objects * 2`` queries you'd get by

-    iterating over the list and accessing each item's object attribute.

-

-    If a dict mapping model classes to field names is given, only the

-    given fields will be looked up for each model specified and the

-    object cache will be populated with a dict of the specified fields.

-    Otherwise, complete model instances will be retrieved.

-    """

-    if model_fields is None:

-        model_fields = {}

-

-    # Group content object ids by their content type ids

-    ids_by_content_type = {}

-    for obj in generic_related_objects:

-        ids_by_content_type.setdefault(obj.content_type_id,

-                                       []).append(obj.object_id)

-

-    # Retrieve content types and content objects in bulk

-    content_types = ContentType.objects.in_bulk(ids_by_content_type.keys())

-    for content_type_id, ids in ids_by_content_type.iteritems():

-        model = content_types[content_type_id].model_class()

-        objects[content_type_id] = fetch_model_dict(

-            model, tuple(set(ids)), model_fields.get(model, None))

-

-    # Set content types and content objects in the appropriate cache

-    # attributes, so accessing the 'content_type' and 'object' attributes

-    # on each object won't result in further database hits.

-    for obj in generic_related_objects:

-        obj._object_cache = objects[obj.content_type_id][obj.object_id]

-        obj._content_type_cache = content_types[obj.content_type_id]

+"""Utilities for working with Django Models."""
+import itertools
+
+from django.contrib.contenttypes.models import ContentType
+
+from lanai.utils.lists import flatten
+
+def fetch_model_dict(model, ids, fields=None):
+    """
+    Fetches a dict of model details for model instances with the given
+    ids, keyed by their id.
+
+    If a fields list is given, a dict of details will be retrieved for
+    each model, otherwise complete model instances will be retrieved.
+
+    Any fields list given shouldn't contain the primary key attribute for
+    the model, as this can be determined from its Options.
+    """
+    if fields is None:
+        return model._default_manager.in_bulk(ids)
+    else:
+        id_attr = model._meta.pk.attname
+        return dict((obj[id_attr], obj) for obj
+            in model._default_manager.filter(id__in=ids).values(
+                *itertools.chain((id_attr,), fields)))
+
+def populate_foreign_key_caches(model, objects_to_populate, fields=None):
+    """
+    Populates caches for the given related Model in instances of objects
+    which have a ForeignKey relationship to it, specified as a list of
+    (object list, related attribute name list) two-tuples.
+
+    If a list of field names is given, only the given fields will be
+    looked up and related object caches will be populated with a dict of
+    the specified fields. Otherwise, complete model instances will be
+    retrieved.
+    """
+    # Get all related object ids for the appropriate fields
+    related_object_ids = []
+    for objects, attrs in objects_to_populate:
+        related_object_ids.append(tuple(tuple(getattr(obj, '%s_id' % attr)
+                                              for attr in attrs)
+                                  for obj in objects))
+    unique_ids = tuple(set(pk for pk in flatten(related_object_ids) if pk))
+    related_objects = fetch_model_dict(model, unique_ids, fields)
+
+    # Fill related object caches
+    for (objects, attrs), related_ids in itertools.izip(objects_to_populate,
+                                                        related_object_ids):
+        for obj, related_ids_for_obj in itertools.izip(objects,
+                                                       related_ids):
+            for attr, related_object in itertools.izip(attrs, (related_objects.get(pk, None)
+                                                               for pk in related_ids_for_obj)):
+                setattr(obj, '_%s_cache' % attr, related_object)
+
+def populate_content_object_caches(generic_related_objects, model_fields=None):
+    """
+    Retrieves ``ContentType`` and content objects for the given list of
+    items which use a generic relation, grouping the retrieval of content
+    objects by model to reduce the number of queries executed.
+
+    This results in ``number_of_content_types + 1`` queries rather than
+    the ``number_of_generic_reL_objects * 2`` queries you'd get by
+    iterating over the list and accessing each item's object attribute.
+
+    If a dict mapping model classes to field names is given, only the
+    given fields will be looked up for each model specified and the
+    object cache will be populated with a dict of the specified fields.
+    Otherwise, complete model instances will be retrieved.
+    """
+    if model_fields is None:
+        model_fields = {}
+
+    # Group content object ids by their content type ids
+    ids_by_content_type = {}
+    for obj in generic_related_objects:
+        ids_by_content_type.setdefault(obj.content_type_id,
+                                       []).append(obj.object_id)
+
+    # Retrieve content types and content objects in bulk
+    content_types = ContentType.objects.in_bulk(ids_by_content_type.keys())
+    for content_type_id, ids in ids_by_content_type.iteritems():
+        model = content_types[content_type_id].model_class()
+        objects[content_type_id] = fetch_model_dict(
+            model, tuple(set(ids)), model_fields.get(model, None))
+
+    # Set content types and content objects in the appropriate cache
+    # attributes, so accessing the 'content_type' and 'object' attributes
+    # on each object won't result in further database hits.
+    for obj in generic_related_objects:
+        obj._object_cache = objects[obj.content_type_id][obj.object_id]
+        obj._content_type_cache = content_types[obj.content_type_id]
diff --git a/utils/html.py b/utils/html.py
index 602e1a76..25a74a4a 100644
--- a/utils/html.py
+++ b/utils/html.py
@@ -1,51 +1,51 @@
-"""Utilities for working with HTML."""

-import html5lib

-from html5lib import sanitizer, serializer, tokenizer, treebuilders, treewalkers

-

-class HTMLSanitizerMixin(sanitizer.HTMLSanitizerMixin):

-    acceptable_elements = ('a', 'abbr', 'acronym', 'address', 'b', 'big',

-        'blockquote', 'br', 'caption', 'center', 'cite', 'code', 'col',

-        'colgroup', 'dd', 'del', 'dfn', 'dir', 'div', 'dl', 'dt', 'em', 'font',

-        'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'ins', 'kbd',

-        'li', 'ol', 'p', 'pre', 'q', 's', 'samp', 'small', 'span', 'strike',

-        'strong', 'sub', 'sup', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead',

-        'tr', 'tt', 'u', 'ul', 'var')

-

-    acceptable_attributes = ('abbr', 'align', 'alt', 'axis', 'border',

-        'cellpadding', 'cellspacing', 'char', 'charoff', 'charset', 'cite',

-        'cols', 'colspan', 'datetime', 'dir', 'frame', 'headers', 'height',

-        'href', 'hreflang', 'hspace', 'lang', 'longdesc', 'name', 'nohref',

-        'noshade', 'nowrap', 'rel', 'rev', 'rows', 'rowspan', 'rules', 'scope',

-        'span', 'src', 'start', 'summary', 'title', 'type', 'valign', 'vspace',

-        'width')

-

-    allowed_elements = acceptable_elements

-    allowed_attributes = acceptable_attributes

-    allowed_css_properties = ()

-    allowed_css_keywords = ()

-    allowed_svg_properties = ()

-

-class HTMLSanitizer(tokenizer.HTMLTokenizer, HTMLSanitizerMixin):

-    def __init__(self, stream, encoding=None, parseMeta=True, useChardet=True,

-                 lowercaseElementName=True, lowercaseAttrName=True):

-        tokenizer.HTMLTokenizer.__init__(self, stream, encoding, parseMeta,

-                                         useChardet, lowercaseElementName,

-                                         lowercaseAttrName)

-

-    def __iter__(self):

-        for token in tokenizer.HTMLTokenizer.__iter__(self):

-            token = self.sanitize_token(token)

-            if token:

-                yield token

-

-def sanitize_html(html):

-    """Sanitizes an HTML fragment."""

-    p = html5lib.HTMLParser(tokenizer=HTMLSanitizer,

-                            tree=treebuilders.getTreeBuilder("dom"))

-    dom_tree = p.parseFragment(html)

-    walker = treewalkers.getTreeWalker("dom")

-    stream = walker(dom_tree)

-    s = serializer.HTMLSerializer(omit_optional_tags=False,

-                                  quote_attr_values=True)

-    output_generator = s.serialize(stream)

-    return u''.join(output_generator)

+"""Utilities for working with HTML."""
+import html5lib
+from html5lib import sanitizer, serializer, tokenizer, treebuilders, treewalkers
+
+class HTMLSanitizerMixin(sanitizer.HTMLSanitizerMixin):
+    acceptable_elements = ('a', 'abbr', 'acronym', 'address', 'b', 'big',
+        'blockquote', 'br', 'caption', 'center', 'cite', 'code', 'col',
+        'colgroup', 'dd', 'del', 'dfn', 'dir', 'div', 'dl', 'dt', 'em', 'font',
+        'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'ins', 'kbd',
+        'li', 'ol', 'p', 'pre', 'q', 's', 'samp', 'small', 'span', 'strike',
+        'strong', 'sub', 'sup', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead',
+        'tr', 'tt', 'u', 'ul', 'var')
+
+    acceptable_attributes = ('abbr', 'align', 'alt', 'axis', 'border',
+        'cellpadding', 'cellspacing', 'char', 'charoff', 'charset', 'cite',
+        'cols', 'colspan', 'datetime', 'dir', 'frame', 'headers', 'height',
+        'href', 'hreflang', 'hspace', 'lang', 'longdesc', 'name', 'nohref',
+        'noshade', 'nowrap', 'rel', 'rev', 'rows', 'rowspan', 'rules', 'scope',
+        'span', 'src', 'start', 'summary', 'title', 'type', 'valign', 'vspace',
+        'width')
+
+    allowed_elements = acceptable_elements
+    allowed_attributes = acceptable_attributes
+    allowed_css_properties = ()
+    allowed_css_keywords = ()
+    allowed_svg_properties = ()
+
+class HTMLSanitizer(tokenizer.HTMLTokenizer, HTMLSanitizerMixin):
+    def __init__(self, stream, encoding=None, parseMeta=True, useChardet=True,
+                 lowercaseElementName=True, lowercaseAttrName=True):
+        tokenizer.HTMLTokenizer.__init__(self, stream, encoding, parseMeta,
+                                         useChardet, lowercaseElementName,
+                                         lowercaseAttrName)
+
+    def __iter__(self):
+        for token in tokenizer.HTMLTokenizer.__iter__(self):
+            token = self.sanitize_token(token)
+            if token:
+                yield token
+
+def sanitize_html(html):
+    """Sanitizes an HTML fragment."""
+    p = html5lib.HTMLParser(tokenizer=HTMLSanitizer,
+                            tree=treebuilders.getTreeBuilder("dom"))
+    dom_tree = p.parseFragment(html)
+    walker = treewalkers.getTreeWalker("dom")
+    stream = walker(dom_tree)
+    s = serializer.HTMLSerializer(omit_optional_tags=False,
+                                  quote_attr_values=True)
+    output_generator = s.serialize(stream)
+    return u''.join(output_generator)
diff --git a/utils/lists.py b/utils/lists.py
index 426d9cd3..bbcfae98 100644
--- a/utils/lists.py
+++ b/utils/lists.py
@@ -1,86 +1,86 @@
-"""Utilities for working with lists and sequences."""

-

-def flatten(x):

-    """

-    Returns a single, flat list which contains all elements retrieved

-    from the sequence and all recursively contained sub-sequences

-    (iterables).

-

-    Examples:

-    >>> [1, 2, [3, 4], (5, 6)]

-    [1, 2, [3, 4], (5, 6)]

-

-    From http://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks

-    """

-    result = []

-    for el in x:

-        if hasattr(el, '__iter__') and not isinstance(el, basestring):

-            result.extend(flatten(el))

-        else:

-            result.append(el)

-    return result

-

-def batch_size(items, size):

-    """

-    Retrieves items in batches of the given size.

-

-    >>> l = range(1, 11)

-    >>> batch_size(l, 3)

-    [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

-    >>> batch_size(l, 5)

-    [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]

-    """

-    return [items[i:i+size] for i in xrange(0, len(items), size)]

-

-def batches(items, number):

-    """

-    Retrieves items in the given number of batches.

-

-    >>> l = range(1, 11)

-    >>> batches(l, 1)

-    [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]

-    >>> batches(l, 2)

-    [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]

-    >>> batches(l, 3)

-    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]

-    >>> batches(l, 4)

-    [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

-    >>> batches(l, 5)

-    [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]

-

-    Initial batches will contain as many items as possible in cases where

-    there are not enough items to be distributed evenly.

-

-    >>> batches(l, 6)

-    [[1, 2], [3, 4], [5, 6], [7, 8], [9], [10]]

-    >>> batches(l, 7)

-    [[1, 2], [3, 4], [5, 6], [7], [8], [9], [10]]

-    >>> batches(l, 8)

-    [[1, 2], [3, 4], [5], [6], [7], [8], [9], [10]]

-    >>> batches(l, 9)

-    [[1, 2], [3], [4], [5], [6], [7], [8], [9], [10]]

-    >>> batches(l, 10)

-    [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]]

-

-    If there are more batches than items, empty batches will be appended

-    to the batch list.

-

-    >>> batches(l, 11)

-    [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], []]

-    >>> batches(l, 12)

-    [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [], []]

-    """

-    div, mod= divmod(len(items), number)

-    if div > 1:

-        if mod:

-            div += 1

-        return batch_size(items, div)

-    else:

-        if not div:

-            return [[item] for item in items] + [[]] * (number - mod)

-        elif div == 1 and not mod:

-            return [[item] for item in items]

-        else:

-            # mod now tells you how many lists of 2 you can fit in

-            return ([items[i*2:(i*2)+2] for i in xrange(0, mod)] +

-                    [[item] for item in items[mod*2:]])

+"""Utilities for working with lists and sequences."""
+
+def flatten(x):
+    """
+    Returns a single, flat list which contains all elements retrieved
+    from the sequence and all recursively contained sub-sequences
+    (iterables).
+
+    Examples:
+    >>> [1, 2, [3, 4], (5, 6)]
+    [1, 2, [3, 4], (5, 6)]
+
+    From http://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks
+    """
+    result = []
+    for el in x:
+        if hasattr(el, '__iter__') and not isinstance(el, basestring):
+            result.extend(flatten(el))
+        else:
+            result.append(el)
+    return result
+
+def batch_size(items, size):
+    """
+    Retrieves items in batches of the given size.
+
+    >>> l = range(1, 11)
+    >>> batch_size(l, 3)
+    [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
+    >>> batch_size(l, 5)
+    [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
+    """
+    return [items[i:i+size] for i in xrange(0, len(items), size)]
+
+def batches(items, number):
+    """
+    Retrieves items in the given number of batches.
+
+    >>> l = range(1, 11)
+    >>> batches(l, 1)
+    [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
+    >>> batches(l, 2)
+    [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
+    >>> batches(l, 3)
+    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
+    >>> batches(l, 4)
+    [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
+    >>> batches(l, 5)
+    [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
+
+    Initial batches will contain as many items as possible in cases where
+    there are not enough items to be distributed evenly.
+
+    >>> batches(l, 6)
+    [[1, 2], [3, 4], [5, 6], [7, 8], [9], [10]]
+    >>> batches(l, 7)
+    [[1, 2], [3, 4], [5, 6], [7], [8], [9], [10]]
+    >>> batches(l, 8)
+    [[1, 2], [3, 4], [5], [6], [7], [8], [9], [10]]
+    >>> batches(l, 9)
+    [[1, 2], [3], [4], [5], [6], [7], [8], [9], [10]]
+    >>> batches(l, 10)
+    [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]]
+
+    If there are more batches than items, empty batches will be appended
+    to the batch list.
+
+    >>> batches(l, 11)
+    [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], []]
+    >>> batches(l, 12)
+    [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [], []]
+    """
+    div, mod= divmod(len(items), number)
+    if div > 1:
+        if mod:
+            div += 1
+        return batch_size(items, div)
+    else:
+        if not div:
+            return [[item] for item in items] + [[]] * (number - mod)
+        elif div == 1 and not mod:
+            return [[item] for item in items]
+        else:
+            # mod now tells you how many lists of 2 you can fit in
+            return ([items[i*2:(i*2)+2] for i in xrange(0, mod)] +
+                    [[item] for item in items[mod*2:]])