autopep8

select_template_api/apps.py

 from django.apps import AppConfig
 
+
 class ApiConfig(AppConfig):
     name = 'select_template_api'

select_template_api/models.py

@@ -21,21 +21,23 @@ STATUS_CHOICES = ((st, st) for st in (
 
 # Create your models here.
 
+
 class SelectTemplateTask(models.Model):
     """This class represents the tasklist model."""
 
     uuid = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)
 
     query_id = models.CharField(max_length=50, blank=False, unique=False)
-    query_sequence = models.CharField(max_length=2000, blank=False, unique=False)
+    query_sequence = models.CharField(
+        max_length=2000, blank=False, unique=False)
 
     #user = models.ForeignKey(User, on_delete=models.CASCADE)
 
-    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default=STATUS_UNKNOWN)
+    status = models.CharField(
+        max_length=10, choices=STATUS_CHOICES, default=STATUS_UNKNOWN)
     message = models.CharField(max_length=150)
     date_created = models.DateTimeField(auto_now_add=True)
     date_modified = models.DateTimeField(auto_now=True)
-    results_csv = models.CharField(max_length=100000, blank=True)
     results_json = models.CharField(max_length=100000, blank=True)
 
     client_ip = models.GenericIPAddressField(default="0.0.0.0")
@@ -47,23 +49,31 @@ class SelectTemplateTask(models.Model):
     def __str__(self):
         """Return a human readable representation of this instance."""
         return "[{}] uuid: {}, status: {}, remote_task_id: {}, started: {}, last_updated: {}, client_ip: {}".format(
-            self.id, self.uuid, self.status, self.remote_task_id, self.date_created, self.date_modified, self.client_ip)
+            self.pk, self.uuid, self.status, self.remote_task_id, self.date_created, self.date_modified, self.client_ip)
 
     @property
     def query_fasta(self):
+        """Retrieves the query sequence in FASTA format"""
+
         return ">{}\n{}\n".format(self.query_id, self.query_sequence)
 
     def submit_remote_task(self):
+        """Submits the task to the remote server"""
+
         LOG.info("submit_remote_task: %s", self.query_id)
         submit_response = self.api_client.submit(self.query_fasta)
         remote_task_id = submit_response.task_id
-        LOG.info("submit_remote_task.response: (%s) %s %s", type(submit_response), str(submit_response.__dict__), remote_task_id)
+        LOG.info("submit_remote_task.response: (%s) %s %s", type(
+            submit_response), str(submit_response.__dict__), remote_task_id)
         self.remote_task_id = remote_task_id
         self.save()
         return remote_task_id
 
     def update_remote_task(self):
-        LOG.info("update_remote_task: %s '%s'", self.query_id, self.remote_task_id)
+        """Updates the task by performing a status request on the remote server"""
+
+        LOG.info("update_remote_task: %s '%s'",
+                 self.query_id, self.remote_task_id)
 
         if not self.remote_task_id:
             LOG.info("update_remote_task: %s no_remote_task_id", self)
@@ -76,23 +86,20 @@ class SelectTemplateTask(models.Model):
         try:
             check_response = self.api_client.check(self.remote_task_id)
         except Exception as e:
-            LOG.error("encountered error when checking remote task: (%s) %s", type(e), e)
+            LOG.error(
+                "encountered error when checking remote task: (%s) %s", type(e), e)
             raise
         msg = check_response.message
 
         # make these checks explicit so we can add extra hooks to each stage
         if msg == 'done':
             results_response = self.api_client.results(self.remote_task_id)
-            try:
-                self.results_csv = results_response.as_csv()
-            except Exception as e:
-                LOG.error("encountered an error when outputting results as CSV: [%s] %s", type(e), e)
-                raise
-            
+
             try:
                 self.results_json = results_response.as_json()
             except Exception as e:
-                LOG.error("encountered an error when outputting results as JSON: [%s] %s", type(e), e)
+                LOG.error(
+                    "encountered an error when outputting results as JSON: [%s] %s", type(e), e)
                 raise
 
             self.status = STATUS_SUCCESS
@@ -105,9 +112,7 @@ class SelectTemplateTask(models.Model):
             self.status = STATUS_ERROR
         else:
             self.status = STATUS_ERROR
-            self.message = "CheckResponse returned unexpected message '{}'".format(msg)
+            self.message = "CheckResponse returned unexpected message '{}'".format(
+                msg)
 
         self.save()
-
-    def retrieve_results(self):
-        pass

select_template_api/serializers.py

@@ -8,14 +8,17 @@ from .models import SelectTemplateTask
 
 LOG = logging.getLogger(__name__)
 
+
 class SelectTemplateQuerySerializer(serializers.ModelSerializer):
     """Serializer to map the Model instance into JSON format"""
 
     class Meta:
         """Meta class to map serializer's fields with the model fields."""
         model = SelectTemplateTask
-        fields = ('uuid', 'status', 'message', 'query_id', 'query_sequence', 'date_created', 'date_modified')
-        read_only_fields = ('status', 'message', 'date_created', 'date_modified',)
+        fields = ('uuid', 'status', 'message', 'query_id',
+                  'query_sequence', 'date_created', 'date_modified')
+        read_only_fields = ('status', 'message',
+                            'date_created', 'date_modified',)
 
     def create(self, validated_data):
         """
@@ -24,14 +27,18 @@ class SelectTemplateQuerySerializer(serializers.ModelSerializer):
         LOG.info("%s.create(%s)", __name__, str(validated_data))
         return SelectTemplateTask.objects.create(**validated_data)
 
+
 class SelectTemplateStatusSerializer(serializers.ModelSerializer):
     """Serializer to map the Model instance into JSON format"""
 
     class Meta:
         """Meta class to map serializer's fields with the model fields."""
         model = SelectTemplateTask
-        fields = ('uuid', 'status', 'message', 'date_created', 'date_modified',)
-        read_only_fields = ('status', 'message', 'date_created', 'date_modified',)
+        fields = ('uuid', 'status', 'message',
+                  'date_created', 'date_modified',)
+        read_only_fields = ('status', 'message',
+                            'date_created', 'date_modified',)
+
 
 class SelectTemplateResultsSerializer(serializers.ModelSerializer):
     """Serializer to map the Model instance into JSON format"""
@@ -39,5 +46,7 @@ class SelectTemplateResultsSerializer(serializers.ModelSerializer):
     class Meta:
         """Meta class to map serializer's fields with the model fields."""
         model = SelectTemplateTask
-        fields = ('uuid', 'status', 'message', 'date_created', 'date_modified', 'results_csv', 'results_json',)
-        read_only_fields = ('status', 'message', 'date_created', 'date_modified', 'results_csv', 'results_json',)
+        fields = ('uuid', 'status', 'message', 'date_created',
+                  'date_modified', 'results_json',)
+        read_only_fields = ('status', 'message', 'date_created',
+                            'date_modified', 'results_json',)

select_template_api/tests.py

@@ -15,13 +15,14 @@ from .models import SelectTemplateTask
 from .models import STATUS_UNKNOWN, STATUS_QUEUED, STATUS_RUNNING, STATUS_ERROR, STATUS_SUCCESS
 
 LOG = logging.getLogger(__name__)
-#logging.basicConfig()
+# logging.basicConfig()
 
 # Create your tests here.
 
 DEFAULT_QUERY_ID = "test_query_id"
 DEFAULT_QUERY_SEQ = "MNDFHRDTWAEVDLDAIYDNVANLRRLLPDDTHIMAVVKANAYGDVQVARTALEAGASRLAVAFLDEALALREKGIEAPILVLGASRPADAALAAQQRIALTVFRSDWLEEASALYSGPFPIHFHLKMDTGMGRLGVKDEEETKRIVALIERHPHFVLEGVYTHFATADEVNTDYFSYQYTRFLHMLEWLPSRPPLVHCANSAASLRFPDRTFNMVRFGIAMYGLAPSPGIKPLLPYPLKEAFSLHSRLVHVKKLQPGEKVSYGATYTAQTEEWIGTIPIGYADGWLRRLQH"
 
+
 class ModelTestCase(TestCase):
     """This class defines the test suite for the select template model."""
 
@@ -39,6 +40,7 @@ class ModelTestCase(TestCase):
         new_count = SelectTemplateTask.objects.count()
         self.assertNotEqual(old_count, new_count)
 
+
 class ViewTestCase(TestCase):
     """Test suite for the api views."""
 
@@ -72,7 +74,7 @@ class ViewTestCase(TestCase):
             reverse('select_template_api:create_selecttemplate'),
             self.template_task_data,
             format="json")
-        
+
         return response
 
     def check_task(self, task_uuid):
@@ -80,29 +82,31 @@ class ViewTestCase(TestCase):
         self.assertTrue(task_uuid)
 
         response = self.client.get(
-            reverse('select_template_api:status_selecttemplate', kwargs={'uuid': task_uuid}),
+            reverse('select_template_api:status_selecttemplate',
+                    kwargs={'uuid': task_uuid}),
             format="json")
 
         return response
 
-    def get_task_results_csv(self, task_uuid):
+    def get_task_results_json(self, task_uuid):
 
         self.assertTrue(task_uuid)
 
         response = self.client.get(
-            reverse('select_template_api:results_selecttemplate', kwargs={'uuid': task_uuid}),
+            reverse('select_template_api:results_selecttemplate',
+                    kwargs={'uuid': task_uuid}),
             format="json")
 
         results_data = response.json()
         # LOG.info("results_data: %s", results_data)
 
-        return results_data['results_csv']
-
+        return results_data['results_json']
 
     def test_api_create_task_requires_auth(self):
         """Test the api cannot create tasks without authentication"""
 
-        self.assertEqual(reverse('select_template_api:create_selecttemplate'), '/api/select-template/')
+        self.assertEqual(
+            reverse('select_template_api:create_selecttemplate'), '/api/select-template/')
 
         response = self.client.post(
             reverse('select_template_api:create_selecttemplate'),
@@ -129,7 +133,7 @@ class ViewTestCase(TestCase):
 
     def test_api_create_task_with_auth(self):
         """Test the api can create a task after auth"""
-        
+
         tasks_before = SelectTemplateTask.objects.count()
 
         create_response = self.submit_default_task_with_auth()
@@ -146,7 +150,8 @@ class ViewTestCase(TestCase):
 
         task_from_db = SelectTemplateTask.objects.get(uuid=task_uuid)
 
-        self.assertEqual(task_from_db.query_sequence, self.template_task_data['query_sequence'])
+        self.assertEqual(task_from_db.query_sequence,
+                         self.template_task_data['query_sequence'])
 
         self.assertEqual(create_response.status_code, status.HTTP_201_CREATED)
 
@@ -172,7 +177,6 @@ class ViewTestCase(TestCase):
         # remove test task from database
         task.delete()
 
-
     def test_api_can_delete_task(self):
         """Test the api can delete a task."""
 
@@ -183,7 +187,8 @@ class ViewTestCase(TestCase):
         self.client.credentials(HTTP_AUTHORIZATION='Token '+token)
 
         response = self.client.delete(
-            reverse('select_template_api:status_selecttemplate', kwargs={'uuid': task.uuid}),
+            reverse('select_template_api:status_selecttemplate',
+                    kwargs={'uuid': task.uuid}),
             format='json',
             follow=True)
 
@@ -201,32 +206,34 @@ class ViewTestCase(TestCase):
         while True:
             check_counter += 1
             if check_counter >= max_checks:
-                raise Exception("Exceeded maximum number of loops ({}) while waiting for task to complete".format(max_checks))
+                raise Exception(
+                    "Exceeded maximum number of loops ({}) while waiting for task to complete".format(max_checks))
 
             res_check = self.check_task(task_uuid)
             res_check_data = res_check.json()
 
             if 'status' not in res_check_data:
-                raise Exception("check response does not have 'status' field: %s", res_check_data)
+                raise Exception(
+                    "check response does not have 'status' field: {}".format(res_check_data))
 
             task_status = res_check_data['status']
             if task_status in [STATUS_QUEUED, STATUS_RUNNING]:
                 pass
             elif task_status == STATUS_ERROR:
-                raise Exception("check response has reported error state {}".format(res_check))
+                raise Exception(
+                    "check response has reported error state {}".format(res_check))
             elif task_status == STATUS_SUCCESS:
                 break
             else:
-                raise Exception("check response reported unknown status '{}'".format(task_status))
+                raise Exception(
+                    "check response reported unknown status '{}'".format(task_status))
 
             time.sleep(1)
 
-        res_results = self.get_task_results_csv(task_uuid)
+        res_results = self.get_task_results_json(task_uuid)
         self.assertTrue(res_results)
 
-
     def tearDown(self):
         """Remove testing data, users, etc"""
 
         self.testuser.delete()
-

select_template_api/urls.py

@@ -4,8 +4,8 @@ from django.conf.urls import url
 from rest_framework.authtoken import views
 from rest_framework.urlpatterns import format_suffix_patterns
 
-from .views import (SelectTemplateTaskCreateView, SelectTemplateTaskStatusView, 
-    SelectTemplateTaskResultsView)
+from .views import (SelectTemplateTaskCreateView, SelectTemplateTaskStatusView,
+                    SelectTemplateTaskResultsView)
 
 app_name = "select_template_api"
 

select_template_api/views.py

@@ -6,16 +6,16 @@ from django.shortcuts import get_object_or_404
 
 from rest_framework import generics, status
 from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticatedOrReadOnly
 
-from .serializers import (SelectTemplateQuerySerializer, SelectTemplateStatusSerializer, 
-    SelectTemplateResultsSerializer)
-    
+from .serializers import (SelectTemplateQuerySerializer, SelectTemplateStatusSerializer,
+                          SelectTemplateResultsSerializer)
+
 from .models import SelectTemplateTask
-from .models import STATUS_UNKNOWN, STATUS_QUEUED, STATUS_RUNNING, STATUS_ERROR, STATUS_SUCCESS
+from .models import STATUS_ERROR
 
 LOG = logging.getLogger(__name__)
 
+
 class TemplateTaskView(object):
     """Generic view for TemplateTask."""