nit updates

Author: jtsodapop

labelbox/data/annotation_types/data/tiled_image.py

@@ -8,7 +8,7 @@
 import requests
 import numpy as np
 
-from retry import retry
+from google.api_core import retry
 from PIL import Image
 from pyproj import Transformer
 from pygeotile.point import Point as PygeoPoint
@@ -27,8 +27,6 @@
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-#TODO: need to add pyproj, pygeotile, retry to dependencies
-
 
 class EPSG(Enum):
     """ Provides the EPSG for tiled image assets that are currently supported.
@@ -147,14 +145,10 @@ def as_raster_data(self,
         if self.tile_bounds.epsg == EPSG.SIMPLEPIXEL:
             xstart, ystart, xend, yend = self._get_simple_image_params(zoom)
 
-        # Currently our editor doesn't support anything other than 3857.
-        # Since the user provided projection is ignored by the editor
-        #    we will ignore it here and assume that the projection is 3857.
         elif self.tile_bounds.epsg == EPSG.EPSG3857:
             xstart, ystart, xend, yend = self._get_3857_image_params(zoom)
         else:
-            raise ValueError(
-                f"Unsupported epsg found...{self.tile_bounds.epsg}")
+            raise ValueError(f"Unsupported epsg found: {self.tile_bounds.epsg}")
 
         self._validate_num_tiles(xstart, ystart, xend, yend, max_tiles)
 
@@ -244,47 +238,33 @@ def _fetch_image_for_bounds(self,
         
         If a tile cannot be fetched, a padding of expected tile size is instead added.
         """
-        tiles = {}
+
         if multithread:
+            tiles = {}
             with ThreadPoolExecutor(
                     max_workers=TILE_DOWNLOAD_CONCURRENCY) as exc:
                 for x in range(x_tile_start, x_tile_end + 1):
                     for y in range(y_tile_start, y_tile_end + 1):
                         tiles[(x, y)] = exc.submit(self._fetch_tile, x, y, zoom)
 
-            rows = []
-            for y in range(y_tile_start, y_tile_end + 1):
-                row = []
-                for x in range(x_tile_start, x_tile_end + 1):
-                    try:
-                        row.append(tiles[(x, y)].result())
-                    except:
-                        row.append(
-                            np.zeros(shape=(self.tile_size, self.tile_size, 3),
-                                     dtype=np.uint8))
-                rows.append(np.hstack(row))
-        #no multithreading
-        else:
+        rows = []
+        for y in range(y_tile_start, y_tile_end + 1):
+            row = []
             for x in range(x_tile_start, x_tile_end + 1):
-                for y in range(y_tile_start, y_tile_end + 1):
-                    try:
-                        tiles[(x, y)] = self._fetch_tile(x, y, zoom)
-                    except:
-                        tiles[(x, y)] = np.zeros(shape=(self.tile_size,
-                                                        self.tile_size, 3),
-                                                 dtype=np.uint8)
-
-            rows = []
-            for y in range(y_tile_start, y_tile_end + 1):
-                rows.append(
-                    np.hstack([
-                        tiles[(x, y)]
-                        for x in range(x_tile_start, x_tile_end + 1)
-                    ]))
+                try:
+                    if multithread:
+                        row.append(tiles[(x, y)].result())
+                    else:
+                        row.append(self._fetch_tile(x, y, zoom))
+                except:
+                    row.append(
+                        np.zeros(shape=(self.tile_size, self.tile_size, 3),
+                                 dtype=np.uint8))
+            rows.append(np.hstack(row))
 
         return np.vstack(rows)
 
-    @retry(delay=1, tries=5, backoff=2, max_delay=8)
+    @retry.Retry(initial=1, maximum=16, multiplier=2)
     def _fetch_tile(self, x: int, y: int, z: int) -> np.ndarray:
         """
         Fetches the image and returns an np array.
@@ -293,9 +273,7 @@ def _fetch_tile(self, x: int, y: int, z: int) -> np.ndarray:
         data.raise_for_status()
         decoded = np.array(Image.open(BytesIO(data.content)))[..., :3]
         if decoded.shape[:2] != (self.tile_size, self.tile_size):
-            logger.warning(
-                f"Unexpected tile size {decoded.shape}. Results aren't guarenteed to be correct."
-            )
+            logger.warning(f"Unexpected tile size {decoded.shape}.")
         return decoded
 
     def _crop_to_bounds(

requirements.txt

@@ -12,3 +12,5 @@ PILLOW
 opencv-python
 typeguard
 imagesize
+pyproj
+pygeotile

setup.py

@@ -22,17 +22,14 @@
     install_requires=[
         "backoff==1.10.0",
         "backports-datetime-fromisoformat==1.0.0; python_version < '3.7.0'",
-        "dataclasses==0.7; python_version < '3.7.0'",
-        "ndjson==0.3.1",
-        "requests>=2.22.0",
-        "google-api-core>=1.22.1",
-        "pydantic>=1.8,<2.0",
-        "tqdm",
+        "dataclasses==0.7; python_version < '3.7.0'", "ndjson==0.3.1",
+        "requests>=2.22.0", "google-api-core>=1.22.1", "pydantic>=1.8,<2.0",
+        "tqdm"
     ],
     extras_require={
         'data': [
             "shapely", "geojson", "numpy", "rasterio", "PILLOW",
-            "opencv-python", "typeguard", "imagesize"
+            "opencv-python", "typeguard", "imagesize", "pyproj", "pygeotile"
         ],
     },
     classifiers=[

tests/data/annotation_types/test_tiled_image.py

@@ -1,11 +1,9 @@
 import pytest
-from labelbox.data.annotation_types.data import tiled_image
 from labelbox.data.annotation_types.geometry.point import Point
 from labelbox.data.annotation_types.data.tiled_image import (EPSG, TiledBounds,
                                                              TileLayer,
                                                              TiledImageData)
 from pydantic import ValidationError
-from retry import retry
 
 
 @pytest.mark.parametrize("epsg", list(EPSG))
@@ -16,7 +14,7 @@ def test_epsg(epsg):
 @pytest.mark.parametrize("epsg", list(EPSG))
 def test_tiled_bounds(epsg):
     top_left = Point(x=0, y=0)
-    bottom_right = Point(x=100, y=100)
+    bottom_right = Point(x=50, y=50)
 
     tiled_bounds = TiledBounds(epsg=epsg, bounds=[top_left, bottom_right])
     assert isinstance(tiled_bounds, TiledBounds)
@@ -31,18 +29,23 @@ def test_tiled_bounds_same(epsg):
                                    bounds=[single_bound, single_bound])
 
 
-# def test_create_tiled_image_data():
-#     bounds_points = [Point(x=0, y=0), Point(x=5, y=5)]
-#     url = "https://labelbox.s3-us-west-2.amazonaws.com/pathology/{z}/{x}/{y}.png"
-#     zoom_levels = [1, 10]
-
-#     tile_layer = TileLayer(url=url, name="slippy map tile")
-#     tile_bounds = TiledBounds(epsg=EPSG.EPSG4326, bounds=bounds_points)
-#     tiled_image_data = TiledImageData(tile_layer=tile_layer,
-#                                       tile_bounds=tile_bounds,
-#                                       zoom_levels=zoom_levels,
-#                                       version=2)
-#     assert isinstance(tiled_image_data, TiledImageData)
-#     assert tiled_image_data.tile_bounds == bounds_points
-#     assert tiled_image_data.tile_layer.url == url
-#     assert tiled_image_data.zoom_levels == zoom_levels
+def test_create_tiled_image_data():
+    bounds_points = [Point(x=0, y=0), Point(x=5, y=5)]
+    url = "https://labelbox.s3-us-west-2.amazonaws.com/pathology/{z}/{x}/{y}.png"
+    zoom_levels = (1, 10)
+
+    tile_layer = TileLayer(url=url, name="slippy map tile")
+    tile_bounds = TiledBounds(epsg=EPSG.EPSG4326, bounds=bounds_points)
+    tiled_image_data = TiledImageData(tile_layer=tile_layer,
+                                      tile_bounds=tile_bounds,
+                                      zoom_levels=zoom_levels,
+                                      version=2)
+    assert isinstance(tiled_image_data, TiledImageData)
+    assert tiled_image_data.tile_bounds.bounds == bounds_points
+    assert tiled_image_data.tile_layer.url == url
+    assert tiled_image_data.zoom_levels == zoom_levels
+
+
+#TODO: create a test from 4326->SIMPLE->3857->4326
+def test_epsg_projections():
+    pass