trivial: Cleanup of 'models.py'

Resolve some issues with the aforementioned file. These are mostly
stylistic changes.

Signed-off-by: Stephen Finucane <stephen.finucane@intel.com>

1 files changed, 124 insertions, 106 deletions

diff --git a/patchwork/models.py b/patchwork/models.py
index f206b18..d0b3447 100644
--- a/patchwork/models.py
+++ b/patchwork/models.py
@@ -17,25 +17,27 @@
 # along with Patchwork; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-from django.db import models
-from django.db.models import Q
+from collections import Counter, OrderedDict
+import datetime
+import random
+import re
+
 from django.contrib.auth.models import User
-from django.core.urlresolvers import reverse
-from django.contrib.sites.models import Site
 from django.conf import settings
+from django.contrib.sites.models import Site
+from django.core.urlresolvers import reverse
+from django.db import models
+from django.db.models import Q
 from django.utils.functional import cached_property
-from patchwork.parser import hash_patch, extract_tags
 
-import re
-import datetime, time
-import random
-from collections import Counter, OrderedDict
+from patchwork.parser import extract_tags, hash_patch
+
 
 class Person(models.Model):
-    email = models.CharField(max_length=255, unique = True)
-    name = models.CharField(max_length=255, null = True, blank = True)
-    user = models.ForeignKey(User, null = True, blank = True,
-            on_delete = models.SET_NULL)
+    email = models.CharField(max_length=255, unique=True)
+    name = models.CharField(max_length=255, null=True, blank=True)
+    user = models.ForeignKey(User, null=True, blank=True,
+                             on_delete=models.SET_NULL)
 
     def __unicode__(self):
         if self.name:
@@ -50,6 +52,7 @@ class Person(models.Model):
     class Meta:
         verbose_name_plural = 'People'
 
+
 class Project(models.Model):
     linkname = models.CharField(max_length=255, unique=True)
     name = models.CharField(max_length=255, unique=True)
@@ -80,16 +83,17 @@ class Project(models.Model):
 
 
 class UserProfile(models.Model):
-    user = models.OneToOneField(User, unique = True, related_name='profile')
-    primary_project = models.ForeignKey(Project, null = True, blank = True)
-    maintainer_projects = models.ManyToManyField(Project,
-            related_name = 'maintainer_project')
-    send_email = models.BooleanField(default = False,
-            help_text = 'Selecting this option allows patchwork to send ' +
-                'email on your behalf')
-    patches_per_page = models.PositiveIntegerField(default = 100,
-            null = False, blank = False,
-            help_text = 'Number of patches to display per page')
+    user = models.OneToOneField(User, unique=True, related_name='profile')
+    primary_project = models.ForeignKey(Project, null=True, blank=True)
+    maintainer_projects = models.ManyToManyField(
+        Project, related_name='maintainer_project')
+    send_email = models.BooleanField(
+        default=False,
+        help_text='Selecting this option allows patchwork to send email on'
+        ' your behalf')
+    patches_per_page = models.PositiveIntegerField(
+        default=100, null=False, blank=False,
+        help_text='Number of patches to display per page')
 
     def name(self):
         if self.user.first_name or self.user.last_name:
@@ -98,11 +102,9 @@ class UserProfile(models.Model):
         return self.user.username
 
     def contributor_projects(self):
-        submitters = Person.objects.filter(user = self.user)
-        return Project.objects.filter(id__in =
-                                        Patch.objects.filter(
-                                            submitter__in = submitters)
-                                        .values('project_id').query)
+        submitters = Person.objects.filter(user=self.user)
+        return Project.objects.filter(id__in=Patch.objects.filter(
+            submitter__in=submitters).values('project_id').query)
 
     def sync_person(self):
         pass
@@ -110,37 +112,37 @@ class UserProfile(models.Model):
     def n_todo_patches(self):
         return self.todo_patches().count()
 
-    def todo_patches(self, project = None):
+    def todo_patches(self, project=None):
 
         # filter on project, if necessary
         if project:
-            qs = Patch.objects.filter(project = project)
+            qs = Patch.objects.filter(project=project)
         else:
             qs = Patch.objects
 
-        qs = qs.filter(archived = False) \
-             .filter(delegate = self.user) \
-             .filter(state__in =
-                     State.objects.filter(action_required = True)
-                         .values('pk').query)
+        qs = qs.filter(archived=False).filter(
+            delegate=self.user).filter(state__in=State.objects.filter(
+                action_required=True).values('pk').query)
         return qs
 
     def __unicode__(self):
         return self.name()
 
+
 def _user_saved_callback(sender, created, instance, **kwargs):
     try:
         profile = instance.profile
     except UserProfile.DoesNotExist:
-        profile = UserProfile(user = instance)
+        profile = UserProfile(user=instance)
     profile.save()
 
-models.signals.post_save.connect(_user_saved_callback, sender = User)
+models.signals.post_save.connect(_user_saved_callback, sender=User)
+
 
 class State(models.Model):
-    name = models.CharField(max_length = 100)
-    ordering = models.IntegerField(unique = True)
-    action_required = models.BooleanField(default = True)
+    name = models.CharField(max_length=100)
+    ordering = models.IntegerField(unique=True)
+    action_required = models.BooleanField(default=True)
 
     def __unicode__(self):
         return self.name
@@ -148,19 +150,21 @@ class State(models.Model):
     class Meta:
         ordering = ['ordering']
 
+
 class HashField(models.CharField):
     __metaclass__ = models.SubfieldBase
 
-    def __init__(self, algorithm = 'sha1', *args, **kwargs):
+    def __init__(self, algorithm='sha1', *args, **kwargs):
         self.algorithm = algorithm
         try:
             import hashlib
-            def _construct(string = ''):
+
+            def _construct(string=''):
                 return hashlib.new(self.algorithm, string)
             self.construct = _construct
             self.n_bytes = len(hashlib.new(self.algorithm).hexdigest())
         except ImportError:
-            modules = { 'sha1': 'sha', 'md5': 'md5'}
+            modules = {'sha1': 'sha', 'md5': 'md5'}
 
             if algorithm not in modules.keys():
                 raise NameError("Unknown algorithm '%s'" % algorithm)
@@ -175,15 +179,16 @@ class HashField(models.CharField):
     def db_type(self, connection=None):
         return 'char(%d)' % self.n_bytes
 
+
 class Tag(models.Model):
     name = models.CharField(max_length=20)
-    pattern = models.CharField(max_length=50,
-                help_text='A simple regex to match the tag in the content of '
-                    'a message. Will be used with MULTILINE and IGNORECASE '
-                    'flags. eg. ^Acked-by:')
-    abbrev = models.CharField(max_length=2, unique=True,
-                help_text='Short (one-or-two letter) abbreviation for the tag, '
-                    'used in table column headers')
+    pattern = models.CharField(
+        max_length=50, help_text='A simple regex to match the tag in the'
+        ' content of a message. Will be used with MULTILINE and IGNORECASE'
+        ' flags. eg. ^Acked-by:')
+    abbrev = models.CharField(
+        max_length=2, unique=True, help_text='Short (one-or-two letter)'
+        ' abbreviation for the tag, used in table column headers')
 
     def __unicode__(self):
         return self.name
@@ -195,6 +200,7 @@ class Tag(models.Model):
     class Meta:
         ordering = ['abbrev']
 
+
 class PatchTag(models.Model):
     patch = models.ForeignKey('Patch')
     tag = models.ForeignKey('Tag')
@@ -203,9 +209,11 @@ class PatchTag(models.Model):
     class Meta:
         unique_together = [('patch', 'tag')]
 
+
 def get_default_initial_patch_state():
     return State.objects.get(ordering=0)
 
+
 class PatchQuerySet(models.query.QuerySet):
 
     def with_tag_counts(self, project):
@@ -220,14 +228,16 @@ class PatchQuerySet(models.query.QuerySet):
         select = OrderedDict()
         select_params = []
         for tag in project.tags:
-            select[tag.attr_name] = ("coalesce("
-                "(SELECT count FROM patchwork_patchtag "
-                "WHERE patchwork_patchtag.patch_id=patchwork_patch.id "
-                    "AND patchwork_patchtag.tag_id=%s), 0)")
+            select[tag.attr_name] = (
+                "coalesce("
+                "(SELECT count FROM patchwork_patchtag"
+                " WHERE patchwork_patchtag.patch_id=patchwork_patch.id"
+                " AND patchwork_patchtag.tag_id=%s), 0)")
             select_params.append(tag.id)
 
         return qs.extra(select=select, select_params=select_params)
 
+
 class PatchManager(models.Manager):
     use_for_related_fields = True
 
@@ -237,20 +247,21 @@ class PatchManager(models.Manager):
     def with_tag_counts(self, project):
         return self.get_queryset().with_tag_counts(project)
 
+
 class Patch(models.Model):
     project = models.ForeignKey(Project)
     msgid = models.CharField(max_length=255)
     name = models.CharField(max_length=255)
     date = models.DateTimeField(default=datetime.datetime.now)
     submitter = models.ForeignKey(Person)
-    delegate = models.ForeignKey(User, blank = True, null = True)
+    delegate = models.ForeignKey(User, blank=True, null=True)
     state = models.ForeignKey(State, null=True)
-    archived = models.BooleanField(default = False)
-    headers = models.TextField(blank = True)
-    content = models.TextField(null = True, blank = True)
-    pull_url = models.CharField(max_length=255, null = True, blank = True)
-    commit_ref = models.CharField(max_length=255, null = True, blank = True)
-    hash = HashField(null = True, blank = True)
+    archived = models.BooleanField(default=False)
+    headers = models.TextField(blank=True)
+    content = models.TextField(null=True, blank=True)
+    pull_url = models.CharField(max_length=255, null=True, blank=True)
+    commit_ref = models.CharField(max_length=255, null=True, blank=True)
+    hash = HashField(null=True, blank=True)
     tags = models.ManyToManyField(Tag, through=PatchTag)
 
     objects = PatchManager()
@@ -274,7 +285,7 @@ class Patch(models.Model):
 
         This includes the commit message and all other replies.
         """
-        return Comment.objects.filter(patch = self)
+        return Comment.objects.filter(patch=self)
 
     def _set_tag(self, tag, count):
         if count == 0:
@@ -313,7 +324,7 @@ class Patch(models.Model):
         return self.project.is_editable(user)
 
     def filename(self):
-        fname_re = re.compile('[^-_A-Za-z0-9\.]+')
+        fname_re = re.compile(r'[^-_A-Za-z0-9\.]+')
         str = fname_re.sub('-', self.name)
         return str.strip('-') + '.patch'
 
@@ -326,21 +337,22 @@ class Patch(models.Model):
         ordering = ['date']
         unique_together = [('msgid', 'project')]
 
+
 class Comment(models.Model):
     patch = models.ForeignKey(Patch)
     msgid = models.CharField(max_length=255)
     submitter = models.ForeignKey(Person)
-    date = models.DateTimeField(default = datetime.datetime.now)
-    headers = models.TextField(blank = True)
+    date = models.DateTimeField(default=datetime.datetime.now)
+    headers = models.TextField(blank=True)
     content = models.TextField()
 
-    response_re = re.compile( \
-            '^(Tested|Reviewed|Acked|Signed-off|Nacked|Reported)-by: .*$',
-            re.M | re.I)
+    response_re = re.compile(
+        r'^(Tested|Reviewed|Acked|Signed-off|Nacked|Reported)-by: .*$',
+        re.M | re.I)
 
     def patch_responses(self):
-        return ''.join([ match.group(0) + '\n' for match in
-                                self.response_re.finditer(self.content)])
+        return ''.join([match.group(0) + '\n' for match in
+                        self.response_re.finditer(self.content)])
 
     def save(self, *args, **kwargs):
         super(Comment, self).save(*args, **kwargs)
@@ -354,12 +366,13 @@ class Comment(models.Model):
         ordering = ['date']
         unique_together = [('msgid', 'patch')]
 
+
 class Bundle(models.Model):
     owner = models.ForeignKey(User)
     project = models.ForeignKey(Project)
-    name = models.CharField(max_length = 50, null = False, blank = False)
-    patches = models.ManyToManyField(Patch, through = 'BundlePatch')
-    public = models.BooleanField(default = False)
+    name = models.CharField(max_length=50, null=False, blank=False)
+    patches = models.ManyToManyField(Patch, through='BundlePatch')
+    public = models.BooleanField(default=False)
 
     def n_patches(self):
         return self.patches.all().count()
@@ -369,8 +382,8 @@ class Bundle(models.Model):
 
     def append_patch(self, patch):
         # todo: use the aggregate queries in django 1.1
-        orders = BundlePatch.objects.filter(bundle = self).order_by('-order') \
-                 .values('order')
+        orders = BundlePatch.objects.filter(bundle=self).order_by('-order') \
+            .values('order')
 
         if len(orders) > 0:
             max_order = orders[0]['order']
@@ -378,11 +391,11 @@ class Bundle(models.Model):
             max_order = 0
 
         # see if the patch is already in this bundle
-        if BundlePatch.objects.filter(bundle = self, patch = patch).count():
-            raise Exception("patch is already in bundle")
+        if BundlePatch.objects.filter(bundle=self, patch=patch).count():
+            raise Exception('patch is already in bundle')
 
-        bp = BundlePatch.objects.create(bundle = self, patch = patch,
-                order = max_order + 1)
+        bp = BundlePatch.objects.create(bundle=self, patch=patch,
+                                        order=max_order + 1)
         bp.save()
 
     class Meta:
@@ -393,18 +406,19 @@ class Bundle(models.Model):
             return None
         site = Site.objects.get_current()
         return 'http://%s%s' % (site.domain,
-                reverse('patchwork.views.bundle.bundle',
-                        kwargs = {
-                                'username': self.owner.username,
-                                'bundlename': self.name
-                        }))
+                                reverse('patchwork.views.bundle.bundle',
+                                        kwargs={
+                                            'username': self.owner.username,
+                                            'bundlename': self.name
+                                        }))
 
     @models.permalink
     def get_absolute_url(self):
         return ('patchwork.views.bundle.bundle', (), {
-                                'username': self.owner.username,
-                                'bundlename': self.name,
-                            })
+            'username': self.owner.username,
+            'bundlename': self.name,
+        })
+
 
 class BundlePatch(models.Model):
     patch = models.ForeignKey(Patch)
@@ -415,18 +429,19 @@ class BundlePatch(models.Model):
         unique_together = [('bundle', 'patch')]
         ordering = ['order']
 
+
 class EmailConfirmation(models.Model):
-    validity = datetime.timedelta(days = settings.CONFIRMATION_VALIDITY_DAYS)
-    type = models.CharField(max_length = 20, choices = [
-                                ('userperson', 'User-Person association'),
-                                ('registration', 'Registration'),
-                                ('optout', 'Email opt-out'),
-                            ])
-    email = models.CharField(max_length = 200)
-    user = models.ForeignKey(User, null = True)
+    validity = datetime.timedelta(days=settings.CONFIRMATION_VALIDITY_DAYS)
+    type = models.CharField(max_length=20, choices=[
+        ('userperson', 'User-Person association'),
+        ('registration', 'Registration'),
+        ('optout', 'Email opt-out'),
+    ])
+    email = models.CharField(max_length=200)
+    user = models.ForeignKey(User, null=True)
     key = HashField()
-    date = models.DateTimeField(default = datetime.datetime.now)
-    active = models.BooleanField(default = True)
+    date = models.DateTimeField(default=datetime.datetime.now)
+    active = models.BooleanField(default=True)
 
     def deactivate(self):
         self.active = False
@@ -442,8 +457,9 @@ class EmailConfirmation(models.Model):
             self.key = self._meta.get_field('key').construct(str).hexdigest()
         super(EmailConfirmation, self).save()
 
+
 class EmailOptout(models.Model):
-    email = models.CharField(max_length = 200, primary_key = True)
+    email = models.CharField(max_length=200, primary_key=True)
 
     def __unicode__(self):
         return self.email
@@ -451,13 +467,15 @@ class EmailOptout(models.Model):
     @classmethod
     def is_optout(cls, email):
         email = email.lower().strip()
-        return cls.objects.filter(email = email).count() > 0
+        return cls.objects.filter(email=email).count() > 0
+
 
 class PatchChangeNotification(models.Model):
-    patch = models.OneToOneField(Patch, primary_key = True)
-    last_modified = models.DateTimeField(default = datetime.datetime.now)
+    patch = models.OneToOneField(Patch, primary_key=True)
+    last_modified = models.DateTimeField(default=datetime.datetime.now)
     orig_state = models.ForeignKey(State)
 
+
 def _patch_change_callback(sender, instance, **kwargs):
     # we only want notification of modified patches
     if instance.pk is None:
@@ -467,7 +485,7 @@ def _patch_change_callback(sender, instance, **kwargs):
         return
 
     try:
-        orig_patch = Patch.objects.get(pk = instance.pk)
+        orig_patch = Patch.objects.get(pk=instance.pk)
     except Patch.DoesNotExist:
         return
 
@@ -478,13 +496,13 @@ def _patch_change_callback(sender, instance, **kwargs):
 
     notification = None
     try:
-        notification = PatchChangeNotification.objects.get(patch = instance)
+        notification = PatchChangeNotification.objects.get(patch=instance)
     except PatchChangeNotification.DoesNotExist:
         pass
 
     if notification is None:
-        notification = PatchChangeNotification(patch = instance,
-                                               orig_state = orig_patch.state)
+        notification = PatchChangeNotification(patch=instance,
+                                               orig_state=orig_patch.state)
 
     elif notification.orig_state == instance.state:
         # If we're back at the original state, there is no need to notify
@@ -494,4 +512,4 @@ def _patch_change_callback(sender, instance, **kwargs):
     notification.last_modified = datetime.datetime.now()
     notification.save()
 
-models.signals.pre_save.connect(_patch_change_callback, sender = Patch)
+models.signals.pre_save.connect(_patch_change_callback, sender=Patch)