[doc] update some docstring and typing hints

src/app.py

@@ -39,7 +39,8 @@ def lambda_handler(event: Dict, context: LambdaContext) -> str:
 
         try:
             body_response = samexporter_predict(body_request["bbox"], body_request["prompt"], body_request["zoom"])
-            app_logger.info(f"output body_response:{body_response}.")
+            app_logger.info(f"output body_response length:{len(body_response)}.")
+            app_logger.debug(f"output body_response:{body_response}.")
             response = get_response(HTTPStatus.OK.value, start_time, context.aws_request_id, body_response)
         except Exception as ex2:
             app_logger.error(f"exception2:{ex2}.")
@@ -51,5 +52,5 @@ def lambda_handler(event: Dict, context: LambdaContext) -> str:
         app_logger.error(f"exception1:{ex1}.")
         response = get_response(HTTPStatus.BAD_REQUEST.value, start_time, context.aws_request_id, {})
 
-    app_logger.info(f"response_dumped:{response}...")
+    app_logger.debug(f"response_dumped:{response}...")
     return response

src/io/geo_helpers.py

@@ -1,14 +1,15 @@
 """handle geo-referenced raster images"""
 from pathlib import Path
-from typing import List, Tuple, Dict
+from typing import Dict
 
 import numpy as np
 from affine import Affine
 
-from src import app_logger, PROJECT_ROOT_FOLDER
+from src import app_logger
+from src.utilities.type_hints import list_float, tuple_float, dict_str_int
 
 
-def load_affine_transformation_from_matrix(matrix_source_coefficients: List[float]) -> Affine:
+def load_affine_transformation_from_matrix(matrix_source_coefficients: list_float) -> Affine:
     """
     Wrapper for rasterio.Affine.from_gdal() method
 
@@ -32,7 +33,7 @@ def load_affine_transformation_from_matrix(matrix_source_coefficients: List[floa
         raise e
 
 
-def get_affine_transform_from_gdal(matrix_source_coefficients: List[float] or Tuple[float]) -> Affine:
+def get_affine_transform_from_gdal(matrix_source_coefficients: list_float or tuple_float) -> Affine:
     """wrapper for rasterio Affine from_gdal method
 
     Args:
@@ -44,7 +45,7 @@ def get_affine_transform_from_gdal(matrix_source_coefficients: List[float] or Tu
     return Affine.from_gdal(*matrix_source_coefficients)
 
 
-def get_vectorized_raster_as_geojson(mask: np.ndarray, matrix: Tuple[float]) -> Dict[str, int]:
+def get_vectorized_raster_as_geojson(mask: np.ndarray, matrix: tuple_float) -> dict_str_int:
     """
         Get shapes and values of connected regions in a dataset or array
 
@@ -84,10 +85,3 @@ def get_vectorized_raster_as_geojson(mask: np.ndarray, matrix: Tuple[float]) ->
     except Exception as e_shape_band:
         app_logger.error(f"e_shape_band:{e_shape_band}.")
         raise e_shape_band
-
-
-if __name__ == '__main__':
-    npy_file = "prediction_masks_46.27697017893455_9.616470336914064_46.11441972281433_9.264907836914064.npy"
-    prediction_masks = np.load(Path(PROJECT_ROOT_FOLDER) / "tmp" / "try_by_steps" / "t0" / npy_file)
-
-    print("#")

src/prediction_api/predictors.py

@@ -1,5 +1,4 @@
 """functions using machine learning instance model(s)"""
-from typing import Dict, Tuple
 from PIL.Image import Image
 import numpy as np
 
@@ -8,7 +7,7 @@ from src.io.geo_helpers import get_vectorized_raster_as_geojson, get_affine_tran
 from src.io.tms2geotiff import download_extent
 from src.prediction_api.sam_onnx import SegmentAnythingONNX
 from src.utilities.constants import MODEL_ENCODER_NAME, MODEL_DECODER_NAME, DEFAULT_TMS
-from src.utilities.type_hints import llist_float
+from src.utilities.type_hints import llist_float, dict_str_int, list_dict, tuple_ndarr_int
 
 
 models_dict = {"fastsam": {"instance": None}}
@@ -20,7 +19,7 @@ def samexporter_predict(
         zoom: float,
         model_name: str = "fastsam",
         url_tile: str = DEFAULT_TMS
-) -> Dict[str, int]:
+) -> dict_str_int:
     """
     Return predictions as a geojson from a geo-referenced image using the given input prompt.
 
@@ -37,7 +36,7 @@ def samexporter_predict(
         url_tile: server url tile
 
     Returns:
-        dict: Affine transform
+        Affine transform
     """
     if models_dict[model_name]["instance"] is None:
         app_logger.info(f"missing instance model {model_name}, instantiating it now!")
@@ -67,9 +66,10 @@ def samexporter_predict(
 
 
 def get_raster_inference(
-        img: Image, prompt: list[dict], models_instance: SegmentAnythingONNX, model_name: str
-     ) -> Tuple[np.ndarray, int]:
-    """wrapper for rasterio Affine from_gdal method
+        img: Image, prompt: list_dict, models_instance: SegmentAnythingONNX, model_name: str
+     ) -> tuple_ndarr_int:
+    """
+    Wrapper for rasterio Affine from_gdal method
 
     Args:
         img: input PIL Image

src/utilities/serialize.py

@@ -2,7 +2,7 @@
 from typing import Mapping
 
 from src import app_logger
-from src.utilities.type_hints import ts_dict_str2, ts_dict_str3
+from src.utilities.type_hints import dict_str, dict_str_any
 
 
 def serialize(obj: any, include_none: bool = False):
@@ -14,13 +14,12 @@ def serialize(obj: any, include_none: bool = False):
         include_none: bool to indicate if include also keys with None values during dict serialization
 
     Returns:
-        any: serialized object
-
+        serialized object
     """
     return _serialize(obj, include_none)
 
 
-def _serialize(obj: any, include_none: bool) -> any:
+def _serialize(obj: any, include_none: bool):
     import numpy as np
 
     primitive = (int, float, str, bool)
@@ -75,11 +74,11 @@ def _serialize_list(ls: list, include_none: bool) -> list:
     return [_serialize(elem, include_none) for elem in ls]
 
 
-def _serialize_bytes(b: bytes) -> ts_dict_str2:
+def _serialize_bytes(b: bytes) -> dict_str:
     import base64
     encoded = base64.b64encode(b)
     return {"value": encoded.decode('ascii'), "type": "bytes"}
 
 
-def _serialize_exception(e: Exception) -> ts_dict_str3:
+def _serialize_exception(e: Exception) -> dict_str_any:
     return {"msg": str(e), "type": str(type(e)), **e.__dict__}

src/utilities/type_hints.py

@@ -3,16 +3,23 @@ from enum import Enum
 from typing import TypedDict
 
 from PIL.Image import Image
+from numpy import ndarray
 from pydantic import BaseModel
 
 from src.utilities.constants import DEFAULT_TMS
 
 
-ts_dict_str2 = dict[str, str]
-ts_dict_str3 = dict[str, str, any]
-ts_ddict1 = dict[str, dict[str, any], dict, dict, any]
+dict_str_int = dict[str, int]
+dict_str = dict[str]
+dict_str_any = dict[str, any]
+list_dict = list[dict]
 list_float = list[float]
+list_int = list[int]
+tuple_int = tuple[int]
+tuple_ndarr_int = tuple[ndarray, int]
 llist_float = list[list_float]
+tuple_float = tuple[float]
+tuple_float_any = tuple[float, any]
 PIL_Image = Image
 
 

src/utilities/utilities.py

@@ -56,7 +56,7 @@ def base64_encode(sb: str or bytes) -> bytes:
     return base64.b64encode(sb_bytes)
 
 
-def hash_calculate(arr: any) -> str or bytes:
+def hash_calculate(arr) -> str or bytes:
     """
     Return computed hash from input variable (typically a numpy array).
 
@@ -64,7 +64,7 @@ def hash_calculate(arr: any) -> str or bytes:
         arr: input variable
 
     Returns:
-        str or bytes: computed hash from input variable
+        computed hash from input variable
     """
     import hashlib
     import numpy as np