Merge branch 'feature/kwalitee' into develop

Author: Fantomas42

tagging/__init__.py

@@ -1,15 +1,21 @@
-VERSION = (0, 3, 6, "final", 0)
+"""
+Django-tagging
+"""
+VERSION = (0, 3, 6, 'final', 0)
 
 
 def get_version():
-    if VERSION[3] == "final":
-        return "%s.%s.%s" % (VERSION[0], VERSION[1], VERSION[2])
-    elif VERSION[3] == "dev":
+    if VERSION[3] == 'final':
+        return '%s.%s.%s' % (VERSION[0], VERSION[1], VERSION[2])
+    elif VERSION[3] == 'dev':
         if VERSION[2] == 0:
-            return "%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[3], VERSION[4])
-        return "%s.%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[2], VERSION[3], VERSION[4])
+            return '%s.%s.%s%s' % (VERSION[0], VERSION[1],
+                                   VERSION[3], VERSION[4])
+        return '%s.%s.%s.%s%s' % (VERSION[0], VERSION[1],
+                                  VERSION[2], VERSION[3], VERSION[4])
     else:
-        return "%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[2], VERSION[3])
+        return '%s.%s.%s%s' % (VERSION[0], VERSION[1],
+                               VERSION[2], VERSION[3])
 
 
 __version__ = get_version()
@@ -34,17 +40,20 @@ def register(model, tag_descriptor_attr='tags',
     from tagging.managers import ModelTaggedItemManager, TagDescriptor
 
     if model in registry:
-        raise AlreadyRegistered("The model '%s' has already been "
-            "registered." % model._meta.object_name)
+        raise AlreadyRegistered(
+            "The model '%s' has already been registered." %
+            model._meta.object_name)
     if hasattr(model, tag_descriptor_attr):
-        raise AttributeError("'%s' already has an attribute '%s'. You must "
+        raise AttributeError(
+            "'%s' already has an attribute '%s'. You must "
             "provide a custom tag_descriptor_attr to register." % (
                 model._meta.object_name,
                 tag_descriptor_attr,
             )
         )
     if hasattr(model, tagged_item_manager_attr):
-        raise AttributeError("'%s' already has an attribute '%s'. You must "
+        raise AttributeError(
+            "'%s' already has an attribute '%s'. You must "
             "provide a custom tagged_item_manager_attr to register." % (
                 model._meta.object_name,
                 tagged_item_manager_attr,
@@ -55,7 +64,8 @@ def register(model, tag_descriptor_attr='tags',
     setattr(model, tag_descriptor_attr, TagDescriptor())
 
     # Add custom manager
-    ModelTaggedItemManager().contribute_to_class(model, tagged_item_manager_attr)
+    ModelTaggedItemManager().contribute_to_class(
+        model, tagged_item_manager_attr)
 
     # Finally register in registry
     registry.append(model)

tagging/fields.py

@@ -59,15 +59,17 @@ class Link(models.Model):
                 self._set_instance_tag_cache(instance, '')
             else:
                 self._set_instance_tag_cache(
-                    instance, edit_string_for_tags(Tag.objects.get_for_object(instance)))
+                    instance, edit_string_for_tags(
+                        Tag.objects.get_for_object(instance)))
         return self._get_instance_tag_cache(instance)
 
     def __set__(self, instance, value):
         """
         Set an object's tags.
         """
         if instance is None:
-            raise AttributeError(_('%s can only be set on instances.') % self.name)
+            raise AttributeError(
+                _('%s can only be set on instances.') % self.name)
         if settings.FORCE_LOWERCASE_TAGS and value is not None:
             value = value.lower()
         self._set_instance_tag_cache(instance, value)

tagging/generic.py

@@ -29,9 +29,11 @@ def fetch_content_objects(tagged_items, select_related_for=None):
     for content_type_pk, object_pks in objects.iteritems():
         model = content_types[content_type_pk].model_class()
         if content_types[content_type_pk].model in select_related_for:
-            objects[content_type_pk] = model._default_manager.select_related().in_bulk(object_pks)
+            objects[content_type_pk] = model._default_manager.select_related(
+                ).in_bulk(object_pks)
         else:
-            objects[content_type_pk] = model._default_manager.in_bulk(object_pks)
+            objects[content_type_pk] = model._default_manager.in_bulk(
+                object_pks)
 
     # Set content types and content objects in the appropriate cache
     # attributes, so accessing the 'content_type' and 'object'

tagging/migrations/0001_initial.py

@@ -1,6 +1,5 @@
-from __future__ import unicode_literals
-
-from django.db import models, migrations
+from django.db import models
+from django.db import migrations
 
 
 class Migration(migrations.Migration):
@@ -13,8 +12,12 @@ class Migration(migrations.Migration):
         migrations.CreateModel(
             name='Tag',
             fields=[
-                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
-                ('name', models.CharField(unique=True, max_length=50, verbose_name='name', db_index=True)),
+                ('id', models.AutoField(
+                    verbose_name='ID', serialize=False,
+                    auto_created=True, primary_key=True)),
+                ('name', models.CharField(
+                    unique=True, max_length=50,
+                    verbose_name='name', db_index=True)),
             ],
             options={
                 'ordering': ('name',),
@@ -25,10 +28,17 @@ class Migration(migrations.Migration):
         migrations.CreateModel(
             name='TaggedItem',
             fields=[
-                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
-                ('object_id', models.PositiveIntegerField(verbose_name='object id', db_index=True)),
-                ('content_type', models.ForeignKey(verbose_name='content type', to='contenttypes.ContentType')),
-                ('tag', models.ForeignKey(related_name='items', verbose_name='tag', to='tagging.Tag')),
+                ('id', models.AutoField(
+                    verbose_name='ID', serialize=False,
+                    auto_created=True, primary_key=True)),
+                ('object_id', models.PositiveIntegerField(
+                    verbose_name='object id', db_index=True)),
+                ('content_type', models.ForeignKey(
+                    verbose_name='content type',
+                    to='contenttypes.ContentType')),
+                ('tag', models.ForeignKey(
+                    related_name='items', verbose_name='tag',
+                    to='tagging.Tag')),
             ],
             options={
                 'verbose_name': 'tagged item',

tagging/migrations/__init__.py

@@ -0,0 +1,3 @@
+"""
+Migrations for tagging
+"""

tagging/models.py

@@ -9,7 +9,7 @@
 from django.contrib.contenttypes.models import ContentType
 try:
     from django.contrib.contenttypes.fields import GenericForeignKey
-except ImportError:
+except ImportError:  # Django 1.8
     from django.contrib.contenttypes.generic import GenericForeignKey
 
 from . import settings
@@ -28,6 +28,7 @@
 ############
 
 class TagManager(models.Manager):
+
     def update_tags(self, obj, tag_names):
         """
         Update tags associated with an object.
@@ -40,12 +41,13 @@ def update_tags(self, obj, tag_names):
             updated_tag_names = [t.lower() for t in updated_tag_names]
 
         # Remove tags which no longer apply
-        tags_for_removal = [tag for tag in current_tags \
+        tags_for_removal = [tag for tag in current_tags
                             if tag.name not in updated_tag_names]
         if len(tags_for_removal):
-            TaggedItem._default_manager.filter(content_type__pk=ctype.pk,
-                                               object_id=obj.pk,
-                                               tag__in=tags_for_removal).delete()
+            TaggedItem._default_manager.filter(
+                content_type__pk=ctype.pk,
+                object_id=obj.pk,
+                tag__in=tags_for_removal).delete()
         # Add new tags
         current_tag_names = [tag.name for tag in current_tags]
         for tag_name in updated_tag_names:
@@ -59,9 +61,11 @@ def add_tag(self, obj, tag_name):
         """
         tag_names = parse_tag_input(tag_name)
         if not len(tag_names):
-            raise AttributeError(_('No tags were given: "%s".') % tag_name)
+            raise AttributeError(
+                _('No tags were given: "%s".') % tag_name)
         if len(tag_names) > 1:
-            raise AttributeError(_('Multiple tags were given: "%s".') % tag_name)
+            raise AttributeError(
+                _('Multiple tags were given: "%s".') % tag_name)
         tag_name = tag_names[0]
         if settings.FORCE_LOWERCASE_TAGS:
             tag_name = tag_name.lower()
@@ -79,12 +83,14 @@ def get_for_object(self, obj):
         return self.filter(items__content_type__pk=ctype.pk,
                            items__object_id=obj.pk)
 
-    def _get_usage(self, model, counts=False, min_count=None, extra_joins=None, extra_criteria=None, params=None):
+    def _get_usage(self, model, counts=False, min_count=None,
+                   extra_joins=None, extra_criteria=None, params=None):
         """
         Perform the custom SQL query for ``usage_for_model`` and
         ``usage_for_queryset``.
         """
-        if min_count is not None: counts = True
+        if min_count is not None:
+            counts = True
 
         model_table = qn(model._meta.db_table)
         model_pk = '%s.%s' % (model_table, qn(model._meta.pk.column))
@@ -116,7 +122,8 @@ def _get_usage(self, model, counts=False, min_count=None, extra_joins=None, extr
             params.append(min_count)
 
         cursor = connection.cursor()
-        cursor.execute(query % (extra_joins, extra_criteria, min_count_sql), params)
+        cursor.execute(query % (extra_joins, extra_criteria, min_count_sql),
+                       params)
         tags = []
         for row in cursor.fetchall():
             t = self.model(*row[:2])
@@ -125,7 +132,8 @@ def _get_usage(self, model, counts=False, min_count=None, extra_joins=None, extr
             tags.append(t)
         return tags
 
-    def usage_for_model(self, model, counts=False, min_count=None, filters=None):
+    def usage_for_model(self, model, counts=False, min_count=None,
+                        filters=None):
         """
         Obtain a list of tags associated with instances of the given
         Model class.
@@ -143,7 +151,8 @@ def usage_for_model(self, model, counts=False, min_count=None, filters=None):
         of field lookups to be applied to the given Model as the
         ``filters`` argument.
         """
-        if filters is None: filters = {}
+        if filters is None:
+            filters = {}
 
         queryset = model._default_manager.filter()
         for f in filters.items():
@@ -185,7 +194,8 @@ def usage_for_queryset(self, queryset, counts=False, min_count=None):
             extra_criteria = 'AND %s' % where
         else:
             extra_criteria = ''
-        return self._get_usage(queryset.model, counts, min_count, extra_joins, extra_criteria, params)
+        return self._get_usage(queryset.model, counts, min_count,
+                               extra_joins, extra_criteria, params)
 
     def related_for_model(self, tags, model, counts=False, min_count=None):
         """
@@ -200,13 +210,16 @@ def related_for_model(self, tags, model, counts=False, min_count=None):
         greater than or equal to ``min_count`` will be returned.
         Passing a value for ``min_count`` implies ``counts=True``.
         """
-        if min_count is not None: counts = True
+        if min_count is not None:
+            counts = True
+
         tags = get_tag_list(tags)
         tag_count = len(tags)
         tagged_item_table = qn(TaggedItem._meta.db_table)
         query = """
         SELECT %(tag)s.id, %(tag)s.name%(count_sql)s
-        FROM %(tagged_item)s INNER JOIN %(tag)s ON %(tagged_item)s.tag_id = %(tag)s.id
+        FROM %(tagged_item)s INNER JOIN %(tag)s ON
+             %(tagged_item)s.tag_id = %(tag)s.id
         WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
           AND %(tagged_item)s.object_id IN
           (
@@ -223,12 +236,14 @@ def related_for_model(self, tags, model, counts=False, min_count=None):
         %(min_count_sql)s
         ORDER BY %(tag)s.name ASC""" % {
             'tag': qn(self.model._meta.db_table),
-            'count_sql': counts and ', COUNT(%s.object_id)' % tagged_item_table or '',
+            'count_sql': counts and ', COUNT(%s.object_id)' %
+                tagged_item_table or '',
             'tagged_item': tagged_item_table,
             'content_type_id': ContentType.objects.get_for_model(model).pk,
             'tag_id_placeholders': ','.join(['%s'] * tag_count),
             'tag_count': tag_count,
-            'min_count_sql': min_count is not None and ('HAVING COUNT(%s.object_id) >= %%s' % tagged_item_table) or '',
+            'min_count_sql': min_count is not None and (
+                'HAVING COUNT(%s.object_id) >= %%s' % tagged_item_table) or '',
         }
 
         params = [tag.pk for tag in tags] * 2
@@ -274,6 +289,7 @@ def cloud_for_model(self, model, steps=4, distribution=LOGARITHMIC,
                                          min_count=min_count))
         return calculate_cloud(tags, steps, distribution)
 
+
 class TaggedItemManager(models.Manager):
     """
     FIXME There's currently no way to get the ``GROUP BY`` and ``HAVING``
@@ -287,6 +303,7 @@ class TaggedItemManager(models.Manager):
           Now that the queryset-refactor branch is in the trunk, this can be
           tidied up significantly.
     """
+
     def get_by_model(self, queryset_or_model, tags):
         """
         Create a ``QuerySet`` containing instances of the specified
@@ -412,7 +429,8 @@ def get_related(self, obj, queryset_or_model, num=None):
         related_content_type = ContentType.objects.get_for_model(model)
         query = """
         SELECT %(model_pk)s, COUNT(related_tagged_item.object_id) AS %(count)s
-        FROM %(model)s, %(tagged_item)s, %(tag)s, %(tagged_item)s related_tagged_item
+        FROM %(model)s, %(tagged_item)s, %(tag)s,
+             %(tagged_item)s related_tagged_item
         WHERE %(tagged_item)s.object_id = %%s
           AND %(tagged_item)s.content_type_id = %(content_type_id)s
           AND %(tag)s.id = %(tagged_item)s.tag_id
@@ -448,10 +466,10 @@ def get_related(self, obj, queryset_or_model, num=None):
         cursor.execute(query, params)
         object_ids = [row[0] for row in cursor.fetchall()]
         if len(object_ids) > 0:
-            # Use in_bulk here instead of an id__in lookup, because id__in would
-            # clobber the ordering.
+            # Use in_bulk here instead of an id__in lookup,
+            # because id__in would clobber the ordering.
             object_dict = queryset.in_bulk(object_ids)
-            return [object_dict[object_id] for object_id in object_ids \
+            return [object_dict[object_id] for object_id in object_ids
                     if object_id in object_dict]
         else:
             return []
@@ -466,7 +484,9 @@ class Tag(models.Model):
     """
     A tag.
     """
-    name = models.CharField(_('name'), max_length=50, unique=True, db_index=True)
+    name = models.CharField(
+        _('name'), max_length=50,
+        unique=True, db_index=True)
 
     objects = TagManager()
 
@@ -484,10 +504,21 @@ class TaggedItem(models.Model):
     """
     Holds the relationship between a tag and the item being tagged.
     """
-    tag = models.ForeignKey(Tag, verbose_name=_('tag'), related_name='items')
-    content_type = models.ForeignKey(ContentType, verbose_name=_('content type'))
-    object_id = models.PositiveIntegerField(_('object id'), db_index=True)
-    object = GenericForeignKey('content_type', 'object_id')
+    tag = models.ForeignKey(
+        Tag,
+        verbose_name=_('tag'),
+        related_name='items')
+
+    content_type = models.ForeignKey(
+        ContentType,
+        verbose_name=_('content type'))
+
+    object_id = models.PositiveIntegerField(
+        _('object id'),
+        db_index=True)
+
+    object = GenericForeignKey(
+        'content_type', 'object_id')
 
     objects = TaggedItemManager()