[databases][models] Pre-commit cleanup

beat/web/databases/models.py

@@ -38,7 +38,6 @@ from beat.backend.python.hash import hashDataset
 
 from ..dataformats.models import DataFormat
 
-from ..common.models import Shareable
 from ..common.models import Versionable
 from ..common.models import VersionableManager
 from ..common.storage import OverwriteStorage
@@ -57,7 +56,7 @@ from ..code.models import get_source_code
 from ..code.models import set_source_code
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 def validate_database(declaration):
@@ -66,8 +65,10 @@ def validate_database(declaration):
     database = beat.core.database.Database(settings.PREFIX, declaration)
 
     if not database.valid:
-        errors = 'The database declaration is **invalid**. Errors:\n  * ' + \
-                 '\n  * '.join(database.errors)
+        errors = (
+            "The database declaration is **invalid**. Errors:\n  * "
+            + "\n  * ".join(database.errors)
+        )
         raise SyntaxError(errors)
 
     # TODO: for each protocol, if a template already exists, that the inserted
@@ -77,37 +78,42 @@ def validate_database(declaration):
     return database
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class DatabaseStorage(OverwriteStorage):
-
     def __init__(self, *args, **kwargs):
-        super(DatabaseStorage, self).__init__(*args, location=settings.DATABASES_ROOT, **kwargs)
+        super(DatabaseStorage, self).__init__(
+            *args, location=settings.DATABASES_ROOT, **kwargs
+        )
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class DatabaseManager(VersionableManager):
-
-
     def get_by_natural_key(self, name, version):
 
         return self.get(name=name, version=version)
 
-
-    def create_database(self, name, short_description='', description='',
-                        declaration=None, code=None, version=1,
-                        previous_version=None):
+    def create_database(
+        self,
+        name,
+        short_description="",
+        description="",
+        declaration=None,
+        code=None,
+        version=1,
+        previous_version=None,
+    ):
         """Convenience function to create a new database from its parts"""
 
         # Create the database representation
         database = self.model(
-            name = name,
-            version = version,
-            sharing = self.model.PRIVATE,
-            previous_version = previous_version,
+            name=name,
+            version=version,
+            sharing=self.model.PRIVATE,
+            previous_version=previous_version,
         )
 
         # Makes sure we get a declaration in string format
@@ -117,11 +123,11 @@ class DatabaseManager(VersionableManager):
             else:
                 default = beat.core.database.Database(settings.PREFIX, data=None)
                 declaration = default.data
-        elif not(isinstance(declaration, dict)):
+        elif not (isinstance(declaration, dict)):
             declaration = simplejson.loads(declaration)
 
         if len(short_description) > 0:
-            declaration['description'] = short_description
+            declaration["description"] = short_description
 
         database.declaration = declaration
 
@@ -130,7 +136,7 @@ class DatabaseManager(VersionableManager):
             if previous_version is not None:
                 code = previous_version.source_code
             else:
-                code = ''
+                code = ""
 
         database.source_code = code
 
@@ -139,7 +145,7 @@ class DatabaseManager(VersionableManager):
             if previous_version is not None:
                 description = previous_version.description
             else:
-                description = ''
+                description = ""
 
         database.description = description
 
@@ -148,68 +154,64 @@ class DatabaseManager(VersionableManager):
             database.save()
         except Exception:
             import traceback
+
             return (None, traceback.format_exc())
 
         return (database, None)
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class Database(Versionable):
 
-    #_____ Fields __________
+    # _____ Fields __________
 
     declaration_file = models.FileField(
         storage=DatabaseStorage(),
         upload_to=get_contribution_declaration_filename,
-        blank=True, null=True,
+        blank=True,
+        null=True,
         max_length=200,
-        db_column='declaration'
+        db_column="declaration",
     )
 
     description_file = models.FileField(
         storage=DatabaseStorage(),
         upload_to=get_contribution_description_filename,
-        blank=True, null=True,
+        blank=True,
+        null=True,
         max_length=200,
-        db_column='description'
+        db_column="description",
     )
 
     source_code_file = models.FileField(
         storage=DatabaseStorage(),
         upload_to=get_contribution_source_code_filename,
-        blank=True, null=True,
+        blank=True,
+        null=True,
         max_length=200,
-        db_column='source_code'
+        db_column="source_code",
     )
 
-
     objects = DatabaseManager()
 
-
-    #_____ Meta parameters __________
+    # _____ Meta parameters __________
 
     class Meta(Versionable.Meta):
-        unique_together = ('name', 'version')
-
+        unique_together = ("name", "version")
 
-    #_____ Utilities __________
+    # _____ Utilities __________
 
     def get_absolute_url(self):
 
-        return reverse(
-            'databases:view',
-                args=(self.name, self.version,),
-        )
-
+        return reverse("databases:view", args=(self.name, self.version))
 
     def natural_key(self):
 
         return (self.name, self.version)
 
-
-    #_____ Overrides __________
+    # _____ Overrides __________
 
     def save(self, *args, **kwargs):
 
@@ -220,7 +222,11 @@ class Database(Versionable):
         wrapper = validate_database(declaration)
 
         # reset the description
-        self.short_description = wrapper.description if (wrapper is not None) and (wrapper.description is not None) else ''
+        self.short_description = (
+            wrapper.description
+            if (wrapper is not None) and (wrapper.description is not None)
+            else ""
+        )
 
         # Save the changed files (if necessary)
         storage.save_files(self)
@@ -229,27 +235,26 @@ class Database(Versionable):
 
         # if the filename has changed, move the declaration
         if self.declaration_filename() != self.declaration_file.name:
-            storage.rename_file(self, 'declaration_file', self.declaration_filename())
-            storage.rename_file(self, 'description_file', self.description_filename())
-            storage.rename_file(self, 'source_code_file', self.source_code_filename())
-
+            storage.rename_file(self, "declaration_file", self.declaration_filename())
+            storage.rename_file(self, "description_file", self.description_filename())
+            storage.rename_file(self, "source_code_file", self.source_code_filename())
 
-    #_____ Methods __________
+    # _____ Methods __________
 
     def fullname(self):
-        return '%s/%d' % (self.name, self.version)
+        return "%s/%d" % (self.name, self.version)
 
     def fullpath(self, extension):
         return os.path.join(self.name, str(self.version) + extension)
 
     def declaration_filename(self):
-        return self.fullpath('.json')
+        return self.fullpath(".json")
 
     def description_filename(self):
-        return self.fullpath('.rst')
+        return self.fullpath(".rst")
 
     def source_code_filename(self):
-        return self.fullpath('.py')
+        return self.fullpath(".py")
 
     def all_referenced_dataformats(self):
         result = []
@@ -263,7 +268,7 @@ class Database(Versionable):
             result.extend(database_protocol.all_needed_dataformats())
         return list(set(result))
 
-    #_____ Properties __________
+    # _____ Properties __________
 
     description = property(get_description, set_description)
     declaration = property(get_declaration, set_declaration)
@@ -271,16 +276,13 @@ class Database(Versionable):
     source_code = property(get_source_code, set_source_code)
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class DatabaseProtocolManager(models.Manager):
-
     def get_by_natural_key(self, database_name, database_version, name):
         return self.get(
-            database__name=database_name,
-            database__version=database_version,
-            name=name,
+            database__name=database_name, database__version=database_version, name=name
         )
 
 
@@ -288,24 +290,26 @@ class DatabaseProtocol(models.Model):
 
     objects = DatabaseProtocolManager()
 
-    database = models.ForeignKey(Database, related_name='protocols',
-                                 on_delete=models.CASCADE)
+    database = models.ForeignKey(
+        Database, related_name="protocols", on_delete=models.CASCADE
+    )
     name = models.CharField(max_length=200, blank=True)
 
     class Meta:
-        unique_together = ('database', 'name')
-        ordering = ['name']
+        unique_together = ("database", "name")
+        ordering = ["name"]
 
     def __str__(self):
         return self.fullname()
 
     def natural_key(self):
         return self.database.natural_key() + (self.name,)
-    natural_key.dependencies = ['databases.database']
+
+    natural_key.dependencies = ["databases.database"]
 
     def fullname(self):
-        if self.name != '':
-            return self.database.fullname() + '@' + self.name
+        if self.name != "":
+            return self.database.fullname() + "@" + self.name
         else:
             return self.database.fullname()
 
@@ -322,16 +326,16 @@ class DatabaseProtocol(models.Model):
         return list(set(result))
 
     def set_template_basename(self):
-        if not self.sets.count(): return "unknown"
+        if not self.sets.count():
+            return "unknown"
         dbset = self.sets.all()[0]
-        return dbset.template.name.rsplit('__')[0]
+        return dbset.template.name.rsplit("__")[0]
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class DatabaseSetTemplateManager(models.Manager):
-
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
@@ -349,24 +353,24 @@ class DatabaseSetTemplate(models.Model):
         return (self.name,)
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class DatabaseSetManager(models.Manager):
-
     def create(self, protocol, template, name):
         dataset = DatabaseSet(
-            name = name,
-            template = template,
-            protocol = protocol,
-            hash = hashDataset(protocol.database.fullname(), protocol.name, name)
+            name=name,
+            template=template,
+            protocol=protocol,
+            hash=hashDataset(protocol.database.fullname(), protocol.name, name),
         )
 
         dataset.save()
         return dataset
 
-
-    def get_by_natural_key(self, database_name, database_version, protocol_name, name, template_name):
+    def get_by_natural_key(
+        self, database_name, database_version, protocol_name, name, template_name
+    ):
         return self.get(
             protocol__database__name=database_name,
             protocol__database__version=database_version,
@@ -378,29 +382,34 @@ class DatabaseSetManager(models.Manager):
 
 class DatabaseSet(models.Model):
 
-    objects     = DatabaseSetManager()
+    objects = DatabaseSetManager()
 
-    protocol    = models.ForeignKey(DatabaseProtocol, related_name='sets',
-                                    on_delete=models.CASCADE)
-    name        = models.CharField(max_length=200, blank=True)
-    template    = models.ForeignKey(DatabaseSetTemplate, related_name='sets',
-                                    on_delete=models.CASCADE)
+    protocol = models.ForeignKey(
+        DatabaseProtocol, related_name="sets", on_delete=models.CASCADE
+    )
+    name = models.CharField(max_length=200, blank=True)
+    template = models.ForeignKey(
+        DatabaseSetTemplate, related_name="sets", on_delete=models.CASCADE
+    )
     hash = models.CharField(max_length=64, unique=True)
 
     class Meta:
-        unique_together = ('protocol', 'name', 'template')
+        unique_together = ("protocol", "name", "template")
 
     def __str__(self):
         return self.fullname()
 
     def natural_key(self):
         return self.protocol.natural_key() + (self.name,) + self.template.natural_key()
-    natural_key.dependencies = ['databases.databaseprotocol',
-                                'databases.databasesettemplate']
+
+    natural_key.dependencies = [
+        "databases.databaseprotocol",
+        "databases.databasesettemplate",
+    ]
 
     def fullname(self):
-        if self.name != '':
-            return self.protocol.fullname() + '.' + self.name
+        if self.name != "":
+            return self.protocol.fullname() + "." + self.name
         else:
             return self.protocol.fullname()
 
@@ -416,43 +425,44 @@ class DatabaseSet(models.Model):
         return list(set(result))
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class DatabaseSetTemplateOutput(models.Model):
-    template        = models.ForeignKey(DatabaseSetTemplate,
-                                        related_name='outputs', on_delete=models.CASCADE)
-    name            = models.CharField(max_length=200)
-    dataformat      = models.ForeignKey(DataFormat,
-                                        related_name='database_outputs', on_delete=models.CASCADE)
+    template = models.ForeignKey(
+        DatabaseSetTemplate, related_name="outputs", on_delete=models.CASCADE
+    )
+    name = models.CharField(max_length=200)
+    dataformat = models.ForeignKey(
+        DataFormat, related_name="database_outputs", on_delete=models.CASCADE
+    )
 
     class Meta:
-        unique_together = ('template', 'name')
+        unique_together = ("template", "name")
 
     def __str__(self):
         return self.fullname()
 
     def fullname(self):
-        return self.template.name + '.' + self.name
+        return self.template.name + "." + self.name
 
 
-#----------------------------------------------------------
+# ----------------------------------------------------------
 
 
 class DatabaseSetOutputManager(models.Manager):
     def get_by_natural_key(self, set_natural_key, output_name):
         set_ = DatabaseSet.objects.get_by_natural_key(*set_natural_key)
-        return self.get(
-            set=set_,
-            template__name=output_name,
-        )
+        return self.get(set=set_, template__name=output_name)
 
 
 class DatabaseSetOutput(models.Model):
-    template = models.ForeignKey(DatabaseSetTemplateOutput,
-                                 related_name='instances', on_delete=models.CASCADE)
-    set = models.ForeignKey(DatabaseSet, related_name='outputs',
-                            on_delete=models.CASCADE)
+    template = models.ForeignKey(
+        DatabaseSetTemplateOutput, related_name="instances", on_delete=models.CASCADE
+    )
+    set = models.ForeignKey(
+        DatabaseSet, related_name="outputs", on_delete=models.CASCADE
+    )
 
     objects = DatabaseSetOutputManager()
 
@@ -460,7 +470,7 @@ class DatabaseSetOutput(models.Model):
         return self.fullname()
 
     def fullname(self):
-        return '%s.%s.%s.%s' % (
+        return "%s.%s.%s.%s" % (
             self.set.protocol.database.fullname(),
             self.set.protocol.name,
             self.set.name,
@@ -475,5 +485,8 @@ class DatabaseSetOutput(models.Model):
 
     def natural_key(self):
         return (self.set.natural_key(), self.template.name)
-    natural_key.dependencies = ['databases.databasesettemplateoutput',
-                                'databases.databaseset']
+
+    natural_key.dependencies = [
+        "databases.databasesettemplateoutput",
+        "databases.databaseset",
+    ]