Added new batch functionality

Author: mattmanley

maproulette/api/challenge.py

@@ -1,6 +1,5 @@
 """This module contains the methods that the user will use directly to interact with MapRoulette challenges"""
 
-import geojson
 from maproulette.api.maproulette_server import MapRouletteServer
 from maproulette.models.challenge import ChallengeModel
 
@@ -260,42 +259,6 @@ def add_tasks_to_challenge(self, data, challenge_id):
             body=data)
         return response
 
-    def add_tasks_to_challenge_batch(self, data, challenge_id, batch_size=100):
-        """Method to add tasks to an existing challenge
-
-        :param data: a GeoJSON containing geometry of tasks to be added to a challenge
-        :param challenge_id: the ID corresponding to the challenge that tasks will be added to
-        :param batch_size: the number of features within the GeoJSON to send to the API at a time. Default is 100.
-        :returns: the API response from the PUT request
-        """
-        if isinstance(data, str):
-            try:
-                geojson.loads(data)
-            except ValueError
-        features = data['features']
-        feature_collection = {'type': 'FeatureCollection'}
-        remaining_features = len(features)
-        bundle = []
-        count = 0
-        for index, feature in enumerate(features):
-            bundle.append(feature)
-            count += 1
-            if count == batch_size:
-                feature_collection['features'] = bundle
-                self.add_tasks_to_challenge(
-                    challenge_id=challenge_id,
-                    data=feature_collection
-                )
-                remaining_features -= count
-                bundle = []
-                count = 0
-        if remaining_features > 0:
-            feature_collection['features'] = bundle
-            self.add_tasks_to_challenge(
-                challenge_id=challenge_id,
-                data=feature_collection
-            )
-
     def delete_challenge(self, challenge_id, immediate="false"):
         """Method to delete a challenge by using the corresponding challenge ID
 
@@ -351,11 +314,3 @@ def is_challenge_model(input_object):
         :returns: True if instance of model
         """
         return bool(isinstance(input_object, ChallengeModel))
-
-    @staticmethod
-    def string_to_geojson(input_object):
-        """Converts string to GeoJSON object using the geojson package
-
-        :param input_object: string representing the GeoJSON object
-        :return: a valid
-        """

maproulette/api/task.py

@@ -30,15 +30,20 @@ def get_task_history(self, task_id):
             endpoint=f"/task/{task_id}/history")
         return response
 
-    def create_tasks(self, data):
-        """Method to create a batch of tasks
+    def create_tasks(self, data, batch_size=100):
+        """Method to create a batch of tasks using the specified batch_size.
 
         :param data: a JSON input containing task details
+        :param batch_size: the number of tasks to post per API call. The default is 100.
+        :type batch_size: int
         :returns: the API response from the POST request
         """
-        response = self.post(
-            endpoint="/tasks",
-            body=data)
+        response = []
+        for batch in self.batch_generator(input_list=data, chunk_size=batch_size):
+            response.append(self.post(
+                endpoint="/tasks",
+                body=batch)
+            )
         return response
 
     def update_tasks(self, data):
@@ -157,3 +162,15 @@ def is_task_model(input_object):
         :returns: True if instance of model
         """
         return bool(isinstance(input_object, TaskModel))
+
+    @staticmethod
+    def batch_generator(input_list, chunk_size):
+        """Method to yield successive n-sized chunks from input_list
+
+        :param input_list: the list to break into chunks
+        :param chunk_size: the number of list items to include per chunk
+        :type chunk_size: int
+        :returns: an iterator for the n-sized chunks of the input_list
+        """
+        for i in range(0, len(input_list), chunk_size):
+            yield input_list[i:i + chunk_size]

maproulette/models/task.py

@@ -190,6 +190,7 @@ def to_dict(self):
             "id": self._id,
             "name": self._name,
             "parent": self._parent,
+            "geometries": self._geometries,
             "instruction": self._instruction,
             "location": self._location,
             "suggestedFix": self._suggested_fix,

requirements.txt

@@ -2,4 +2,3 @@ requests==2.23.0
 tox==3.14.5
 sphinx==2.4.4
 sphinx_rtd_theme
-geojson

tests/test_task_api.py

@@ -26,13 +26,16 @@ def test_get_task_history(self, mock_request, api_instance=api):
 
     @patch('maproulette.api.maproulette_server.requests.Session.post')
     def test_create_tasks(self, mock_request, api_instance=api):
+        test_tasks = []
         geometries = test_geojson['features'][0]['geometry']
         test_task_model = maproulette.TaskModel(name='test_task',
                                                 parent='12345',
                                                 geometries=geometries)
+        test_tasks.append(test_task_model.to_dict())
         mock_request.return_value.status_code = '200'
-        response = api_instance.create_tasks(test_task_model)
-        self.assertEqual(response['status'], '200')
+        responses = api_instance.create_tasks(test_tasks)
+        for response in responses:
+            self.assertEqual(response['status'], '200')
 
     @patch('maproulette.api.maproulette_server.requests.Session.put')
     def test_update_tasks(self, mock_request, api_instance=api):