Use foreign keys for model/proto version references in Experiment table

weblab/conftest.py

@@ -173,7 +173,9 @@ def queued_experiment(model_with_version, protocol_with_version):
     version = recipes.experiment_version.make(
         status='QUEUED',
         experiment__model=model_with_version,
+        experiment__model_version=model_with_version.repocache.latest_version,
         experiment__protocol=protocol_with_version,
+        experiment__protocol_version=protocol_with_version.repocache.latest_version,
     )
     recipes.running_experiment.make(experiment_version=version)
     return version
@@ -184,7 +186,9 @@ def experiment_with_result(model_with_version, protocol_with_version):
     version = recipes.experiment_version.make(
         status='SUCCESS',
         experiment__model=model_with_version,
+        experiment__model_version=model_with_version.repocache.latest_version,
         experiment__protocol=protocol_with_version,
+        experiment__protocol_version=protocol_with_version.repocache.latest_version,
     )
     version.mkdir()
     with (version.abs_path / 'result.txt').open('w') as f:
@@ -197,19 +201,19 @@ def experiment_version(public_model, public_protocol):
     return recipes.experiment_version.make(
         status='SUCCESS',
         experiment__model=public_model,
-        experiment__model_version=public_model.repo.latest_commit.sha,
+        experiment__model_version=public_model.repocache.latest_version,
         experiment__protocol=public_protocol,
-        experiment__protocol_version=public_protocol.repo.latest_commit.sha,
+        experiment__protocol_version=public_protocol.repocache.latest_version,
     )
 
 
 @pytest.fixture
 def quick_experiment_version(helpers):
     """An experiment version that exists only in the DB - no model/proto repos, no results."""
     model = recipes.model.make()
-    model_version = str(helpers.add_fake_version(model, 'public').sha)
+    model_version = helpers.add_fake_version(model, 'public')
     protocol = recipes.protocol.make()
-    protocol_version = str(helpers.add_fake_version(protocol, 'public').sha)
+    protocol_version = helpers.add_fake_version(protocol, 'public')
     return recipes.experiment_version.make(
         status='SUCCESS',
         experiment__model=model,
@@ -224,9 +228,9 @@ def moderated_experiment_version(moderated_model, moderated_protocol):
     return recipes.experiment_version.make(
         status='SUCCESS',
         experiment__model=moderated_model,
-        experiment__model_version=moderated_model.repo.latest_commit.sha,
+        experiment__model_version=moderated_model.repocache.latest_version,
         experiment__protocol=moderated_protocol,
-        experiment__protocol_version=moderated_protocol.repo.latest_commit.sha,
+        experiment__protocol_version=moderated_protocol.repocache.latest_version,
     )
 
 

weblab/core/recipes.py

@@ -22,23 +22,26 @@
 
 analysis_task = Recipe('AnalysisTask', entity=foreign_key(protocol))
 
+cached_model = Recipe('CachedModel')
+cached_model_version = Recipe('CachedModelVersion')
+cached_model_tag = Recipe('CachedModelTag')
+
+cached_protocol = Recipe('CachedProtocol')
+cached_protocol_version = Recipe('CachedProtocolVersion')
+cached_protocol_tag = Recipe('CachedProtocolTag')
+
 experiment = Recipe(
     'Experiment',
     model=foreign_key(model),
-    protocol=foreign_key(protocol)
+    model_version=foreign_key(cached_model_version),
+    protocol=foreign_key(protocol),
+    protocol_version=foreign_key(cached_protocol_version),
 )
 
-running_experiment = Recipe('RunningExperiment')
-
 experiment_version = Recipe('ExperimentVersion', experiment=foreign_key(experiment))
 
-cached_model = Recipe('CachedModel')
-cached_model_version = Recipe('CachedModelVersion')
-cached_model_tag = Recipe('CachedModelTag')
+running_experiment = Recipe('RunningExperiment', experiment_version=foreign_key(experiment_version))
 
-cached_protocol = Recipe('CachedProtocol')
-cached_protocol_version = Recipe('CachedProtocolVersion')
-cached_protocol_tag = Recipe('CachedProtocolTag')
 
 dataset = Recipe('Dataset',
                  name=seq('mydataset'),

weblab/entities/models.py

@@ -94,18 +94,6 @@ def repo_abs_path(self):
             self.author.get_storage_dir('repo'), '%ss' % self.entity_type, str(self.id)
         )
 
-    def nice_version(self, sha_or_tag):
-        """
-        Returns tag/sha with ellipses
-
-        :param sha_or_tag: version sha or tag string
-        :return version_name: string with the sha_or_tag formatted
-        """
-        version_name = self.repocache.get_name_for_version(sha_or_tag)
-        if len(version_name) > 20:
-            version_name = version_name[:8] + '...'
-        return version_name
-
     def get_visibility_from_repo(self, commit):
         """
         Get the visibility of the given entity version from the repository

weblab/entities/processing.py

@@ -159,17 +159,17 @@ def record_experiments_to_run(user, entity, commit):
         # Find visible experiments involving this parent
         parent_kwargs = {
             entity.entity_type: entity,
-            entity.entity_type + '_version': parent.sha,
+            entity.entity_type + '_version': entity.repocache.get_version(parent.sha),
         }
         for expt in Experiment.objects.filter(**parent_kwargs):
             if expt.is_visible_to_user(user):
                 # Record the new experiment to run
                 kwargs = {
                     'submitter': user,
                     'model_id': expt.model_id,
-                    'model_version': expt.model_version,
+                    'model_version': expt.model_version.sha,
                     'protocol_id': expt.protocol_id,
-                    'protocol_version': expt.protocol_version,
+                    'protocol_version': expt.protocol_version.sha,
                 }
                 kwargs.update(new_version_kwargs)
                 PlannedExperiment.objects.get_or_create(**kwargs)

weblab/entities/templatetags/entities.py

@@ -115,16 +115,12 @@ def url_entity_diff_base(context, entity_type):
 
 @register.filter
 def name_of_model(experiment):
-    model = experiment.model
-    model_version = model.repocache.get_name_for_version(experiment.model_version)
-    return '%s @ %s' % (model.name, model_version)
+    return '%s @ %s' % (experiment.model.name, experiment.model_version.get_name())
 
 
 @register.filter
 def name_of_protocol(experiment):
-    protocol = experiment.protocol
-    protocol_version = protocol.repocache.get_name_for_version(experiment.protocol_version)
-    return '%s @ %s' % (protocol.name, protocol_version)
+    return '%s @ %s' % (experiment.protocol.name, experiment.protocol_version.get_name())
 
 
 def _url_friendly_label(entity, version):

weblab/entities/tests/test_models.py

@@ -92,14 +92,6 @@ def test_repo_abs_path(self, fake_repo_path):
         assert model.repo._root == path
         assert str(model.repo_abs_path) == path
 
-    def test_nice_version(self, model_with_version):
-        commit = model_with_version.repo.latest_commit.sha
-        assert model_with_version.nice_version(commit) == '%s...' % commit[:8]
-
-        model_with_version.repo.tag('v1')
-        populate_entity_cache(model_with_version)
-        assert model_with_version.nice_version(commit) == 'v1'
-
     def test_set_and_get_version_visibility(self, model_with_version):
         commit = model_with_version.repo.latest_commit
         assert model_with_version.get_version_visibility(commit.sha) == 'private'

weblab/entities/tests/test_templatetags.py

@@ -105,9 +105,9 @@ def test_name_of_entity_linked_to_experiment(model_with_version, protocol_with_v
     exp = recipes.experiment_version.make(
         status='SUCCESS',
         experiment__model=model_with_version,
-        experiment__model_version=model_with_version.repo.latest_commit.sha,
+        experiment__model_version=model_with_version.cachedentity.latest_version,
         experiment__protocol=protocol_with_version,
-        experiment__protocol_version=protocol_with_version.repo.latest_commit.sha,
+        experiment__protocol_version=protocol_with_version.cachedentity.latest_version,
     ).experiment
 
     assert entity_tags.name_of_model(exp) == '%s @ v1' % model_with_version.name

weblab/entities/tests/test_views.py

@@ -183,6 +183,7 @@ def test_version_with_two_tags(self, client, helpers):
         version = model.repocache.latest_version
         model.add_tag('tag1', version.sha)
         model.add_tag('tag2', version.sha)
+
         self.check(client, '/entities/models/%d/versions/%s' % (model.pk, version.sha), version, ['tag1', 'tag2'])
         self.check(client, '/entities/models/%d/versions/%s' % (model.pk, 'tag1'), version, ['tag1', 'tag2'])
         self.check(client, '/entities/models/%d/versions/%s' % (model.pk, 'tag2'),
@@ -445,52 +446,52 @@ def test_complex_visibilities(self, client, logged_in_user, other_user, helpers)
 class TestModelEntityCompareExperimentsView:
     def test_shows_related_experiments(self, client, helpers, experiment_version):
         exp = experiment_version.experiment
-        sha = exp.model.repo.latest_commit.sha
+        model_version = exp.model.repocache.latest_version
         recipes.experiment_version.make()  # another experiment which should not be included
         exp.model.set_version_visibility('latest', 'public')
         exp.protocol.set_version_visibility('latest', 'public')
-
+        helpers.add_version(exp.protocol, visibility='public')
         # Add an experiment with a newer version of the protocol but that was created earlier
         exp2 = recipes.experiment_version.make(
             experiment__protocol=exp.protocol,
-            experiment__protocol_version=helpers.add_version(exp.protocol, visibility='public').sha,
+            experiment__protocol_version=exp.protocol.repocache.latest_version,
             experiment__model=exp.model,
-            experiment__model_version=sha,
+            experiment__model_version=model_version,
         ).experiment
         exp2.created_at = exp.created_at - timedelta(seconds=10)
         exp2.save()
 
         # Add an experiment with a newer version of the protocol and that was created later
+        helpers.add_version(exp.protocol, visibility='public')
         exp3 = recipes.experiment_version.make(
             experiment__protocol=exp.protocol,
-            experiment__protocol_version=helpers.add_version(exp.protocol, visibility='public').sha,
+            experiment__protocol_version=exp.protocol.repocache.latest_version,
             experiment__model=exp.model,
-            experiment__model_version=sha,
+            experiment__model_version=model_version,
         ).experiment
 
         response = client.get(
-            '/entities/models/%d/versions/%s/compare' % (exp.model.pk, sha)
+            '/entities/models/%d/versions/%s/compare' % (exp.model.pk, model_version.sha)
         )
 
         assert response.status_code == 200
         assert response.context['comparisons'] == [(exp.protocol, [exp3, exp2, exp])]
 
     def test_applies_visibility(self, client, helpers, experiment_version):
         exp = experiment_version.experiment
-        sha = exp.model_version
         protocol = recipes.protocol.make()
         exp.model.set_version_visibility('latest', 'public')
         exp.protocol.set_version_visibility('latest', 'public')
-
+        protocol_version = helpers.add_version(protocol, visibility='private')
         recipes.experiment_version.make(
             experiment__protocol=protocol,
-            experiment__protocol_version=helpers.add_version(protocol, visibility='private').sha,
+            experiment__protocol_version=protocol.repocache.get_version(protocol_version.sha),
             experiment__model=exp.model,
-            experiment__model_version=sha,
+            experiment__model_version=exp.model_version,
         )  # should not be included for visibility reasons
 
         response = client.get(
-            '/entities/models/%d/versions/%s/compare' % (exp.model.pk, sha)
+            '/entities/models/%d/versions/%s/compare' % (exp.model.pk, exp.model_version.sha)
         )
 
         assert response.status_code == 200
@@ -527,16 +528,16 @@ def test_shows_related_experiments(self, client, logged_in_user, experiment_vers
 
     def test_applies_visibility(self, client, helpers, experiment_version):
         exp = experiment_version.experiment
-        sha = exp.protocol_version
+        sha = exp.protocol_version.sha
         model = recipes.model.make()
         exp.protocol.set_version_visibility('latest', 'public')
         exp.model.set_version_visibility('latest', 'public')
-
+        model_version = helpers.add_version(model, visibility='private')
         recipes.experiment_version.make(
             experiment__protocol=exp.protocol,
-            experiment__protocol_version=sha,
+            experiment__protocol_version=exp.protocol.repocache.get_version(sha),
             experiment__model=model,
-            experiment__model_version=helpers.add_version(model, visibility='private').sha,
+            experiment__model_version=model.repocache.get_version(model_version.sha),
         )  # should not be included for visibility reasons
 
         response = client.get(
@@ -1182,9 +1183,9 @@ def _add_experiment(proto_author, proto_vis, shared=False,
             recipes.experiment_version.make(
                 status='SUCCESS',
                 experiment__model=model,
-                experiment__model_version=model_commit.sha,
+                experiment__model_version=model.repocache.get_version(model_commit.sha),
                 experiment__protocol=proto,
-                experiment__protocol_version=proto_commit.sha,
+                experiment__protocol_version=proto.repocache.get_version(proto_commit.sha),
             )
             if shared:
                 assign_perm('edit_entity', logged_in_user, proto)
@@ -2218,9 +2219,9 @@ def test_view_run_experiment_model_post_exclude_existing(self, client, helpers,
         recipes.experiment_version.make(
             status='SUCCESS',
             experiment__model=model,
-            experiment__model_version=commit_model.sha,
+            experiment__model_version=model.repocache.get_version(commit_model.sha),
             experiment__protocol=protocol,
-            experiment__protocol_version=commit1.sha)
+            experiment__protocol_version=protocol.repocache.get_version(commit1.sha),)
 
         # Test context has correct information
         response = client.get(
@@ -2482,15 +2483,15 @@ def test_view_run_experiment_protocol_post_exclude_existing(self, client, helper
         recipes.experiment_version.make(
             status='SUCCESS',
             experiment__model=model,
-            experiment__model_version=commit1.sha,
+            experiment__model_version=model.repocache.get_version(commit1.sha),
             experiment__protocol=protocol,
-            experiment__protocol_version=commit_protocol.sha)
+            experiment__protocol_version=protocol.repocache.get_version(commit_protocol.sha))
         # This experiment has no versions so should not be excluded
         recipes.experiment.make(
             model=model,
-            model_version=commit2.sha,
+            model_version=model.repocache.get_version(commit2.sha),
             protocol=protocol,
-            protocol_version=commit_protocol.sha)
+            protocol_version=protocol.repocache.get_version(commit_protocol.sha))
 
         version1 = model.repocache.get_version(commit1.sha)
         version2 = model.repocache.get_version(commit2.sha)