Format with black and isort (#448)

Author: Rodrigo Almeida

docs/conf.py

@@ -14,8 +14,8 @@
 import sys
 
 sys.path.insert(0, os.path.abspath(".."))
-import sphinx_bootstrap_theme
 import numpy as np
+import sphinx_bootstrap_theme
 
 # -- Project information -----------------------------------------------------
 

setup.py

@@ -1,9 +1,10 @@
-import os
-import sys
-import subprocess
 import logging
-from setuptools import setup, find_packages
+import os
 import re
+import subprocess
+import sys
+
+from setuptools import find_packages, setup
 
 
 def get_version():

solaris/tile/raster_tile.py

@@ -10,6 +10,7 @@
 
 # from rio_cogeo.cogeo import cog_validate, cog_translate
 from ..utils.core import _check_crs, _check_rasterio_im_load
+
 # removing the following until COG functionality is implemented
 # from ..utils.tile import read_cog_tile
 from ..utils.geo import raster_get_projection_unit, reproject, split_geom

tests/test_cli/compare.py

@@ -1,36 +1,39 @@
 import os
-import numpy as np
-import skimage
 import pickle
-import networkx as nx
 import sys
 
-im_fnames = ['sample_fp_mask.tif',
-             'sample_fbc_mask.tif',
-             'sample_c_mask.tif',
-             'sample_b_inner_mask.tif',
-             'sample_b_outer10_mask.tif']
+import networkx as nx
+import numpy as np
+import skimage
+
+im_fnames = [
+    "sample_fp_mask.tif",
+    "sample_fbc_mask.tif",
+    "sample_c_mask.tif",
+    "sample_b_inner_mask.tif",
+    "sample_b_outer10_mask.tif",
+]
 
 
 def main(path):
     os.chdir(path)  # set to the directory containing this script
 
     # compare expected mask results and truth images
     for im_fname in im_fnames:
-        truth_im = skimage.io.imread(os.path.join('expected', im_fname))
-        result_im = skimage.io.imread(os.path.join('results', im_fname))
+        truth_im = skimage.io.imread(os.path.join("expected", im_fname))
+        result_im = skimage.io.imread(os.path.join("results", im_fname))
         assert np.array_equal(truth_im, result_im)
 
     # compare graphs
-    with open(os.path.join('expected', 'sample_graph.pkl'), 'rb') as f:
+    with open(os.path.join("expected", "sample_graph.pkl"), "rb") as f:
         truth_graph = pickle.load(f)
         f.close()
-    with open(os.path.join('results', 'sample_graph.pkl'), 'rb') as f:
+    with open(os.path.join("results", "sample_graph.pkl"), "rb") as f:
         result_graph = pickle.load(f)
         f.close()
 
     assert nx.is_isomorphic(truth_graph, result_graph)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv[1])

tests/test_cli/test_cli.py

@@ -1,9 +1,10 @@
 import os
-import numpy as np
 import pickle
 import subprocess
-import skimage.io
+
 import networkx as nx
+import numpy as np
+import skimage.io
 
 data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../data/"))
 
@@ -65,7 +66,9 @@ def test_make_masks(self):
             if os.path.exists(os.path.join(dest_dir, im_fname)):
                 os.remove(os.path.join(dest_dir, im_fname))
             # run the CLI command
-            subprocess.run(cmd_start + os.path.join(dest_dir, im_fname) + arg, shell=True)
+            subprocess.run(
+                cmd_start + os.path.join(dest_dir, im_fname) + arg, shell=True
+            )
             truth_im = skimage.io.imread(os.path.join(expected_dir, im_fname))
             result_im = skimage.io.imread(os.path.join(dest_dir, im_fname))
             # compare the expected to the result

tests/test_data/test_coco.py

@@ -1,55 +1,81 @@
-from solaris.data.coco import geojson2coco
 import json
 import os
 
+from solaris.data.coco import geojson2coco
+
 data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../data/"))
 
+
 class TestGeoJSON2COCO(object):
     """Tests for the ``geojson2coco`` function."""
 
     def test_multiclass_single_geojson(self):
-        sample_geojson = os.path.join(data_dir, 'geotiff_labels.geojson')
-        sample_image = os.path.join(data_dir, 'sample_geotiff.tif')
-
-        coco_dict = geojson2coco(sample_image, sample_geojson,
-                                 category_attribute='truncated',
-                                 output_path=os.path.join(data_dir,
-                                                          'tmp_coco.json'))
-        with open(os.path.join(data_dir, 'coco_sample_2.json'), 'r') as f:
+        sample_geojson = os.path.join(data_dir, "geotiff_labels.geojson")
+        sample_image = os.path.join(data_dir, "sample_geotiff.tif")
+
+        coco_dict = geojson2coco(
+            sample_image,
+            sample_geojson,
+            category_attribute="truncated",
+            output_path=os.path.join(data_dir, "tmp_coco.json"),
+        )
+        with open(os.path.join(data_dir, "coco_sample_2.json"), "r") as f:
             expected_dict = json.load(f)
-        with open(os.path.join(data_dir, 'tmp_coco.json'), 'r') as f:
+        with open(os.path.join(data_dir, "tmp_coco.json"), "r") as f:
             saved_result = json.load(f)
-        ## Simplified test due to rounding errors- JSS    
-        assert coco_dict['annotations'][0]['bbox'] == expected_dict['annotations'][0]['bbox']
-        assert saved_result['annotations'][0]['bbox'] == expected_dict['annotations'][0]['bbox']
-        os.remove(os.path.join(data_dir, 'tmp_coco.json'))
+        ## Simplified test due to rounding errors- JSS
+        assert (
+            coco_dict["annotations"][0]["bbox"]
+            == expected_dict["annotations"][0]["bbox"]
+        )
+        assert (
+            saved_result["annotations"][0]["bbox"]
+            == expected_dict["annotations"][0]["bbox"]
+        )
+        os.remove(os.path.join(data_dir, "tmp_coco.json"))
 
     def test_singleclass_multi_geojson(self):
-        sample_geojsons = [os.path.join(data_dir, 'vectortile_test_expected/geoms_733601_3724734.geojson'),
-                           os.path.join(data_dir, 'vectortile_test_expected/geoms_733601_3724869.geojson')]
-        sample_images = [os.path.join(data_dir, 'rastertile_test_expected/sample_geotiff_733601_3724734.tif'),
-                         os.path.join(data_dir, 'rastertile_test_expected/sample_geotiff_733601_3724869.tif')]
-
-        coco_dict = geojson2coco(sample_images,
-                                 sample_geojsons,
-                                 matching_re=r'(\d+_\d+)',
-                                 license_dict={'CC-BY 4.0': 'https://creativecommons.org/licenses/by/4.0/'},
-                                 verbose=0)
-
-        with open(os.path.join(data_dir, 'coco_sample_1.json'), 'r') as f:
+        sample_geojsons = [
+            os.path.join(
+                data_dir, "vectortile_test_expected/geoms_733601_3724734.geojson"
+            ),
+            os.path.join(
+                data_dir, "vectortile_test_expected/geoms_733601_3724869.geojson"
+            ),
+        ]
+        sample_images = [
+            os.path.join(
+                data_dir, "rastertile_test_expected/sample_geotiff_733601_3724734.tif"
+            ),
+            os.path.join(
+                data_dir, "rastertile_test_expected/sample_geotiff_733601_3724869.tif"
+            ),
+        ]
+
+        coco_dict = geojson2coco(
+            sample_images,
+            sample_geojsons,
+            matching_re=r"(\d+_\d+)",
+            license_dict={"CC-BY 4.0": "https://creativecommons.org/licenses/by/4.0/"},
+            verbose=0,
+        )
+
+        with open(os.path.join(data_dir, "coco_sample_1.json"), "r") as f:
             expected_dict = json.load(f)
         ## Simplified test due to rounding errors- JSS
-        assert expected_dict['annotations'][0]['bbox'] == coco_dict['annotations'][0]['bbox']
+        assert (
+            expected_dict["annotations"][0]["bbox"]
+            == coco_dict["annotations"][0]["bbox"]
+        )
 
     def test_from_directories(self):
-        sample_geojsons = os.path.join(data_dir, 'vectortile_test_expected')
-        sample_images = os.path.join(data_dir, 'rastertile_test_expected')
-        coco_dict = geojson2coco(sample_images,
-                                 sample_geojsons,
-                                 matching_re=r'(\d+_\d+)',
-                                 verbose=0)
-        with open(os.path.join(data_dir, 'coco_sample_3.json'), 'r') as f:
+        sample_geojsons = os.path.join(data_dir, "vectortile_test_expected")
+        sample_images = os.path.join(data_dir, "rastertile_test_expected")
+        coco_dict = geojson2coco(
+            sample_images, sample_geojsons, matching_re=r"(\d+_\d+)", verbose=0
+        )
+        with open(os.path.join(data_dir, "coco_sample_3.json"), "r") as f:
             expected_dict = json.load(f)
         # this test had issues due to rounding errors, I therefore lowered the
         # barrier to passing - NW
-        assert len(expected_dict['annotations']) == len(coco_dict['annotations'])
+        assert len(expected_dict["annotations"]) == len(coco_dict["annotations"])

tests/test_eval/evaluator_test.py

@@ -1,21 +1,24 @@
 import os
-from solaris.eval.base import Evaluator
-import solaris
+
 import geopandas as gpd
 import pandas as pd
 
+import solaris
+from solaris.eval.base import Evaluator
+
 data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../data/"))
 
+
 class TestEvaluator(object):
     def test_init_from_file(self):
         """Test instantiation of an Evaluator instance from a file."""
-        base_instance = Evaluator(os.path.join(data_dir,
-                                               'gt.geojson'))
+        base_instance = Evaluator(os.path.join(data_dir, "gt.geojson"))
         gdf = solaris.data.gt_gdf()
         assert base_instance.ground_truth_sindex.bounds == gdf.sindex.bounds
         assert base_instance.proposal_GDF.equals(gpd.GeoDataFrame([]))
         assert base_instance.ground_truth_GDF.equals(
-            base_instance.ground_truth_GDF_Edit)
+            base_instance.ground_truth_GDF_Edit
+        )
 
     def test_init_from_gdf(self):
         """Test instantiation of an Evaluator from a pre-loaded GeoDataFrame."""
@@ -24,72 +27,76 @@ def test_init_from_gdf(self):
         assert base_instance.ground_truth_sindex.bounds == gdf.sindex.bounds
         assert base_instance.proposal_GDF.equals(gpd.GeoDataFrame([]))
         assert base_instance.ground_truth_GDF.equals(
-            base_instance.ground_truth_GDF_Edit)
+            base_instance.ground_truth_GDF_Edit
+        )
 
     def test_init_empty_geojson(self):
         """Test instantiation of Evaluator with an empty geojson file."""
-        base_instance = Evaluator(os.path.join(data_dir,
-                                               'empty.geojson'))
-        expected_gdf = gpd.GeoDataFrame({'sindex': [],
-                                         'condition': [],
-                                         'geometry': []})
+        base_instance = Evaluator(os.path.join(data_dir, "empty.geojson"))
+        expected_gdf = gpd.GeoDataFrame({"sindex": [], "condition": [], "geometry": []})
         assert base_instance.ground_truth_GDF.equals(expected_gdf)
 
     def test_score_proposals(self):
         """Test reading in a proposal GDF from a geojson and scoring it."""
-        eb = Evaluator(os.path.join(data_dir, 'gt.geojson'))
-        eb.load_proposal(os.path.join(data_dir, 'pred.geojson'))
+        eb = Evaluator(os.path.join(data_dir, "gt.geojson"))
+        eb.load_proposal(os.path.join(data_dir, "pred.geojson"))
         pred_gdf = solaris.data.pred_gdf()
         assert eb.proposal_GDF.iloc[:, 0:3].sort_index().equals(pred_gdf)
-        expected_score = [{'class_id': 'all',
-                           'iou_field': 'iou_score_all',
-                           'TruePos': 8,
-                           'FalsePos': 20,
-                           'FalseNeg': 20,
-                           'Precision': 0.2857142857142857,
-                           'Recall': 0.2857142857142857,
-                           'F1Score': 0.2857142857142857}]
+        expected_score = [
+            {
+                "class_id": "all",
+                "iou_field": "iou_score_all",
+                "TruePos": 8,
+                "FalsePos": 20,
+                "FalseNeg": 20,
+                "Precision": 0.2857142857142857,
+                "Recall": 0.2857142857142857,
+                "F1Score": 0.2857142857142857,
+            }
+        ]
         scores = eb.eval_iou(calculate_class_scores=False)
         assert scores == expected_score
 
     def test_score_proposals_return_gdfs(self):
-        eb = Evaluator(os.path.join(data_dir, 'gt.geojson'))
-        eb.load_proposal(os.path.join(data_dir, 'pred.geojson'))
-        expected_score = [{'class_id': 'all',
-                           'iou_field': 'iou_score_all',
-                           'TruePos': 8,
-                           'FalsePos': 20,
-                           'FalseNeg': 20,
-                           'Precision': 0.2857142857142857,
-                           'Recall': 0.2857142857142857,
-                           'F1Score': 0.2857142857142857}]
+        eb = Evaluator(os.path.join(data_dir, "gt.geojson"))
+        eb.load_proposal(os.path.join(data_dir, "pred.geojson"))
+        expected_score = [
+            {
+                "class_id": "all",
+                "iou_field": "iou_score_all",
+                "TruePos": 8,
+                "FalsePos": 20,
+                "FalseNeg": 20,
+                "Precision": 0.2857142857142857,
+                "Recall": 0.2857142857142857,
+                "F1Score": 0.2857142857142857,
+            }
+        ]
         scores, tp_gdf, fn_gdf, fp_gdf = eb.eval_iou_return_GDFs(
-            calculate_class_scores=False)
+            calculate_class_scores=False
+        )
         assert scores == expected_score
-        assert len(tp_gdf) == expected_score[0]['TruePos']
-        assert len(fp_gdf) == expected_score[0]['FalsePos']
-        assert len(fn_gdf) == expected_score[0]['FalseNeg']
+        assert len(tp_gdf) == expected_score[0]["TruePos"]
+        assert len(fp_gdf) == expected_score[0]["FalsePos"]
+        assert len(fn_gdf) == expected_score[0]["FalseNeg"]
 
     def test_iou_by_building(self):
         """Test output of ground truth table with per-building IoU scores"""
         data_folder = data_dir
-        path_truth = os.path.join(data_folder, 'SN2_sample_truth.csv')
-        path_pred = os.path.join(data_folder, 'SN2_sample_preds.csv')
-        path_ious = os.path.join(data_folder, 'SN2_sample_iou_by_building.csv')
-        path_temp = './temp.pd'
+        path_truth = os.path.join(data_folder, "SN2_sample_truth.csv")
+        path_pred = os.path.join(data_folder, "SN2_sample_preds.csv")
+        path_ious = os.path.join(data_folder, "SN2_sample_iou_by_building.csv")
+        path_temp = "./temp.pd"
         eb = Evaluator(path_truth)
-        eb.load_proposal(path_pred, conf_field_list=['Confidence'],
-                         proposalCSV=True)
-        eb.eval_iou_spacenet_csv(miniou=0.5, imageIDField='ImageId',
-                                 min_area=20)
+        eb.load_proposal(path_pred, conf_field_list=["Confidence"], proposalCSV=True)
+        eb.eval_iou_spacenet_csv(miniou=0.5, imageIDField="ImageId", min_area=20)
         output = eb.get_iou_by_building()
         result_actual = pd.DataFrame(output)
-        result_actual.sort_values(by=['ImageId', 'BuildingId'], inplace=True)
-        ious_actual = list(result_actual['iou_score'])
+        result_actual.sort_values(by=["ImageId", "BuildingId"], inplace=True)
+        ious_actual = list(result_actual["iou_score"])
         result_expected = pd.read_csv(path_ious, index_col=0)
-        result_expected.sort_values(by=['ImageId', 'BuildingId'], inplace=True)
-        ious_expected = list(result_expected['iou_score'])
-        maxdifference = max([abs(x-y) for x, y in zip(ious_actual,
-                                                      ious_expected)])
-        epsilon = 1E-9
+        result_expected.sort_values(by=["ImageId", "BuildingId"], inplace=True)
+        ious_expected = list(result_expected["iou_score"])
+        maxdifference = max([abs(x - y) for x, y in zip(ious_actual, ious_expected)])
+        epsilon = 1e-9
         assert maxdifference < epsilon

tests/test_eval/iou_test.py

@@ -1,7 +1,8 @@
-from solaris.eval.iou import calculate_iou, process_iou
-from solaris import data
-from shapely.geometry import Polygon
 import numpy as np
+from shapely.geometry import Polygon
+
+from solaris import data
+from solaris.eval.iou import calculate_iou, process_iou
 
 
 class TestEvalFuncs(object):