Merge branch 'cleanup_model_representation' into 'master'

Cleanup model representation

See merge request !314

beat/web/accounts/models.py

@@ -71,7 +71,7 @@ class SupervisionTrack(models.Model):
     last_validation_date = models.DateTimeField(null=True, blank=True)
     supervision_key = models.CharField(max_length=40, null=True, blank=True)
 
-    def __unicode__(self):
+    def __str__(self):
         return u"Supervisor: %s, Supervisee, %s, Validity: %s" % (
             self.supervisor.username,
             self.supervisee.username,
@@ -123,8 +123,8 @@ class Profile(models.Model):
 
     objects = ProfileManager()
 
-    def __unicode__(self):
-        return u"User: %s" % self.user.username
+    def __str__(self):
+        return "User: %s" % self.user.username
 
     def _generate_current_supervision_key(self):
         length = 40

beat/web/navigation/models.py

@@ -29,19 +29,15 @@ from django.db import models
 from django.contrib.auth.models import User
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class Agreement(models.Model):
 
     user = models.OneToOneField(User)
     version = models.PositiveIntegerField(
-        default=1,
-        help_text='Last version of the ToS the user has agreed with',
+        default=1, help_text="Last version of the ToS the user has agreed with"
     )
 
-    def __unicode__(self):
-        return u"%s agrees with ToS version %d" % (
-            self.user.username,
-            self.version
-        )
+    def __str__(self):
+        return "%s agrees with ToS version %d" % (self.user.username, self.version)

beat/web/team/models.py

@@ -33,7 +33,6 @@ from django.utils.translation import ugettext_lazy as _
 
 
 class TeamManager(models.Manager):
-
     def get_by_natural_key(self, owner_username, name):
         return self.get(owner__username=owner_username, name=name)
 
@@ -42,13 +41,14 @@ class TeamManager(models.Manager):
         if user.is_anonymous():
             return self.public()
 
-        query = Q(owner=user) |\
-            (Q(privacy_level__in=[Team.MEMBERS, Team.PRIVATE]) & Q(members=user))
+        query = Q(owner=user) | (
+            Q(privacy_level__in=[Team.MEMBERS, Team.PRIVATE]) & Q(members=user)
+        )
 
         if add_public:
             query |= Q(privacy_level=Team.PUBLIC)
 
-        return self.filter(query).distinct().order_by('privacy_level')
+        return self.filter(query).distinct().order_by("privacy_level")
 
     def public(self):
         return self.filter(privacy_level=Team.PUBLIC)
@@ -56,49 +56,45 @@ class TeamManager(models.Manager):
 
 class Team(models.Model):
 
-    #_____ Constants __________
+    # _____ Constants __________
 
     PRIVATE = 0
     MEMBERS = 1
-    PUBLIC  = 2
-
+    PUBLIC = 2
 
-    #_____ Fields __________
+    # _____ Fields __________
 
     PRIVACY_LEVELS = [
-        [PRIVATE, _('Private')],
-        [MEMBERS, _('Members only')],
-        [PUBLIC,  _('Public')],
+        [PRIVATE, _("Private")],
+        [MEMBERS, _("Members only")],
+        [PUBLIC, _("Public")],
     ]
 
-    owner             = models.ForeignKey(User)
-    name              = models.CharField(max_length=32)
-    short_description = models.TextField(max_length=100, default='', blank=True)
-    members           = models.ManyToManyField(User, related_name='teams', blank=True)
-    privacy_level     = models.PositiveIntegerField(default=PRIVATE, choices=PRIVACY_LEVELS)
+    owner = models.ForeignKey(User)
+    name = models.CharField(max_length=32)
+    short_description = models.TextField(max_length=100, default="", blank=True)
+    members = models.ManyToManyField(User, related_name="teams", blank=True)
+    privacy_level = models.PositiveIntegerField(default=PRIVATE, choices=PRIVACY_LEVELS)
 
     objects = TeamManager()
 
-
-    #_____ Meta parameters __________
+    # _____ Meta parameters __________
 
     class Meta:
-        unique_together = ['owner', 'name']
+        unique_together = ["owner", "name"]
 
-
-    #_____ Utilities __________
+    # _____ Utilities __________
 
     def natural_key(self):
 
         return (self.owner.username, self.name)
 
-
     def total_shares(self, user=None):
-        '''Count number of objects shared with this team
+        """Count number of objects shared with this team
 
         If ``user`` is passed, counts objects shared with this team that the
         given user has access to.
-        '''
+        """
 
         used_at = 0
 
@@ -127,34 +123,34 @@ class Team(models.Model):
             used_at += self.shared_environments.for_user(user, add_public=True).count()
             used_at += self.shared_experiments.for_user(user, add_public=True).count()
             used_at += self.shared_librarys.for_user(user, add_public=True).count()
-            used_at += self.shared_plotterparameters.for_user(user, add_public=True).count()
+            used_at += self.shared_plotterparameters.for_user(
+                user, add_public=True
+            ).count()
             used_at += self.shared_plotters.for_user(user, add_public=True).count()
             used_at += self.shared_searchs.for_user(user, add_public=True).count()
             used_at += self.shared_toolchains.for_user(user, add_public=True).count()
             used_at += self.usable_algorithms.for_user(user, add_public=True).count()
             used_at += self.usable_librarys.for_user(user, add_public=True).count()
-            used_at += self.usable_plotterparameters.for_user(user, add_public=True).count()
+            used_at += self.usable_plotterparameters.for_user(
+                user, add_public=True
+            ).count()
             used_at += self.usable_plotters.for_user(user, add_public=True).count()
 
         return used_at
 
-
     def deletable(self):
 
         return not self.total_shares()
 
+    # _____ Overrides __________
 
-    #_____ Overrides __________
-
-    def __unicode__(self):
+    def __str__(self):
         return self.fullname()
 
-
-    #_____ Methods __________
+    # _____ Methods __________
 
     def fullname(self):
-        return '%s/%s' % (self.owner.username, self.name)
-
+        return "%s/%s" % (self.owner.username, self.name)
 
     def get_absolute_url(self):
-        return reverse('teams:view', args=(self.owner.username, self.name))
+        return reverse("teams:view", args=(self.owner.username, self.name))

beat/web/ui/registration/admin.py

@@ -32,17 +32,16 @@ from .models import PreregistrationProfile
 
 
 class RegistrationAdmin(admin.ModelAdmin):
-    list_display = ('__unicode__', 'activation_key_expired')
-    search_fields = ('user__username', 'user__first_name')
+    list_display = ("__str__", "activation_key_expired")
+    search_fields = ("user__username", "user__first_name")
 
 
 admin.site.register(RegistrationProfile, RegistrationAdmin)
 
 
-
 class PreregistrationAdmin(admin.ModelAdmin):
-    list_display = ('first_name', 'last_name', 'email')
-    search_fields = ('first_name', 'last_name', 'email')
+    list_display = ("first_name", "last_name", "email")
+    search_fields = ("first_name", "last_name", "email")
 
 
 admin.site.register(PreregistrationProfile, PreregistrationAdmin)

beat/web/ui/registration/models.py

@@ -29,6 +29,7 @@ import datetime
 import random
 import re
 import hashlib
+
 try:
     from urlparse import urlparse
 except ImportError:
@@ -38,14 +39,13 @@ from django.conf import settings
 from django.contrib.auth.models import User
 from django.db import models
 from django.db import transaction
-from django.template import loader
 from django.utils.translation import ugettext_lazy as _
 
 from ...accounts.models import SupervisionTrack
 from ...accounts.models import Profile
 from ...utils import mail
 
-SHA1_RE = re.compile('^[a-f0-9]{40}$')
+SHA1_RE = re.compile("^[a-f0-9]{40}$")
 
 
 class RegistrationManager(models.Manager):
@@ -57,6 +57,7 @@ class RegistrationManager(models.Manager):
     keys), and for cleaning out expired inactive accounts.
 
     """
+
     def activate_user(self, activation_key):
         """
         Validate an activation key and activate the corresponding
@@ -111,44 +112,56 @@ class RegistrationManager(models.Manager):
                 if user.profile.is_supervisor:
                     # Send email to beat admins
                     parsed_url = urlparse(settings.URL_PREFIX)
-                    server_address = '%s://%s' % (parsed_url.scheme, parsed_url.hostname)
+                    server_address = "%s://%s" % (
+                        parsed_url.scheme,
+                        parsed_url.hostname,
+                    )
 
-                    context = {
-                      'supervisee': user,
-                      'prefix': server_address,
-                    }
+                    context = {"supervisee": user, "prefix": server_address}
 
-                    beat_admins_email = settings.DEFAULT_FROM_EMAIL.split("<")[1].split(">")[0]
+                    beat_admins_email = settings.DEFAULT_FROM_EMAIL.split("<")[1].split(
+                        ">"
+                    )[0]
 
-                    mail.send_email('registration/mail.beatadmin_supervisor_validation.subject.txt',
-                                    'registration/mail.beatadmin_supervisor_validation.message.txt',
-                                    context,
-                                    [beat_admins_email])
+                    mail.send_email(
+                        "registration/mail.beatadmin_supervisor_validation.subject.txt",
+                        "registration/mail.beatadmin_supervisor_validation.message.txt",
+                        context,
+                        [beat_admins_email],
+                    )
 
                 else:
                     # Fetch Supervisor user from supervision track
-                    supervisiontrack = SupervisionTrack.objects.get(supervision_key=user.profile.supervision_key)
+                    supervisiontrack = SupervisionTrack.objects.get(
+                        supervision_key=user.profile.supervision_key
+                    )
                     supervisor_user = supervisiontrack.supervisor
 
                     parsed_url = urlparse(settings.URL_PREFIX)
-                    server_address = '%s://%s' % (parsed_url.scheme, parsed_url.hostname)
+                    server_address = "%s://%s" % (
+                        parsed_url.scheme,
+                        parsed_url.hostname,
+                    )
 
                     context = {
-                        'supervisor': supervisor_user,
-                        'supervisee': user,
-                        'prefix': server_address,
+                        "supervisor": supervisor_user,
+                        "supervisee": user,
+                        "prefix": server_address,
                     }
 
-                    mail.send_email('registration/mail.supervisor_validation.subject.txt',
-                                    'registration/mail.supervisor_validation.message.txt',
-                                    context,
-                                    [supervisor_user.email])
+                    mail.send_email(
+                        "registration/mail.supervisor_validation.subject.txt",
+                        "registration/mail.supervisor_validation.message.txt",
+                        context,
+                        [supervisor_user.email],
+                    )
 
                 return user
         return False
 
-    def create_inactive_user(self, username, first_name, last_name, password,
-                             email, send_email=True):
+    def create_inactive_user(
+        self, username, first_name, last_name, password, email, send_email=True
+    ):
         """
         Create a new, inactive ``User``, generate a
         ``RegistrationProfile`` and email its activation key to the
@@ -198,19 +211,21 @@ class RegistrationManager(models.Manager):
 
         if send_email:
             parsed_url = urlparse(settings.URL_PREFIX)
-            server_address = '%s://%s' % (parsed_url.scheme, parsed_url.hostname)
+            server_address = "%s://%s" % (parsed_url.scheme, parsed_url.hostname)
 
             context = {
-                'activation_key': registration_profile.activation_key,
-                'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS,
-                'user': new_user,
-                'prefix': server_address,
+                "activation_key": registration_profile.activation_key,
+                "expiration_days": settings.ACCOUNT_ACTIVATION_DAYS,
+                "user": new_user,
+                "prefix": server_address,
             }
 
-            mail.send_email('registration/mail.subject.txt',
-                            'registration/mail.message.txt',
-                            context,
-                            [new_user.email])
+            mail.send_email(
+                "registration/mail.subject.txt",
+                "registration/mail.message.txt",
+                context,
+                [new_user.email],
+            )
 
         user_registered.send(sender=self.model, user=new_user)
         return new_user
@@ -227,10 +242,11 @@ class RegistrationManager(models.Manager):
         username and a random salt.
 
         """
-        salt = hashlib.sha1(str(random.random()).encode()).hexdigest()[:5]
-        activation_key = hashlib.sha1((salt+user.username).encode()).hexdigest()
-        return self.create(user=user,
-                           activation_key=activation_key)
+        salt = hashlib.sha1(str(random.random()).encode()).hexdigest()[:5]  # nosec
+        activation_key = hashlib.sha1(  # nosec
+            (salt + user.username).encode()
+        ).hexdigest()
+        return self.create(user=user, activation_key=activation_key)
 
     def delete_expired_users(self):
         """
@@ -295,19 +311,20 @@ class RegistrationProfile(models.Model):
     account registration and activation.
 
     """
+
     ACTIVATED = u"ALREADY_ACTIVATED"
 
-    user = models.OneToOneField(User, verbose_name=_('user'))
-    activation_key = models.CharField(_('activation key'), max_length=40)
+    user = models.OneToOneField(User, verbose_name=_("user"))
+    activation_key = models.CharField(_("activation key"), max_length=40)
 
     objects = RegistrationManager()
 
     class Meta:
-        verbose_name = _('registration profile')
-        verbose_name_plural = _('registration profiles')
+        verbose_name = _("registration profile")
+        verbose_name_plural = _("registration profiles")
 
-    def __unicode__(self):
-        return u"Registration information for %s" % self.user
+    def __str__(self):
+        return "Registration information for %s" % self.user
 
     def activation_key_expired(self):
         """
@@ -332,19 +349,24 @@ class RegistrationProfile(models.Model):
 
         """
         expiration_date = datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS)
-        return self.activation_key == self.ACTIVATED or \
-            (self.user.date_joined + expiration_date <= datetime.datetime.now())
+        return self.activation_key == self.ACTIVATED or (
+            self.user.date_joined + expiration_date <= datetime.datetime.now()
+        )
+
     activation_key_expired.boolean = True
 
 
 class PreregistrationProfile(models.Model):
     first_name = models.CharField(max_length=30)
-    last_name  = models.CharField(max_length=30)
-    email      = models.CharField(max_length=75)
+    last_name = models.CharField(max_length=30)
+    email = models.CharField(max_length=75)
 
     class Meta:
-        verbose_name = _('preregistration profile')
-        verbose_name_plural = _('preregistration profiles')
-
-    def __unicode__(self):
-        return u"Preregistration information for %s %s" % (self.first_name, self.last_name)
+        verbose_name = _("preregistration profile")
+        verbose_name_plural = _("preregistration profiles")
+
+    def __str__(self):
+        return "Preregistration information for %s %s" % (
+            self.first_name,
+            self.last_name,
+        )