AL-4081: Reformat with yapf

Author: dubininsergey

labelbox/client.py

@@ -767,7 +767,7 @@ def get_data_row_ids_for_external_ids(
             for row in self.execute(
                     query_str,
                 {'externalId_in': external_ids[i:i + max_ids_per_request]
-                 })['externalIdsToDataRowIds']:
+                })['externalIdsToDataRowIds']:
                 result[row['externalId']].append(row['dataRowId'])
         return result
 
@@ -1074,7 +1074,7 @@ def _format_failed_rows(rows: Dict[str, str],
         result_params = {
             "jobId":
                 assign_global_keys_to_data_rows_job["assignGlobalKeysToDataRows"
-                                                    ]["jobId"]
+                                                   ]["jobId"]
         }
 
         # Poll job status until finished, then retrieve results

labelbox/schema/batch.py

@@ -37,7 +37,12 @@ class Batch(DbObject):
     # Relationships
     created_by = Relationship.ToOne("User")
 
-    def __init__(self, client, project_id, *args, failed_data_row_ids=None, **kwargs):
+    def __init__(self,
+                 client,
+                 project_id,
+                 *args,
+                 failed_data_row_ids=None,
+                 **kwargs):
         super().__init__(client, *args, **kwargs)
         self.project_id = project_id
         self._failed_data_row_ids = failed_data_row_ids
@@ -77,7 +82,7 @@ def remove_queued_data_rows(self) -> None:
                 batch_id_param), {
                     project_id_param: self.project_id,
                     batch_id_param: self.uid
-            },
+                },
             experimental=True)
 
     def export_data_rows(self,
@@ -146,8 +151,8 @@ def delete(self) -> None:
                 batch_id_param), {
                     project_id_param: self.project_id,
                     batch_id_param: self.uid
-        },
-            experimental=True)
+                },
+                            experimental=True)
 
     def delete_labels(self, set_labels_as_template=False) -> None:
         """ Deletes labels that were created for data rows in the batch.
@@ -172,7 +177,7 @@ def delete_labels(self, set_labels_as_template=False) -> None:
                     type_param:
                         "RequeueDataWithLabelAsTemplate"
                         if set_labels_as_template else "RequeueData"
-            },
+                },
             experimental=True)
         return res
 

labelbox/schema/project.py

@@ -9,8 +9,10 @@
 
 import ndjson
 import requests
+
 from labelbox import utils
-from labelbox.exceptions import InvalidQueryError, LabelboxError, ProcessingWaitTimeout
+from labelbox.exceptions import (InvalidQueryError, LabelboxError,
+                                 ProcessingWaitTimeout)
 from labelbox.orm import query
 from labelbox.orm.db_object import DbObject, Deletable, Updateable
 from labelbox.orm.model import Entity, Field, Relationship
@@ -631,7 +633,10 @@ def create_batch(self,
                                   experimental=True)["project"][method]
         batch = res['batch']
         batch['size'] = len(dr_ids)
-        return Entity.Batch(self.client, self.uid, batch, failed_data_row_ids=res['failedDataRowIds'])
+        return Entity.Batch(self.client,
+                            self.uid,
+                            batch,
+                            failed_data_row_ids=res['failedDataRowIds'])
 
     def _update_queue_mode(self, mode: "QueueMode") -> "QueueMode":
         """
@@ -984,11 +989,15 @@ def _is_url_valid(url: Union[str, Path]) -> bool:
             raise ValueError(
                 f'Invalid annotations given of type: {type(annotations)}')
 
-    def _wait_until_data_rows_are_processed(self, data_row_ids: List[str], wait_processing_max_seconds: int, sleep_interval=30):
+    def _wait_until_data_rows_are_processed(self,
+                                            data_row_ids: List[str],
+                                            wait_processing_max_seconds: int,
+                                            sleep_interval=30):
         """ Wait until all the specified data rows are processed"""
         start_time = datetime.now()
         while True:
-            if (datetime.now() - start_time).total_seconds() >= wait_processing_max_seconds:
+            if (datetime.now() -
+                    start_time).total_seconds() >= wait_processing_max_seconds:
                 raise ProcessingWaitTimeout(
                     "Maximum wait time exceeded while waiting for data rows to be processed. Try creating a batch a bit later"
                 )
@@ -1013,7 +1022,8 @@ def __check_data_rows_have_been_processed(self, data_row_ids: List[str]):
         params = {}
         params[data_row_ids_param] = data_row_ids
         response = self.client.execute(query_str, params)
-        return response["queryAllDataRowsHaveBeenProcessed"]["allDataRowsHaveBeenProcessed"]
+        return response["queryAllDataRowsHaveBeenProcessed"][
+            "allDataRowsHaveBeenProcessed"]
 
 
 class ProjectMember(DbObject):

tests/integration/conftest.py

@@ -190,6 +190,7 @@ def dataset(client, rand_gen):
     yield dataset
     dataset.delete()
 
+
 @pytest.fixture(scope='function')
 def unique_dataset(client, rand_gen):
     dataset = client.create_dataset(name=rand_gen(str))

tests/integration/test_batch.py

@@ -97,50 +97,42 @@ def test_batch_project(batch_project: Project, small_dataset: Dataset):
 
 
 def test_batch_creation_for_data_rows_with_issues(
-    batch_project: Project,
-    small_dataset: Dataset,
-    dataset_with_invalid_data_rows: Dataset
-):
+        batch_project: Project, small_dataset: Dataset,
+        dataset_with_invalid_data_rows: Dataset):
     """
     Create a batch containing both valid and invalid data rows
     """
     valid_data_rows = [dr.uid for dr in list(small_dataset.data_rows())]
-    invalid_data_rows = [dr.uid for dr in list(
-        dataset_with_invalid_data_rows.data_rows())]
+    invalid_data_rows = [
+        dr.uid for dr in list(dataset_with_invalid_data_rows.data_rows())
+    ]
     data_rows_to_add = valid_data_rows + invalid_data_rows
 
     assert len(data_rows_to_add) == 5
-    batch = batch_project.create_batch(
-        "batch to test failed data rows",
-        data_rows_to_add
-    )
+    batch = batch_project.create_batch("batch to test failed data rows",
+                                       data_rows_to_add)
 
     assert len(batch.failed_data_row_ids) == 2
 
     failed_data_row_ids_set = set(batch.failed_data_row_ids)
     invalid_data_rows_set = set(invalid_data_rows)
-    assert len(failed_data_row_ids_set.intersection(
-        invalid_data_rows_set)) == 2
+    assert len(failed_data_row_ids_set.intersection(invalid_data_rows_set)) == 2
 
 
-def test_batch_creation_with_processing_timeout(
-    batch_project: Project,
-    small_dataset: Dataset,
-    unique_dataset: Dataset
-):
+def test_batch_creation_with_processing_timeout(batch_project: Project,
+                                                small_dataset: Dataset,
+                                                unique_dataset: Dataset):
     """
     Create a batch with zero wait time, this means that the waiting logic will throw exception immediately
     """
     #  wait for these data rows to be processed
     valid_data_rows = [dr.uid for dr in list(small_dataset.data_rows())]
     batch_project._wait_until_data_rows_are_processed(
-        valid_data_rows, wait_processing_max_seconds=3600, sleep_interval=5
-    )
+        valid_data_rows, wait_processing_max_seconds=3600, sleep_interval=5)
 
     # upload data rows for this dataset and don't wait
     upload_invalid_data_rows_for_dataset(unique_dataset)
-    unprocessed_data_rows = [dr.uid for dr in list(
-        unique_dataset.data_rows())]
+    unprocessed_data_rows = [dr.uid for dr in list(unique_dataset.data_rows())]
 
     data_row_ids = valid_data_rows + unprocessed_data_rows
 
@@ -149,10 +141,8 @@ def test_batch_creation_with_processing_timeout(
         # emulate the situation where there are still some data rows being
         # processed but wait timeout exceeded
         batch_project._wait_processing_max_seconds = 0
-        batch_project.create_batch(
-            "batch to test failed data rows",
-            data_row_ids
-        )
+        batch_project.create_batch("batch to test failed data rows",
+                                   data_row_ids)
     batch_project._wait_processing_max_seconds = stashed_wait_timeout