feat: remove loguru and change logging method (use the @session_logger.set_uuid_logging decorator on functions with logs)

app.py

@@ -1,11 +1,10 @@
 import json
+import logging
 import os
 import pathlib
-import uuid
 from typing import Callable, NoReturn
 
 import gradio as gr
-from samgis_lisa_on_zero.utilities.constants import GRADIO_EXAMPLE_BODY, GRADIO_EXAMPLES_TEXT_LIST, GRADIO_MARKDOWN
 import spaces
 import uvicorn
 from fastapi import FastAPI, HTTPException, Request, status
@@ -13,16 +12,16 @@ from fastapi.exceptions import RequestValidationError
 from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from lisa_on_cuda.utils import app_helpers, frontend_builder, create_folders_and_variables_if_not_exists
+from lisa_on_cuda.utils import app_helpers, frontend_builder, create_folders_and_variables_if_not_exists, session_logger
 from pydantic import ValidationError
-from samgis_core.utilities.fastapi_logger import setup_logging
+
 from samgis_lisa_on_zero import PROJECT_ROOT_FOLDER, WORKDIR
-from samgis_lisa_on_zero.utilities.type_hints import ApiRequestBody, StringPromptApiRequestBody
+from samgis_lisa_on_zero.utilities.constants import GRADIO_EXAMPLE_BODY, GRADIO_EXAMPLES_TEXT_LIST, GRADIO_MARKDOWN
+from samgis_lisa_on_zero.utilities.type_hints import StringPromptApiRequestBody
 
 
 loglevel = os.getenv('LOGLEVEL', 'INFO').upper()
-app_logger = setup_logging(debug=loglevel == "DEBUG")
-
+session_logger.change_logging(loglevel)
 VITE_INDEX_URL = os.getenv("VITE_INDEX_URL", "/")
 VITE_SAMGIS_URL = os.getenv("VITE_SAMGIS_URL", "/samgis")
 VITE_LISA_URL = os.getenv("VITE_LISA_URL", "/lisa")
@@ -32,8 +31,9 @@ app = FastAPI(title=FASTAPI_TITLE, version="1.0")
 
 
 @spaces.GPU
+@session_logger.set_uuid_logging
 def gpu_initialization() -> None:
-    app_logger.info("GPU initialization...")
+    logging.info("GPU initialization...")
 
 
 def get_example_complete(example_text):
@@ -67,45 +67,27 @@ def get_gradio_interface_geojson(fn_inference: Callable):
     return gradio_app
 
 
+@session_logger.set_uuid_logging
 def handle_exception_response(exception: Exception) -> NoReturn:
     import subprocess
     project_root_folder_content = subprocess.run(
         f"ls -l {PROJECT_ROOT_FOLDER}/", shell=True, universal_newlines=True, stdout=subprocess.PIPE
     )
-    app_logger.error(f"project_root folder 'ls -l' command output: {project_root_folder_content.stdout}.")
+    logging.error(f"project_root folder 'ls -l' command output: {project_root_folder_content.stdout}.")
     workdir_folder_content = subprocess.run(
         f"ls -l {WORKDIR}/", shell=True, universal_newlines=True, stdout=subprocess.PIPE
     )
-    app_logger.error(f"workdir folder 'ls -l' command stdout: {workdir_folder_content.stdout}.")
-    app_logger.error(f"workdir folder 'ls -l' command stderr: {workdir_folder_content.stderr}.")
-    app_logger.error(f"inference error:{exception}.")
+    logging.error(f"workdir folder 'ls -l' command stdout: {workdir_folder_content.stdout}.")
+    logging.error(f"workdir folder 'ls -l' command stderr: {workdir_folder_content.stderr}.")
+    logging.error(f"inference error:{exception}.")
     raise HTTPException(
         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Internal server error on inference"
     )
 
 
-@app.middleware("http")
-async def request_middleware(request, call_next):
-    request_id = str(uuid.uuid4())
-    with app_logger.contextualize(request_id=request_id):
-        app_logger.info("Request started")
-
-        try:
-            response = await call_next(request)
-
-        except Exception as ex_middleware_http:
-            app_logger.error(f"Request failed, ex_middleware_http: {ex_middleware_http}")
-            response = JSONResponse(content={"success": False}, status_code=500)
-
-        finally:
-            response.headers["X-Request-ID"] = request_id
-            app_logger.info("Request ended")
-
-        return response
-
-
 @app.get("/health")
-async def health() -> JSONResponse:
+@session_logger.set_uuid_logging
+def health() -> JSONResponse:
     import importlib.metadata
     from importlib.metadata import PackageNotFoundError
 
@@ -115,73 +97,76 @@ async def health() -> JSONResponse:
         lisa_on_cuda_version = importlib.metadata.version('lisa-on-cuda')
         samgis_lisa_on_cuda_version = importlib.metadata.version('samgis-lisa-on-zero')
     except PackageNotFoundError as pe:
-        app_logger.error(f"pe:{pe}.")
+        logging.error(f"pe:{pe}.")
 
     msg = "still alive, "
     msg += f"""version:{samgis_lisa_on_cuda_version}, core version:{core_version},"""
     msg += f"""lisa-on-cuda version:{lisa_on_cuda_version},"""
 
-    app_logger.info(msg)
+    logging.info(msg)
     return JSONResponse(status_code=200, content={"msg": "still alive..."})
 
 
-def infer_lisa_gradio(request_input: StringPromptApiRequestBody) -> JSONResponse:
-    from samgis_lisa_on_zero.io_package.wrappers_helpers import get_parsed_bbox_points_with_string_prompt, get_source_name
+@session_logger.set_uuid_logging
+def infer_lisa_gradio(request_input: StringPromptApiRequestBody) -> str:
+    from samgis_lisa_on_zero.io_package.wrappers_helpers import get_parsed_bbox_points_with_string_prompt
     from samgis_lisa_on_zero.prediction_api import lisa
     from samgis_lisa_on_zero.utilities.constants import LISA_INFERENCE_FN
 
-    app_logger.info("starting lisa inference request...")
+    logging.info("starting lisa inference request...")
 
     try:
         import time
 
         time_start_run = time.time()
         body_request = get_parsed_bbox_points_with_string_prompt(request_input)
-        app_logger.info(f"lisa body_request:{body_request}.")
+        logging.info(f"lisa body_request:{body_request}.")
         try:
             source = body_request["source"]
             source_name = body_request["source_name"]
-            app_logger.debug(f"body_request:type(source):{type(source)}, source:{source}.")
-            app_logger.debug(f"body_request:type(source_name):{type(source_name)}, source_name:{source_name}.")
-            app_logger.debug(f"lisa module:{lisa}.")
+            logging.debug(f"body_request:type(source):{type(source)}, source:{source}.")
+            logging.debug(f"body_request:type(source_name):{type(source_name)}, source_name:{source_name}.")
+            logging.debug(f"lisa module:{lisa}.")
             gpu_initialization()
             output = lisa.lisa_predict(
                 bbox=body_request["bbox"], prompt=body_request["prompt"], zoom=body_request["zoom"],
                 source=source, source_name=source_name, inference_function_name_key=LISA_INFERENCE_FN
             )
             duration_run = time.time() - time_start_run
-            app_logger.info(f"duration_run:{duration_run}.")
+            logging.info(f"duration_run:{duration_run}.")
             body = {
                 "duration_run": duration_run,
                 "output": output
             }
             dumped = json.dumps(body)
-            app_logger.info(f"json.dumps(body) type:{type(dumped)}, len:{len(dumped)}.")
-            app_logger.debug(f"complete json.dumps(body):{dumped}.")
+            logging.info(f"json.dumps(body) type:{type(dumped)}, len:{len(dumped)}.")
+            logging.debug(f"complete json.dumps(body):{dumped}.")
             return dumped
         except Exception as inference_exception:
             handle_exception_response(inference_exception)
     except ValidationError as va1:
-        app_logger.error(f"validation error: {str(va1)}.")
+        logging.error(f"validation error: {str(va1)}.")
         raise ValidationError("Unprocessable Entity")
 
 
+@session_logger.set_uuid_logging
 @app.post("/infer_lisa")
 def infer_lisa(request_input: StringPromptApiRequestBody) -> JSONResponse:
     dumped = infer_lisa_gradio(request_input=request_input)
-    app_logger.info(f"json.dumps(body) type:{type(dumped)}, len:{len(dumped)}.")
-    app_logger.debug(f"complete json.dumps(body):{dumped}.")
+    logging.info(f"json.dumps(body) type:{type(dumped)}, len:{len(dumped)}.")
+    logging.debug(f"complete json.dumps(body):{dumped}.")
     return JSONResponse(status_code=200, content={"body": dumped})
 
 
 @app.exception_handler(RequestValidationError)
-async def request_validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
-    app_logger.error(f"exception errors: {exc.errors()}.")
-    app_logger.error(f"exception body: {exc.body}.")
+@session_logger.set_uuid_logging
+def request_validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
+    logging.error(f"exception errors: {exc.errors()}.")
+    logging.error(f"exception body: {exc.body}.")
     headers = request.headers.items()
-    app_logger.error(f'request header: {dict(headers)}.')
+    logging.error(f'request header: {dict(headers)}.')
     params = request.query_params.items()
-    app_logger.error(f'request query params: {dict(params)}.')
+    logging.error(f'request query params: {dict(params)}.')
     return JSONResponse(
         status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
         content={"msg": "Error - Unprocessable Entity"}
@@ -189,12 +174,13 @@ async def request_validation_exception_handler(request: Request, exc: RequestVal
 
 
 @app.exception_handler(HTTPException)
-async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
-    app_logger.error(f"exception: {str(exc)}.")
+@session_logger.set_uuid_logging
+def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
+    logging.error(f"exception: {str(exc)}.")
     headers = request.headers.items()
-    app_logger.error(f'request header: {dict(headers)}.')
+    logging.error(f'request header: {dict(headers)}.')
     params = request.query_params.items()
-    app_logger.error(f'request query params: {dict(params)}.')
+    logging.error(f'request query params: {dict(params)}.')
     return JSONResponse(
         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
         content={"msg": "Error - Internal Server Error"}
@@ -202,21 +188,21 @@ async def http_exception_handler(request: Request, exc: HTTPException) -> JSONRe
 
 
 write_tmp_on_disk = os.getenv("WRITE_TMP_ON_DISK", "")
-app_logger.info(f"write_tmp_on_disk:{write_tmp_on_disk}.")
+logging.info(f"write_tmp_on_disk:{write_tmp_on_disk}.")
 if bool(write_tmp_on_disk):
     try:
         path_write_tmp_on_disk = pathlib.Path(write_tmp_on_disk)
         try:
             pathlib.Path.unlink(path_write_tmp_on_disk, missing_ok=True)
         except (IsADirectoryError, PermissionError, OSError) as err:
-            app_logger.error(f"{err} while removing old write_tmp_on_disk:{write_tmp_on_disk}.")
-            app_logger.error(f"is file?{path_write_tmp_on_disk.is_file()}.")
-            app_logger.error(f"is symlink?{path_write_tmp_on_disk.is_symlink()}.")
-            app_logger.error(f"is folder?{path_write_tmp_on_disk.is_dir()}.")
+            logging.error(f"{err} while removing old write_tmp_on_disk:{write_tmp_on_disk}.")
+            logging.error(f"is file?{path_write_tmp_on_disk.is_file()}.")
+            logging.error(f"is symlink?{path_write_tmp_on_disk.is_symlink()}.")
+            logging.error(f"is folder?{path_write_tmp_on_disk.is_dir()}.")
         os.makedirs(write_tmp_on_disk, exist_ok=True)
         app.mount("/vis_output", StaticFiles(directory=write_tmp_on_disk), name="vis_output")
     except RuntimeError as runtime_error:
-        app_logger.error(f"{runtime_error} while loading the folder write_tmp_on_disk:{write_tmp_on_disk}...")
+        logging.error(f"{runtime_error} while loading the folder write_tmp_on_disk:{write_tmp_on_disk}...")
         raise runtime_error
     templates = Jinja2Templates(directory=WORKDIR / "static")
 
@@ -239,7 +225,7 @@ frontend_builder.build_frontend(
 )
 create_folders_and_variables_if_not_exists.folders_creation()
 
-app_logger.info("build_frontend ok!")
+logging.info("build_frontend ok!")
 
 templates = Jinja2Templates(directory="templates")
 
@@ -272,12 +258,12 @@ async def index() -> FileResponse:
     return FileResponse(path=static_dist_folder / "index.html", media_type="text/html")
 
 
-app_helpers.app_logger.info(f"creating gradio interface...")
+app_helpers.logging.info(f"creating gradio interface...")
 io = get_gradio_interface_geojson(infer_lisa_gradio)
-app_helpers.app_logger.info(
+app_helpers.logging.info(
     f"gradio interface created, mounting gradio app on url {VITE_GRADIO_URL} within FastAPI...")
 app = gr.mount_gradio_app(app, io, path=VITE_GRADIO_URL)
-app_helpers.app_logger.info("mounted gradio app within fastapi")
+app_helpers.logging.info("mounted gradio app within fastapi")
 
 
 if __name__ == '__main__':

samgis_lisa_on_zero/io_package/coordinates_pixel_conversion.py

@@ -1,12 +1,13 @@
 """functions useful to convert to/from latitude-longitude coordinates to pixel image coordinates"""
+from lisa_on_cuda.utils import session_logger
 from samgis_core.utilities.type_hints import TupleFloat, TupleFloatAny
-
 from samgis_lisa_on_zero import app_logger
 from samgis_lisa_on_zero.utilities.constants import TILE_SIZE, EARTH_EQUATORIAL_RADIUS
 from samgis_lisa_on_zero.utilities.type_hints import ImagePixelCoordinates
 from samgis_lisa_on_zero.utilities.type_hints import LatLngDict
 
 
+@session_logger.set_uuid_logging
 def _get_latlng2pixel_projection(latlng: LatLngDict) -> ImagePixelCoordinates:
     from math import log, pi, sin
 
@@ -30,6 +31,7 @@ def _get_latlng2pixel_projection(latlng: LatLngDict) -> ImagePixelCoordinates:
         raise e_get_latlng2pixel_projection
 
 
+@session_logger.set_uuid_logging
 def _get_point_latlng_to_pixel_coordinates(latlng: LatLngDict, zoom: int | float) -> ImagePixelCoordinates:
     from math import floor
 
@@ -50,6 +52,7 @@ def _get_point_latlng_to_pixel_coordinates(latlng: LatLngDict, zoom: int | float
         raise e_format_latlng_to_pixel_coordinates
 
 
+@session_logger.set_uuid_logging
 def get_latlng_to_pixel_coordinates(
         latlng_origin_ne: LatLngDict,
         latlng_origin_sw: LatLngDict,

samgis_lisa_on_zero/io_package/geo_helpers.py

@@ -2,10 +2,12 @@
 from affine import Affine
 from numpy import ndarray as np_ndarray
 
+from lisa_on_cuda.utils import session_logger
 from samgis_core.utilities.type_hints import ListFloat, TupleFloat, DictStrInt
 from samgis_lisa_on_zero import app_logger
 
 
+@session_logger.set_uuid_logging
 def load_affine_transformation_from_matrix(matrix_source_coefficients: ListFloat) -> Affine:
     """
     Wrapper for rasterio.Affine.from_gdal() method
@@ -44,6 +46,7 @@ def get_affine_transform_from_gdal(matrix_source_coefficients: ListFloat or Tupl
     return Affine.from_gdal(*matrix_source_coefficients)
 
 
+@session_logger.set_uuid_logging
 def get_vectorized_raster_as_geojson(mask: np_ndarray, transform: TupleFloat) -> DictStrInt:
     """
         Get shapes and values of connected regions in a dataset or array

samgis_lisa_on_zero/io_package/raster_helpers.py

@@ -3,7 +3,7 @@ import numpy as np
 from numpy import ndarray, bitwise_not
 from rasterio import open as rasterio_open
 
-from samgis_lisa_on_zero import PROJECT_ROOT_FOLDER
+from lisa_on_cuda.utils import session_logger
 from samgis_lisa_on_zero import app_logger
 from samgis_lisa_on_zero.utilities.constants import OUTPUT_CRS_STRING
 from samgis_lisa_on_zero.utilities.type_hints import XYZTerrainProvidersNames
@@ -71,6 +71,7 @@ def get_raster_terrain_rgb_like(arr: ndarray, xyz_provider_name, nan_value_int:
     return output
 
 
+@session_logger.set_uuid_logging
 def get_rgb_prediction_image(raster_cropped: ndarray, slope_cellsize: int, invert_image: bool = True) -> ndarray:
     """
     Return an RGB image from input numpy array
@@ -100,6 +101,7 @@ def get_rgb_prediction_image(raster_cropped: ndarray, slope_cellsize: int, inver
         raise ve_get_rgb_prediction_image
 
 
+@session_logger.set_uuid_logging
 def get_rgb_image(arr_channel0: ndarray, arr_channel1: ndarray, arr_channel2: ndarray,
                   invert_image: bool = True) -> ndarray:
     """
@@ -139,6 +141,7 @@ def get_rgb_image(arr_channel0: ndarray, arr_channel1: ndarray, arr_channel2: nd
         raise ve_get_rgb_image
 
 
+@session_logger.set_uuid_logging
 def get_slope_curvature(dem: ndarray, slope_cellsize: int, title: str = "") -> tuple[ndarray, ndarray]:
     """
     Return a tuple of two numpy arrays representing slope and curvature (1st grade derivative and 2nd grade derivative)
@@ -171,6 +174,7 @@ def get_slope_curvature(dem: ndarray, slope_cellsize: int, title: str = "") -> t
         raise ve_get_slope_curvature
 
 
+@session_logger.set_uuid_logging
 def calculate_slope(dem_array: ndarray, cell_size: int, calctype: str = "degree") -> ndarray:
     """
     Return a numpy array representing slope (1st grade derivative)
@@ -198,6 +202,7 @@ def calculate_slope(dem_array: ndarray, cell_size: int, calctype: str = "degree"
         raise ve_calculate_slope
 
 
+@session_logger.set_uuid_logging
 def normalize_array(arr: ndarray, high: int = 255, norm_type: str = "float", invert: bool = False, title: str = "") -> ndarray:
     """
     Return normalized numpy array between 0 and 'high' value. Default normalization type is int
@@ -239,6 +244,7 @@ def normalize_array(arr: ndarray, high: int = 255, norm_type: str = "float", inv
         raise ValueError(msg)
 
 
+@session_logger.set_uuid_logging
 def normalize_array_list(arr_list: list[ndarray], exaggerations_list: list[float] = None, title: str = "") -> ndarray:
     """
     Return a normalized numpy array from a list of numpy array and an optional list of exaggeration values.
@@ -266,6 +272,7 @@ def normalize_array_list(arr_list: list[ndarray], exaggerations_list: list[float
     return arr_tmp / len(arr_list)
 
 
+@session_logger.set_uuid_logging
 def check_empty_array(arr: ndarray, val: float) -> bool:
     """
     Return True if the input numpy array is empy. Check if
@@ -297,6 +304,7 @@ def check_empty_array(arr: ndarray, val: float) -> bool:
     return check1 or check2 or check3 or check4 or check5
 
 
+@session_logger.set_uuid_logging
 def write_raster_png(arr, transform, prefix: str, suffix: str, folder_output_path="/tmp"):
     from pathlib import Path
     from rasterio.plot import reshape_as_raster
@@ -315,6 +323,7 @@ def write_raster_png(arr, transform, prefix: str, suffix: str, folder_output_pat
     app_logger.info(f"written:{output_filename} as PNG, use {OUTPUT_CRS_STRING} as CRS.")
 
 
+@session_logger.set_uuid_logging
 def write_raster_tiff(arr, transform, prefix: str, suffix: str, folder_output_path="/tmp"):
     from pathlib import Path
     output_filename = Path(folder_output_path) / f"{prefix}_{suffix}.tiff"

samgis_lisa_on_zero/io_package/tms2geotiff.py

@@ -4,8 +4,10 @@ from numpy import ndarray
 from samgis_core.utilities.type_hints import TupleFloat
 from xyzservices import TileProvider
 
+from lisa_on_cuda.utils import session_logger
 from samgis_lisa_on_zero import app_logger
-from samgis_lisa_on_zero.utilities.constants import (OUTPUT_CRS_STRING, DRIVER_RASTERIO_GTIFF, N_MAX_RETRIES, N_CONNECTION, N_WAIT,
+from samgis_lisa_on_zero.utilities.constants import (OUTPUT_CRS_STRING, DRIVER_RASTERIO_GTIFF, N_MAX_RETRIES,
+                                                     N_CONNECTION, N_WAIT,
                                                      ZOOM_AUTO, BOOL_USE_CACHE)
 from samgis_lisa_on_zero.utilities.type_hints import tuple_ndarray_transform
 
@@ -17,6 +19,7 @@ n_wait = int(os.getenv("N_WAIT", N_WAIT))
 zoom_auto_string = os.getenv("ZOOM_AUTO", ZOOM_AUTO)
 
 
+@session_logger.set_uuid_logging
 def download_extent(w: float, s: float, e: float, n: float, zoom: int or str = zoom_auto_string,
                     source: TileProvider or str = None,
                     wait: int = n_wait, max_retries: int = n_max_retries, n_connections: int = n_connection,
@@ -70,6 +73,7 @@ def download_extent(w: float, s: float, e: float, n: float, zoom: int or str = z
         raise e_download_extent
 
 
+@session_logger.set_uuid_logging
 def crop_raster(w: float, s: float, e: float, n: float, raster: ndarray, raster_bbox: TupleFloat,
                 crs: str = OUTPUT_CRS_STRING, driver: str = DRIVER_RASTERIO_GTIFF) -> tuple_ndarray_transform:
     """
@@ -134,6 +138,7 @@ def crop_raster(w: float, s: float, e: float, n: float, raster: ndarray, raster_
         raise e_crop_raster
 
 
+@session_logger.set_uuid_logging
 def get_transform_raster(raster: ndarray, raster_bbox: TupleFloat) -> tuple_ndarray_transform:
     """
     Convert the input raster image to RGB and extract the Affine 
@@ -170,6 +175,7 @@ def get_transform_raster(raster: ndarray, raster_bbox: TupleFloat) -> tuple_ndar
         raise e_get_transform_raster
 
 
+@session_logger.set_uuid_logging
 def reshape_as_image(arr):
     try:
         from numpy import swapaxes

samgis_lisa_on_zero/io_package/wrappers_helpers.py

@@ -1,52 +1,18 @@
 """lambda helper functions"""
-import logging
-from sys import stdout
 from typing import Dict
 
-import loguru
 from xyzservices import providers, TileProvider
 
+from lisa_on_cuda.utils import session_logger
 from lisa_on_cuda.utils.app_helpers import get_cleaned_input
 from samgis_lisa_on_zero import app_logger
 from samgis_lisa_on_zero.io_package.coordinates_pixel_conversion import get_latlng_to_pixel_coordinates
-from samgis_lisa_on_zero.utilities.constants import COMPLETE_URL_TILES_MAPBOX, COMPLETE_URL_TILES_NEXTZEN, CUSTOM_RESPONSE_MESSAGES
-from samgis_lisa_on_zero.utilities.type_hints import ApiRequestBody, ContentTypes, XYZTerrainProvidersNames, \
-    XYZDefaultProvidersNames, StringPromptApiRequestBody
-from samgis_core.utilities.utilities import base64_decode
-
-
-def get_response(status: int, start_time: float, request_id: str, response_body: Dict = None) -> str:
-    """
-    Response composer
-
-    Args:
-        status: status response
-        start_time: request start time (float)
-        request_id: str
-        response_body: dict we embed into our response
-
-    Returns:
-        json response
-
-    """
-    from json import dumps
-    from time import time
-
-    app_logger.debug(f"response_body:{response_body}.")
-    response_body["duration_run"] = time() - start_time
-    response_body["message"] = CUSTOM_RESPONSE_MESSAGES[status]
-    response_body["request_id"] = request_id
-
-    response = {
-        "statusCode": status,
-        "header": {"Content-Type": ContentTypes.APPLICATION_JSON},
-        "body": dumps(response_body),
-        "isBase64Encoded": False
-    }
-    app_logger.debug(f"response type:{type(response)} => {response}.")
-    return dumps(response)
+from samgis_lisa_on_zero.utilities.constants import COMPLETE_URL_TILES_MAPBOX, COMPLETE_URL_TILES_NEXTZEN
+from samgis_lisa_on_zero.utilities.type_hints import (
+    ApiRequestBody, XYZTerrainProvidersNames, XYZDefaultProvidersNames, StringPromptApiRequestBody)
 
 
+@session_logger.set_uuid_logging
 def get_parsed_bbox_points_with_string_prompt(request_input: StringPromptApiRequestBody) -> Dict:
     """
         Parse the raw input request into bbox, prompt string and zoom
@@ -88,6 +54,7 @@ def get_parsed_bbox_points_with_string_prompt(request_input: StringPromptApiRequ
     }
 
 
+@session_logger.set_uuid_logging
 def get_parsed_bbox_points_with_dictlist_prompt(request_input: ApiRequestBody) -> Dict:
     """
     Parse the raw input request into bbox, prompt and zoom
@@ -125,6 +92,7 @@ def get_parsed_bbox_points_with_dictlist_prompt(request_input: ApiRequestBody) -
     }
 
 
+@session_logger.set_uuid_logging
 def _get_parsed_prompt_list(bbox_ne, bbox_sw, zoom, prompt_list):
     new_prompt_list = []
     for prompt in prompt_list:
@@ -144,12 +112,14 @@ def _get_parsed_prompt_list(bbox_ne, bbox_sw, zoom, prompt_list):
     return new_prompt_list
 
 
+@session_logger.set_uuid_logging
 def _get_new_prompt_data_point(bbox_ne, bbox_sw, prompt, zoom):
     current_point = get_latlng_to_pixel_coordinates(bbox_ne, bbox_sw, prompt.data, zoom, prompt.type)
     app_logger.debug(f"current prompt: {type(current_point)}, value:{current_point}, label: {prompt.label}.")
     return [current_point['x'], current_point['y']]
 
 
+@session_logger.set_uuid_logging
 def _get_new_prompt_data_rectangle(bbox_ne, bbox_sw, prompt, zoom):
     current_point_ne = get_latlng_to_pixel_coordinates(bbox_ne, bbox_sw, prompt.data.ne, zoom, prompt.type)
     app_logger.debug(
@@ -166,51 +136,6 @@ def _get_new_prompt_data_rectangle(bbox_ne, bbox_sw, prompt, zoom):
     ]
 
 
-def get_parsed_request_body(event: Dict or str) -> ApiRequestBody:
-    """
-    Validator for the raw input request lambda event
-
-    Args:
-        event: input dict
-
-    Returns:
-        parsed request input
-    """
-    from json import dumps, loads
-    from logging import getLevelName
-
-    def _get_current_log_level(logger: loguru.logger) -> [str, loguru._logger.Level]:
-        levels = logger._core.levels
-        current_log_level = logger._core.min_level
-        level_filt = [l for l in levels.items() if l[1].no == current_log_level]
-        return level_filt[0]
-
-    app_logger.info(f"event:{dumps(event)}...")
-    try:
-        raw_body = event["body"]
-    except Exception as e_constants1:
-        app_logger.error(f"e_constants1:{e_constants1}.")
-        raw_body = event
-    app_logger.debug(f"raw_body, #1: {type(raw_body)}, {raw_body}...")
-    if isinstance(raw_body, str):
-        body_decoded_str = base64_decode(raw_body)
-        app_logger.debug(f"body_decoded_str: {type(body_decoded_str)}, {body_decoded_str}...")
-        raw_body = loads(body_decoded_str)
-    app_logger.info(f"body, #2: {type(raw_body)}, {raw_body}...")
-
-    parsed_body = ApiRequestBody.model_validate(raw_body)
-    log_level = "DEBUG" if parsed_body.debug else "INFO"
-    app_logger.remove()
-    app_logger.add(stdout, level=log_level)
-    try:
-        current_log_level_name, _ = _get_current_log_level(app_logger)
-        app_logger.warning(f"set log level to {getLevelName(current_log_level_name)}.")
-    except Exception as ex:
-        print("failing setting parsing bbox, logger is ok? ex:", ex, "#")
-
-    return parsed_body
-
-
 mapbox_terrain_rgb = TileProvider(
     name=XYZTerrainProvidersNames.MAPBOX_TERRAIN_TILES_NAME,
     url=COMPLETE_URL_TILES_MAPBOX,
@@ -223,6 +148,7 @@ nextzen_terrain_rgb = TileProvider(
 )
 
 
+@session_logger.set_uuid_logging
 def get_url_tile(source_type: str):
     try:
         match source_type.lower():
@@ -246,6 +172,7 @@ def check_source_type_is_terrain(source: str | TileProvider):
     return isinstance(source, TileProvider) and source.name in list(XYZTerrainProvidersNames)
 
 
+@session_logger.set_uuid_logging
 def get_source_name(source: str | TileProvider) -> str | bool:
     try:
         match source.lower():

samgis_lisa_on_zero/prediction_api/lisa.py

@@ -1,15 +1,19 @@
 from datetime import datetime
-from spaces import GPU as SPACES_GPU
 
+from lisa_on_cuda.utils import session_logger
 from samgis_core.utilities.type_hints import LlistFloat, DictStrInt
+from spaces import GPU as SPACES_GPU
+
 from samgis_lisa_on_zero.io_package.geo_helpers import get_vectorized_raster_as_geojson
 from samgis_lisa_on_zero.io_package.raster_helpers import write_raster_png, write_raster_tiff
 from samgis_lisa_on_zero.io_package.tms2geotiff import download_extent
 from samgis_lisa_on_zero.utilities.constants import DEFAULT_URL_TILES, LISA_INFERENCE_FN
 
+
 msg_write_tmp_on_disk = "found option to write images and geojson output..."
 
 
+@session_logger.set_uuid_logging
 def load_model_and_inference_fn(inference_function_name_key: str):
     from samgis_lisa_on_zero import app_logger
     from lisa_on_cuda.utils import app_helpers
@@ -28,6 +32,7 @@ def load_model_and_inference_fn(inference_function_name_key: str):
         models_dict[inference_function_name_key]["inference"] = inference_fn
 
 
+@session_logger.set_uuid_logging
 def lisa_predict(
         bbox: LlistFloat,
         prompt: str,

samgis_lisa_on_zero/prediction_api/predictors.py

@@ -1,4 +1,9 @@
 """functions using machine learning instance model(s)"""
+from lisa_on_cuda.utils import session_logger
+from samgis_core.prediction_api import sam_onnx2, sam_onnx_inference
+from samgis_core.utilities.constants import MODEL_ENCODER_NAME, MODEL_DECODER_NAME, DEFAULT_INPUT_SHAPE
+from samgis_core.utilities.type_hints import LlistFloat, DictStrInt, ListDict
+
 from samgis_lisa_on_zero import app_logger, MODEL_FOLDER
 from samgis_lisa_on_zero.io_package.geo_helpers import get_vectorized_raster_as_geojson
 from samgis_lisa_on_zero.io_package.raster_helpers import get_raster_terrain_rgb_like, get_rgb_prediction_image
@@ -6,11 +11,9 @@ from samgis_lisa_on_zero.io_package.tms2geotiff import download_extent
 from samgis_lisa_on_zero.io_package.wrappers_helpers import check_source_type_is_terrain
 from samgis_lisa_on_zero.prediction_api.global_models import models_dict, embedding_dict
 from samgis_lisa_on_zero.utilities.constants import DEFAULT_URL_TILES, SLOPE_CELLSIZE
-from samgis_core.prediction_api import sam_onnx2, sam_onnx_inference
-from samgis_core.utilities.constants import MODEL_ENCODER_NAME, MODEL_DECODER_NAME, DEFAULT_INPUT_SHAPE
-from samgis_core.utilities.type_hints import LlistFloat, DictStrInt, ListDict
 
 
+@session_logger.set_uuid_logging
 def samexporter_predict(
         bbox: LlistFloat,
         prompt: ListDict,

samgis_lisa_on_zero/utilities/session_logger.py

@@ -3,21 +3,19 @@ import logging
 from functools import wraps
 from typing import Callable, Tuple
 
+
 logging_uuid = contextvars.ContextVar("uuid")
 default_formatter = '%(asctime)s | %(uuid)s [%(pathname)s:%(module)s %(lineno)d] %(levelname)s | %(message)s'
-
-
 loggingType = logging.CRITICAL | logging.ERROR | logging.WARNING | logging.INFO | logging.DEBUG
 
 
-def setup_logging(
-        debug: bool = False, formatter: str = default_formatter, name: str = "logger"
+def setup_logging(log_level: loggingType, formatter: str = default_formatter, name: str = "logger"
 ) -> Tuple[logging, contextvars.ContextVar]:
     """
     Create a logging instance with log string formatter.
 
     Args:
-        debug: logging debug argument
+        log_level: logging level
         formatter: log string formatter
         name: logger name
 
@@ -36,13 +34,13 @@ def setup_logging(
         return record
 
     logging.setLogRecordFactory(record_factory)
-    logging.basicConfig(level=logging.DEBUG, format=default_formatter, force=True)
+    logging.basicConfig(level="DEBUG", format=default_formatter, force=True)
 
     logger = logging.getLogger(name=name)
 
     # create a console handler
     ch = logging.StreamHandler()
-    ch.setLevel(logging.DEBUG)
+    ch.setLevel("DEBUG")
 
     # create formatter and add to the console
     formatter = logging.Formatter(formatter)

tests/io_package/test_wrappers_helpers.py

@@ -1,55 +1,14 @@
 import json
-import time
 import unittest
-
-from http import HTTPStatus
 from unittest.mock import patch
 
 from samgis_lisa_on_zero.io_package import wrappers_helpers
-from samgis_lisa_on_zero.io_package.wrappers_helpers import get_parsed_bbox_points_with_dictlist_prompt, get_parsed_request_body, get_response
+from samgis_lisa_on_zero.io_package.wrappers_helpers import get_parsed_bbox_points_with_dictlist_prompt
 from samgis_lisa_on_zero.utilities.type_hints import ApiRequestBody
 from tests import TEST_EVENTS_FOLDER
 
 
 class WrappersHelpersTest(unittest.TestCase):
-    @patch.object(time, "time")
-    def test_get_response(self, time_mocked):
-        time_diff = 108
-        end_run = 1000
-        time_mocked.return_value = end_run
-        start_time = end_run - time_diff
-        aws_request_id = "test_invoke_id"
-
-        with open(TEST_EVENTS_FOLDER / "get_response.json") as tst_json:
-            inputs_outputs = json.load(tst_json)
-
-        response_type = "200"
-        body_response = inputs_outputs[response_type]["input"]
-        output = get_response(HTTPStatus.OK.value, start_time, aws_request_id, body_response)
-        assert json.loads(output) == inputs_outputs[response_type]["output"]
-
-        response_type = "400"
-        response_400 = get_response(HTTPStatus.BAD_REQUEST.value, start_time, aws_request_id, {})
-        assert response_400 == inputs_outputs[response_type]["output"]
-
-        response_type = "422"
-        response_422 = get_response(HTTPStatus.UNPROCESSABLE_ENTITY.value, start_time, aws_request_id, {})
-        assert response_422 == inputs_outputs[response_type]["output"]
-
-        response_type = "500"
-        response_500 = get_response(HTTPStatus.INTERNAL_SERVER_ERROR.value, start_time, aws_request_id, {})
-        assert response_500 == inputs_outputs[response_type]["output"]
-
-    @staticmethod
-    def test_get_parsed_bbox_points():
-        with open(TEST_EVENTS_FOLDER / "get_parsed_bbox_prompts_single_point.json") as tst_json:
-            inputs_outputs = json.load(tst_json)
-            for k, input_output in inputs_outputs.items():
-                print(f"k:{k}.")
-                raw_body = get_parsed_request_body(**input_output["input"])
-                output = get_parsed_bbox_points_with_dictlist_prompt(raw_body)
-                assert output == input_output["output"]
-
     @staticmethod
     def test_get_parsed_bbox_other_inputs():
         for json_filename in ["single_rectangle", "multi_prompt"]:
@@ -59,39 +18,6 @@ class WrappersHelpersTest(unittest.TestCase):
                 output = get_parsed_bbox_points_with_dictlist_prompt(parsed_input)
                 assert output == inputs_outputs["output"]
 
-    @staticmethod
-    def test_get_parsed_request_body():
-        from samgis_core.utilities.utilities import base64_encode
-
-        input_event = {
-            "event": {
-                "bbox": {
-                    "ne": {"lat": 38.03932961278458, "lng": 15.36808069832851},
-                    "sw": {"lat": 37.455509218936974, "lng": 14.632807441554068}
-                },
-                "prompt": [{"type": "point", "data": {"lat": 37.0, "lng": 15.0}, "label": 0}],
-                "zoom": 10, "source_type": "OpenStreetMap.Mapnik", "debug": True
-            }
-        }
-        expected_output_dict = {
-            "bbox": {
-                "ne": {"lat": 38.03932961278458, "lng": 15.36808069832851},
-                "sw": {"lat": 37.455509218936974, "lng": 14.632807441554068}
-            },
-            "prompt": [{"type": "point", "data": {"lat": 37.0, "lng": 15.0}, "label": 0}],
-            "zoom": 10, "source_type": "OpenStreetMap.Mapnik", "debug": True
-        }
-        output = get_parsed_request_body(input_event["event"])
-        assert output == ApiRequestBody.model_validate(input_event["event"])
-
-        input_event_str = json.dumps(input_event["event"])
-        output = get_parsed_request_body(input_event_str)
-        assert output == ApiRequestBody.model_validate(expected_output_dict)
-
-        event = {"body": base64_encode(input_event_str).decode("utf-8")}
-        output = get_parsed_request_body(event)
-        assert output == ApiRequestBody.model_validate(expected_output_dict)
-
     def test_get_parsed_bbox_points_with_string_prompt(self):
         from samgis_lisa_on_zero.io_package.wrappers_helpers import get_parsed_bbox_points_with_string_prompt
         req = {