Refactor and tidy

Author: helenst

weblab/experiments/models.py

@@ -10,7 +10,75 @@
 from repocache.models import CachedModelVersion, CachedProtocolVersion
 
 
-class Experiment(UserCreatedModelMixin, models.Model):
+class ExperimentMixin(models.Model):
+    """
+    Model mixin for different types of experiment
+
+    Models must have model, model_version, protocol and protocol_version fields
+    and be the parent of a Runnable-derived model.
+    """
+    def __str__(self):
+        return self.name
+
+    @property
+    def latest_version(self):
+        return self.versions.latest('created_at')
+
+    @property
+    def nice_model_version(self):
+        """Use tags to give a nicer representation of the commit id"""
+        return self.model_version.nice_version()
+
+    @property
+    def nice_protocol_version(self):
+        """Use tags to give a nicer representation of the commit id"""
+        return self.protocol_version.nice_version()
+
+    @property
+    def latest_result(self):
+        try:
+            return self.latest_version.status
+        except Runnable.DoesNotExist:
+            return ''
+
+    @property
+    def entities(self):
+        """Entity objects related to this experiment"""
+        return (self.model, self.protocol)
+
+    def is_visible_to_user(self, user):
+        """
+        Can the user view the experiment?
+
+        :param user: user to test against
+
+        :returns: True if the user is allowed to view the experiment, False otherwise
+        """
+        return visibility_check(self.visibility, self.viewers, user)
+
+    @property
+    def viewers(self):
+        """
+        Get users which have special permissions to view this experiment.
+
+        We take the intersection of users with special permissions to view each object
+        (model, fitting spec, etc) involved, if that object is private. If it's public,
+        we can ignore it because everyone can see it.
+
+        :return: `set` of `User` objects
+        """
+        viewers = [
+            obj.viewers
+            for obj in self.entities
+            if obj.visibility == Visibility.PRIVATE
+        ]
+        return set.intersection(*viewers) if viewers else {}
+
+    class Meta:
+        abstract = True
+
+
+class Experiment(ExperimentMixin, UserCreatedModelMixin, models.Model):
     """A specific version of a protocol run on a specific version of a model
 
     This class essentially just stores the model & protocol links. The results are
@@ -34,9 +102,6 @@ class Meta:
             ('create_experiment', 'Can create experiments'),
         )
 
-    def __str__(self):
-        return self.name
-
     @property
     def name(self):
         return self.get_name()
@@ -60,55 +125,6 @@ def get_name(self, model_version=False, proto_version=False):
     def visibility(self):
         return get_joint_visibility(self.model_version.visibility, self.protocol_version.visibility)
 
-    @property
-    def viewers(self):
-        """
-        Get users which have special permissions to view this experiment
-
-        We do not handle the case where both model and protocol are public,
-        since this would make the experiment also public and therefore
-        visible to every user - so calling this method makes very little sense.
-
-        :return: `set` of `User` objects
-        """
-        if self.protocol.visibility != Visibility.PRIVATE:
-            return self.model.viewers
-        elif self.model.visibility != Visibility.PRIVATE:
-            return self.protocol.viewers
-        else:
-            return self.model.viewers & self.protocol.viewers
-
-    def is_visible_to_user(self, user):
-        """
-        Can the user view the experiment?
-
-        :param user: user to test against
-
-        :returns: True if the user is allowed to view the experiment, False otherwise
-        """
-        return visibility_check(self.visibility, self.viewers, user)
-
-    @property
-    def latest_version(self):
-        return self.versions.latest('created_at')
-
-    @property
-    def nice_model_version(self):
-        """Use tags to give a nicer representation of the commit id"""
-        return self.model_version.nice_version()
-
-    @property
-    def nice_protocol_version(self):
-        """Use tags to give a nicer representation of the commit id"""
-        return self.protocol_version.nice_version()
-
-    @property
-    def latest_result(self):
-        try:
-            return self.latest_version.status
-        except Runnable.DoesNotExist:
-            return ''
-
 
 class Runnable(UserCreatedModelMixin, FileCollectionMixin, models.Model):
     """ Runnable base class

weblab/experiments/processing.py

@@ -45,6 +45,12 @@ class ProcessingException(Exception):
 
 
 def submit_runnable(runnable, body, user):
+    """Submit a Celery task to the Chaste backend
+
+    @param runnable Runnable object to submit
+    @param body dict of extra parameters to post to the request
+    @param user user making the request
+    """
     run = RunningExperiment.objects.create(runnable=runnable)
     signature = runnable.signature
 
@@ -93,8 +99,6 @@ def submit_runnable(runnable, body, user):
 
     runnable.save()
 
-    return runnable, True
-
 
 def submit_experiment(model, model_version, protocol, protocol_version, user, rerun_ok):
     """Submit a Celery task to run an experiment.
@@ -144,11 +148,11 @@ def submit_experiment(model, model_version, protocol, protocol_version, user, re
         'model': urljoin(settings.CALLBACK_BASE_URL, model_url),
         'protocol': urljoin(settings.CALLBACK_BASE_URL, protocol_url),
     }
-
     if protocol.is_fitting_spec:
         body['dataset'] = body['fittingSpec'] = body['protocol']
 
-    return submit_runnable(version, body, user)
+    submit_runnable(version, body, user)
+    return version, True
 
 
 def cancel_experiment(task_id):

weblab/fitting/models.py

@@ -1,15 +1,15 @@
 from django.db import models
 
 from core.models import UserCreatedModelMixin
-from core.visibility import Visibility, get_joint_visibility, visibility_check
+from core.visibility import get_joint_visibility
 from datasets.models import Dataset
 from entities.models import (
     Entity,
     EntityManager,
     ModelEntity,
     ProtocolEntity,
 )
-from experiments.models import Runnable
+from experiments.models import ExperimentMixin, Runnable
 from repocache.models import CachedFittingSpecVersion, CachedModelVersion, CachedProtocolVersion
 
 
@@ -59,7 +59,7 @@ def collaborators(self):
         return self.entity_ptr.collaborators
 
 
-class FittingResult(UserCreatedModelMixin, models.Model):
+class FittingResult(ExperimentMixin, UserCreatedModelMixin, models.Model):
     """Represents the result of running a parameter fitting experiment.
 
     This class essentially just stores the links to (particular versions of) a fitting spec,
@@ -69,7 +69,6 @@ class FittingResult(UserCreatedModelMixin, models.Model):
     There will only ever be one FittingResult for a given combination of model, protocol,
     dataset and fitting spec versions.
 
-    TODO: Consider creating a mixin for fields/methods shared with Experiment.
     """
     fittingspec = models.ForeignKey(FittingSpec, related_name='fitting_results')
     dataset = models.ForeignKey(Dataset, related_name='fitting_results')
@@ -91,9 +90,6 @@ class Meta:
             ('run_fits', 'Can run parameter fitting experiments'),
         )
 
-    def __str__(self):
-        return self.name
-
     @property
     def name(self):
         """There isn't an obvious easy naming for fitting results..."""
@@ -109,53 +105,8 @@ def visibility(self):
         )
 
     @property
-    def viewers(self):
-        """
-        Get users which have special permissions to view this experiment.
-
-        We take the intersection of users with special permissions to view each object
-        (model, fitting spec, etc) involved, if that object is private. If it's public,
-        we can ignore it because everyone can see it.
-
-        :return: `set` of `User` objects
-        """
-        viewers = [
-            obj.viewers
-            for obj in (self.fittingspec, self.dataset, self.model, self.protocol)
-            if obj.visibility == Visibility.PRIVATE
-        ]
-        return set.intersection(*viewers) if viewers else {}
-
-    def is_visible_to_user(self, user):
-        """
-        Can the user view the experiment?
-
-        :param user: user to test against
-
-        :returns: True if the user is allowed to view the experiment, False otherwise
-        """
-        return visibility_check(self.visibility, self.viewers, user)
-
-    @property
-    def latest_version(self):
-        return self.versions.latest('created_at')
-
-    @property
-    def nice_model_version(self):
-        """Use tags to give a nicer representation of the commit id"""
-        return self.model_version.nice_version()
-
-    @property
-    def nice_protocol_version(self):
-        """Use tags to give a nicer representation of the commit id"""
-        return self.protocol_version.nice_version()
-
-    @property
-    def latest_result(self):
-        try:
-            return self.latest_version.status
-        except Runnable.DoesNotExist:
-            return ''
+    def entities(self):
+        return (self.fittingspec, self.dataset, self.model, self.protocol)
 
 
 class FittingResultVersion(Runnable):

weblab/fitting/processing.py

@@ -80,4 +80,5 @@ def submit_fitting(
         'dataset': urljoin(settings.CALLBACK_BASE_URL, dataset_url),
     }
 
-    return submit_runnable(version, body, user)
+    submit_runnable(version, body, user)
+    return version, True