conforming to yapf style

Author: TumanyanV

superannotate/common.py

@@ -33,12 +33,14 @@
     "FailedAfterEvaluationWithSavedModel": 6
 }
 
+
 class PredictionSegmentationStatuses(IntEnum):
     NotStarted = 1
     InProgress = 2
     Completed = 3
     Failed = 4
 
+
 def model_training_status_int_to_str(project_status):
     for item in _MODEL_TRAINING_STATUSES:
         if _MODEL_TRAINING_STATUSES[item] == project_status:
@@ -289,6 +291,8 @@ def process_api_response(data):
         return data
 
     return data['data']
+
+
 def tqdm_converter(
     total_num, images_converted, images_not_converted, finish_event
 ):

superannotate/db/images.py

@@ -132,6 +132,7 @@ def process_result(x):
     else:
         return result_list
 
+
 @project_metadata
 def get_image_metadata(project, image_names):
     """Returns image metadata
@@ -148,14 +149,14 @@ def get_image_metadata(project, image_names):
         image_names = [image_names]
 
     json_req = {
-        'project_id' : project['id'],
-        'team_id' : _api.team_id,
-        'names' : image_names
+        'project_id': project['id'],
+        'team_id': _api.team_id,
+        'names': image_names
     }
-    response =_api.send_request(
+    response = _api.send_request(
         req_type='POST',
-        path = '/images/getBulk',
-        json_req = json_req,
+        path='/images/getBulk',
+        json_req=json_req,
     )
 
     metadata = response.json()

superannotate/ml/ml_funcs.py

@@ -52,7 +52,8 @@ def run_prediction(project, images_list, model):
     model = model.get(project['type'], None)
     if not model:
         raise SABaseException(
-            0, f"Specified project has type {project['type']}, and does not correspond to the type of provided model"
+            0,
+            f"Specified project has type {project['type']}, and does not correspond to the type of provided model"
         )
     project_id = project["id"]
 
@@ -126,9 +127,7 @@ def run_segmentation(project, images_list, model):
         raise SABaseException(0, "Model Does not exist")
 
     images_metadata = get_image_metadata(project, images_list)
-    images_metadata.sort(
-        key=lambda x: x["name"]
-    )
+    images_metadata.sort(key=lambda x: x["name"])
 
     if len(images_metadata) == 0:
         raise SABaseException(0, "No valid image names were provided")
@@ -223,7 +222,8 @@ def run_training(
             "The base model has to be of the same type (vector or pixel) as the projects"
         )
         raise SABaseException(
-            0, f"The type of provided projects is {project_type}, and does not correspond to the type of provided model"
+            0,
+            f"The type of provided projects is {project_type}, and does not correspond to the type of provided model"
         )
 
     for item in DEFAULT_HYPERPARAMETERS:
@@ -368,7 +368,11 @@ def get_plottable_cols(df):
         plottable_cols = []
         for sub_df in df:
             col_names = sub_df.columns.values.tolist()
-            plottable_cols += [col_name for col_name in col_names if col_name not in plottable_cols and col_name not in NON_PLOTABLE_KEYS]
+            plottable_cols += [
+                col_name
+                for col_name in col_names if col_name not in plottable_cols and
+                col_name not in NON_PLOTABLE_KEYS
+            ]
         return plottable_cols
 
     if not isinstance(metric_json_list, list):
@@ -399,11 +403,14 @@ def get_plottable_cols(df):
         specs=figure_specs,
         subplot_titles=plottable_cols,
     )
-    figure.update_layout(height=1000* num_rows)
+    figure.update_layout(height=1000 * num_rows)
     models = [os.path.basename(x).split('.')[0] for x in metric_json_list]
 
     plot_df(full_c_metrics, plottable_c_cols, figure)
-    plot_df(full_pe_metrics, plottable_pe_cols, figure, len(plottable_c_cols) + 1)
+    plot_df(
+        full_pe_metrics, plottable_pe_cols, figure,
+        len(plottable_c_cols) + 1
+    )
     figure.show()
 
 

superannotate/ml/ml_models.py

@@ -4,7 +4,6 @@
 from ..common import project_type_int_to_str
 import logging
 
-
 logger = logging.getLogger("superannotate-python-sdk")
 _api = API.get_instance()
 
@@ -38,4 +37,3 @@ def search_models(
     if not result['data']:
         raise SABaseException(0, "Model with such a name does not exist")
     return result['data']
-

superannotate/ml/utils.py

@@ -6,11 +6,13 @@
 import time
 import os
 
+
 def metric_is_plottable(key):
-    if key in PLOTTABLE_METRICS or 'mIoU'in key or 'mAP' in key or key == 'iteration':
+    if key in PLOTTABLE_METRICS or 'mIoU' in key or 'mAP' in key or key == 'iteration':
         return True
     return False
 
+
 def reformat_metrics_json(data, name):
     continuous_metrics = []
     per_evaluation_metrics = []
@@ -26,18 +28,18 @@ def reformat_metrics_json(data, name):
             per_evaluation_metrics += [item]
     continuous_metrics_df = pd.DataFrame.from_dict(continuous_metrics)
     per_evaluation_metrics_df = pd.DataFrame.from_dict(per_evaluation_metrics)
-    continuous_metrics_df = drop_non_plotable_cols(
-        continuous_metrics_df
-    )
+    continuous_metrics_df = drop_non_plotable_cols(continuous_metrics_df)
     per_evaluation_metrics_df = drop_non_plotable_cols(
         per_evaluation_metrics_df
     )
     continuous_metrics_df['model'] = name
     per_evaluation_metrics_df['model'] = name
     if 'total_loss' in per_evaluation_metrics_df:
-        per_evaluation_metrics_df = per_evaluation_metrics_df.drop(columns='total_loss')
+        per_evaluation_metrics_df = per_evaluation_metrics_df.drop(
+            columns='total_loss'
+        )
 
-    per_evaluation_metrics_df = per_evaluation_metrics_df.dropna(axis = 'rows')
+    per_evaluation_metrics_df = per_evaluation_metrics_df.dropna(axis='rows')
     return continuous_metrics_df, per_evaluation_metrics_df
 
 
@@ -53,25 +55,41 @@ def make_plotly_specs(num_rows):
     specs = [[{"secondary_y": True}] for x in range(num_rows)]
     return specs
 
+
 def get_images_prediction_segmentation_status(project, image_names, task):
-    metadata = get_image_metadata(project,image_names)
+    metadata = get_image_metadata(project, image_names)
     if isinstance(metadata, dict):
         metadata = [metadata]
-    success_names = [x['name'] for x in metadata if x[task] == PredictionSegmentationStatuses.Completed]
-    failure_names = [x['name'] for x in metadata if x[task] == PredictionSegmentationStatuses.Failed]
+    success_names = [
+        x['name']
+        for x in metadata if x[task] == PredictionSegmentationStatuses.Completed
+    ]
+    failure_names = [
+        x['name']
+        for x in metadata if x[task] == PredictionSegmentationStatuses.Failed
+    ]
     return success_names, failure_names
 
-def log_process(project, image_name_set, total_image_count,status_key, task, logger):
+
+def log_process(
+    project, image_name_set, total_image_count, status_key, task, logger
+):
     num_complete = 0
     succeded_imgs = []
     failed_imgs = []
     while image_name_set:
-        succeded_imgs_batch, failed_imgs_batch = get_images_prediction_segmentation_status(project, list(image_name_set), status_key)
+        succeded_imgs_batch, failed_imgs_batch = get_images_prediction_segmentation_status(
+            project, list(image_name_set), status_key
+        )
         complete_images = succeded_imgs_batch + failed_imgs_batch
         succeded_imgs += succeded_imgs_batch
         failed_imgs += failed_imgs_batch
         num_complete += len(complete_images)
-        logger.info(f"{task} complete on {num_complete} / {total_image_count} images")
-        image_name_set = image_name_set.symmetric_difference(set(complete_images))
+        logger.info(
+            f"{task} complete on {num_complete} / {total_image_count} images"
+        )
+        image_name_set = image_name_set.symmetric_difference(
+            set(complete_images)
+        )
         time.sleep(5)
     return (succeded_imgs, failed_imgs)

superannotate/parameter_decorators.py

@@ -37,7 +37,8 @@ def inner(*args, **kwargs):
             if current_chosen_type is str:
                 for idx, item in enumerate(new_kwargs['project']):
                     new_kwargs['project'][idx] = get_project_metadata_bare(
-                        item, include_complete_image_count=include_complete_image_count
+                        item,
+                        include_complete_image_count=include_complete_image_count
                     )
             elif current_chosen_type is not dict:
                 raise SABaseException(
@@ -86,8 +87,11 @@ def inner(*args, **kwargs):
                     0,
                     f"The specifed model does not exist. Available models are {list(all_models_name_map.keys())}"
                 )
-            elif (func.__name__ == 'run_prediction' or func.__name__ == 'run_training'):
-                new_model_arg = {x['type']:x for x in all_models}
+            elif (
+                func.__name__ == 'run_prediction' or
+                func.__name__ == 'run_training'
+            ):
+                new_model_arg = {x['type']: x for x in all_models}
             elif len(all_models) == 2:
                 raise SABaseException(
                     0,

tests/test_ml_funcs.py

@@ -4,7 +4,6 @@
 from .common import upload_project
 import pytest
 
-
 sa.init(Path.home() / ".superannotate" / "config.json")
 PROJECT_NAME_VECTOR = 'ML Functionality Test Vector'
 PROJECT_NAME_PIXEL = 'ML Functionality Test Pixel'
@@ -14,46 +13,63 @@
 
 MODEL_NAME = 'Instance segmentation (trained on COCO)'
 
+
 @pytest.mark.skipif(
     "SA_STRESS_TESTS" not in os.environ,
     reason="Requires env variable to be set"
 )
 def test_run_prediction():
 
     upload_project(
-        Path(PROJECT_PATH_VECTOR) ,PROJECT_NAME_VECTOR,  "Test for ml functionality", "Vector"
+        Path(PROJECT_PATH_VECTOR), PROJECT_NAME_VECTOR,
+        "Test for ml functionality", "Vector"
     )
 
     upload_project(
-        Path(PROJECT_PATH_PIXEL),PROJECT_NAME_PIXEL,  "Test for ml functionality", "Pixel"
+        Path(PROJECT_PATH_PIXEL), PROJECT_NAME_PIXEL,
+        "Test for ml functionality", "Pixel"
     )
 
     #Tests for the case when provided images do not exist in the project
     with pytest.raises(SABaseException) as e:
-        sa.run_prediction(PROJECT_NAME_VECTOR, ["NonExistantImage.jpg"], MODEL_NAME)
+        sa.run_prediction(
+            PROJECT_NAME_VECTOR, ["NonExistantImage.jpg"], MODEL_NAME
+        )
         assert str(e) == "No valid image names were provided"
 
     #Tests that the argument 'project' is valid
     with pytest.raises(SABaseException) as e:
-        sa.run_prediction([PROJECT_NAME_VECTOR, PROJECT_NAME_PIXEL], ["DoesntMatter.jpg"], MODEL_NAME)
-        assert str(e) == "smart prediction cannot be run on images from different projects simultaneously"
+        sa.run_prediction(
+            [PROJECT_NAME_VECTOR, PROJECT_NAME_PIXEL], ["DoesntMatter.jpg"],
+            MODEL_NAME
+        )
+        assert str(
+            e
+        ) == "smart prediction cannot be run on images from different projects simultaneously"
 
     #Tests if prediction on all available images gets run
     image_names_pixel = sa.search_images(PROJECT_NAME_PIXEL)
     image_names_vector = sa.search_images(PROJECT_NAME_VECTOR)
 
-    succeded_imgs, failed_imgs = sa.run_prediction(PROJECT_NAME_VECTOR, image_names_vector[:4], MODEL_NAME)
-    assert(len(succeded_imgs) + len(failed_imgs)) == 4
-
-    succeded_imgs, failed_imgs = sa.run_prediction(PROJECT_NAME_PIXEL,image_names_pixel[:4],  MODEL_NAME)
-    assert(len(succeded_imgs) + len(failed_imgs)) == 4
+    succeded_imgs, failed_imgs = sa.run_prediction(
+        PROJECT_NAME_VECTOR, image_names_vector[:4], MODEL_NAME
+    )
+    assert (len(succeded_imgs) + len(failed_imgs)) == 4
 
-    succeded_imgs, failed_imgs = sa.run_prediction(PROJECT_NAME_PIXEL, image_names_pixel[:4] + ["NA.jpg"], MODEL_NAME)
-    assert(len(succeded_imgs) + len(failed_imgs)) == 4
+    succeded_imgs, failed_imgs = sa.run_prediction(
+        PROJECT_NAME_PIXEL, image_names_pixel[:4], MODEL_NAME
+    )
+    assert (len(succeded_imgs) + len(failed_imgs)) == 4
 
-    succeded_imgs, failed_imgs = sa.run_prediction(PROJECT_NAME_VECTOR, image_names_vector[:4] + ["NA.jpg"], MODEL_NAME)
-    assert(len(succeded_imgs) + len(failed_imgs)) == 4
+    succeded_imgs, failed_imgs = sa.run_prediction(
+        PROJECT_NAME_PIXEL, image_names_pixel[:4] + ["NA.jpg"], MODEL_NAME
+    )
+    assert (len(succeded_imgs) + len(failed_imgs)) == 4
 
+    succeded_imgs, failed_imgs = sa.run_prediction(
+        PROJECT_NAME_VECTOR, image_names_vector[:4] + ["NA.jpg"], MODEL_NAME
+    )
+    assert (len(succeded_imgs) + len(failed_imgs)) == 4
 
 
 @pytest.mark.skipif(
@@ -66,40 +82,46 @@ def test_run_segmentation():
     model_generic = 'generic'
 
     upload_project(
-        Path(PROJECT_PATH_PIXEL), PROJECT_NAME_PIXEL, "Test for ml functionality", "Pixel"
+        Path(PROJECT_PATH_PIXEL), PROJECT_NAME_PIXEL,
+        "Test for ml functionality", "Pixel"
     )
 
     image_names_pixel = sa.search_images(PROJECT_NAME_PIXEL)
     with pytest.raises(SABaseException) as e:
-        res = sa.run_segmentation(PROJECT_NAME_VECTOR, image_names_pixel, model_auto)
+        res = sa.run_segmentation(
+            PROJECT_NAME_VECTOR, image_names_pixel, model_auto
+        )
         assert str(e) == "Operation not supported for given project type"
     with pytest.raises(SABaseException) as e:
         sa.run_segmentation(
             PROJECT_NAME_PIXEL, image_names_pixel[:2], "NonExistantModel"
-
         )
         assert str(e) == "Model Does not exist"
 
     with pytest.raises(SABaseException) as e:
-        sa.run_segmentation(PROJECT_NAME_PIXEL, ["NonExistantImage.jpg"], MODEL_NAME)
+        sa.run_segmentation(
+            PROJECT_NAME_PIXEL, ["NonExistantImage.jpg"], MODEL_NAME
+        )
         assert str(e) == "No valid image names were provided"
 
-    succeded_imgs, failed_imgs = sa.run_segmentation(PROJECT_NAME_PIXEL, image_names_pixel[:4] + ["NA.jpg"], model_generic)
-    assert(len(succeded_imgs) + len(failed_imgs)) == 4
+    succeded_imgs, failed_imgs = sa.run_segmentation(
+        PROJECT_NAME_PIXEL, image_names_pixel[:4] + ["NA.jpg"], model_generic
+    )
+    assert (len(succeded_imgs) + len(failed_imgs)) == 4
 
-    succeded_imgs, failed_imgs = sa.run_segmentation(ROJECT_NAME_PIXEL, image_names_pixel[:4] + ["NA.jpg"], Pmodel_auto)
+    succeded_imgs, failed_imgs = sa.run_segmentation(
+        ROJECT_NAME_PIXEL, image_names_pixel[:4] + ["NA.jpg"], Pmodel_auto
+    )
+
+    assert (len(succeded_imgs) + len(failed_imgs)) == 4
 
-    assert(len(succeded_imgs) + len(failed_imgs)) == 4
 
 def test_download_model(tmpdir):
     print(tmpdir)
     export_dir = Path(tmpdir / 'export')
     export_dir.mkdir(parents=True, exist_ok=True)
 
-    ml_model = sa.search_models(include_global = True)[0]
+    ml_model = sa.search_models(include_global=True)[0]
     Path.rmdir(Path(tmpdir) / './export')
     assert (sa.download_model(ml_model, './export') == True)
     assert (sa.download_model(ml_model['name'], './export') == True)
-
-
-

tests/test_preannotation_upload.py

@@ -7,7 +7,6 @@
 import superannotate as sa
 
 
-
 @pytest.mark.parametrize(
     "project_type,name,description,from_folder", [
         (