feat: use everywhere a single app_logger instance defined in samgis_lisa_on_zero.__init__

app.py

@@ -1,5 +1,4 @@
 import json
-import logging
 import os
 import pathlib
 from typing import Callable, NoReturn
@@ -15,13 +14,11 @@ from fastapi.templating import Jinja2Templates
 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_lisa_on_zero import PROJECT_ROOT_FOLDER, WORKDIR
+from samgis_lisa_on_zero import PROJECT_ROOT_FOLDER, WORKDIR, app_logger
 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()
-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")
@@ -33,7 +30,7 @@ app = FastAPI(title=FASTAPI_TITLE, version="1.0")
 @spaces.GPU
 @session_logger.set_uuid_logging
 def gpu_initialization() -> None:
-    logging.info("GPU initialization...")
+    app_logger.info("GPU initialization...")
 
 
 def get_example_complete(example_text):
@@ -73,13 +70,13 @@ def handle_exception_response(exception: Exception) -> NoReturn:
     project_root_folder_content = subprocess.run(
         f"ls -l {PROJECT_ROOT_FOLDER}/", shell=True, universal_newlines=True, stdout=subprocess.PIPE
     )
-    logging.error(f"project_root folder 'ls -l' command output: {project_root_folder_content.stdout}.")
+    app_logger.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
     )
-    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}.")
+    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}.")
     raise HTTPException(
         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Internal server error on inference"
     )
@@ -97,13 +94,13 @@ 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:
-        logging.error(f"pe:{pe}.")
+        app_logger.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},"""
 
-    logging.info(msg)
+    app_logger.info(msg)
     return JSONResponse(status_code=200, content={"msg": "still alive..."})
 
 
@@ -113,39 +110,39 @@ def infer_lisa_gradio(request_input: StringPromptApiRequestBody) -> str:
     from samgis_lisa_on_zero.prediction_api import lisa
     from samgis_lisa_on_zero.utilities.constants import LISA_INFERENCE_FN
 
-    logging.info("starting lisa inference request...")
+    app_logger.info("starting lisa inference request...")
 
     try:
         import time
 
         time_start_run = time.time()
         body_request = get_parsed_bbox_points_with_string_prompt(request_input)
-        logging.info(f"lisa body_request:{body_request}.")
+        app_logger.info(f"lisa body_request:{body_request}.")
         try:
             source = body_request["source"]
             source_name = body_request["source_name"]
-            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}.")
+            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}.")
             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
-            logging.info(f"duration_run:{duration_run}.")
+            app_logger.info(f"duration_run:{duration_run}.")
             body = {
                 "duration_run": duration_run,
                 "output": output
             }
             dumped = json.dumps(body)
-            logging.info(f"json.dumps(body) type:{type(dumped)}, len:{len(dumped)}.")
-            logging.debug(f"complete json.dumps(body):{dumped}.")
+            app_logger.info(f"json.dumps(body) type:{type(dumped)}, len:{len(dumped)}.")
+            app_logger.debug(f"complete json.dumps(body):{dumped}.")
             return dumped
         except Exception as inference_exception:
             handle_exception_response(inference_exception)
     except ValidationError as va1:
-        logging.error(f"validation error: {str(va1)}.")
+        app_logger.error(f"validation error: {str(va1)}.")
         raise ValidationError("Unprocessable Entity")
 
 
@@ -153,20 +150,20 @@ def infer_lisa_gradio(request_input: StringPromptApiRequestBody) -> str:
 @app.post("/infer_lisa")
 def infer_lisa(request_input: StringPromptApiRequestBody) -> JSONResponse:
     dumped = infer_lisa_gradio(request_input=request_input)
-    logging.info(f"json.dumps(body) type:{type(dumped)}, len:{len(dumped)}.")
-    logging.debug(f"complete json.dumps(body):{dumped}.")
+    app_logger.info(f"json.dumps(body) type:{type(dumped)}, len:{len(dumped)}.")
+    app_logger.debug(f"complete json.dumps(body):{dumped}.")
     return JSONResponse(status_code=200, content={"body": dumped})
 
 
 @app.exception_handler(RequestValidationError)
 @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}.")
+    app_logger.error(f"exception errors: {exc.errors()}.")
+    app_logger.error(f"exception body: {exc.body}.")
     headers = request.headers.items()
-    logging.error(f'request header: {dict(headers)}.')
+    app_logger.error(f'request header: {dict(headers)}.')
     params = request.query_params.items()
-    logging.error(f'request query params: {dict(params)}.')
+    app_logger.error(f'request query params: {dict(params)}.')
     return JSONResponse(
         status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
         content={"msg": "Error - Unprocessable Entity"}
@@ -176,11 +173,11 @@ def request_validation_exception_handler(request: Request, exc: RequestValidatio
 @app.exception_handler(HTTPException)
 @session_logger.set_uuid_logging
 def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
-    logging.error(f"exception: {str(exc)}.")
+    app_logger.error(f"exception: {str(exc)}.")
     headers = request.headers.items()
-    logging.error(f'request header: {dict(headers)}.')
+    app_logger.error(f'request header: {dict(headers)}.')
     params = request.query_params.items()
-    logging.error(f'request query params: {dict(params)}.')
+    app_logger.error(f'request query params: {dict(params)}.')
     return JSONResponse(
         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
         content={"msg": "Error - Internal Server Error"}
@@ -188,21 +185,21 @@ def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse
 
 
 write_tmp_on_disk = os.getenv("WRITE_TMP_ON_DISK", "")
-logging.info(f"write_tmp_on_disk:{write_tmp_on_disk}.")
+app_logger.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:
-            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()}.")
+            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()}.")
         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:
-        logging.error(f"{runtime_error} while loading the folder write_tmp_on_disk:{write_tmp_on_disk}...")
+        app_logger.error(f"{runtime_error} while loading the folder write_tmp_on_disk:{write_tmp_on_disk}...")
         raise runtime_error
     templates = Jinja2Templates(directory=WORKDIR / "static")
 
@@ -225,7 +222,7 @@ frontend_builder.build_frontend(
 )
 create_folders_and_variables_if_not_exists.folders_creation()
 
-logging.info("build_frontend ok!")
+app_logger.info("build_frontend ok!")
 
 templates = Jinja2Templates(directory="templates")
 
@@ -258,20 +255,18 @@ async def index() -> FileResponse:
     return FileResponse(path=static_dist_folder / "index.html", media_type="text/html")
 
 
-app_helpers.logging.info(f"creating gradio interface...")
+app_helpers.app_logger.info(f"creating gradio interface...")
 io = get_gradio_interface_geojson(infer_lisa_gradio)
-app_helpers.logging.info(
+app_helpers.app_logger.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.logging.info("mounted gradio app within fastapi")
+app_helpers.app_logger.info("mounted gradio app within fastapi")
 
 
 if __name__ == '__main__':
     try:
         uvicorn.run(host="0.0.0.0", port=7860, app=app)
     except Exception as ex:
-        import logging
-
-        logging.error(f"fastapi/gradio application {FASTAPI_TITLE}, exception:{ex}.")
+        app_logger.error(f"fastapi/gradio application {FASTAPI_TITLE}, exception:{ex}.")
         print(f"fastapi/gradio application {FASTAPI_TITLE}, exception:{ex}.")
         raise ex

samgis_lisa_on_zero/__init__.py

@@ -1,4 +1,5 @@
 """Get machine learning predictions from geodata raster images"""
+import logging
 import os
 
 # not used here but contextily_tile is imported in samgis_lisa_on_zero.io_package.tms2geotiff
@@ -6,7 +7,6 @@ from contextily import tile as contextily_tile
 from pathlib import Path
 
 from lisa_on_cuda.utils import session_logger
-
 from samgis_lisa_on_zero.utilities.constants import SERVICE_NAME
 
 
@@ -15,5 +15,7 @@ PROJECT_ROOT_FOLDER = Path(os.getenv("PROJECT_ROOT_FOLDER", ROOT))
 WORKDIR = Path(os.getenv("WORKDIR", ROOT))
 MODEL_FOLDER_PROJECT_ROOT_FOLDER = Path(PROJECT_ROOT_FOLDER / "machine_learning_models")
 MODEL_FOLDER = Path(os.getenv("MODEL_FOLDER", MODEL_FOLDER_PROJECT_ROOT_FOLDER))
+
 loglevel = os.getenv('LOGLEVEL', 'INFO').upper()
 session_logger.change_logging(loglevel)
+app_logger = logging.getLogger(__name__)

samgis_lisa_on_zero/io_package/coordinates_pixel_conversion.py

@@ -1,16 +1,12 @@
 """functions useful to convert to/from latitude-longitude coordinates to pixel image coordinates"""
-import logging
-
 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
 
 
-app_logger = logging.getLogger(__name__)
-
-
 @session_logger.set_uuid_logging
 def _get_latlng2pixel_projection(latlng: LatLngDict) -> ImagePixelCoordinates:
     from math import log, pi, sin

samgis_lisa_on_zero/io_package/geo_helpers.py

@@ -1,14 +1,11 @@
 """handle geo-referenced raster images"""
-import logging
 
 from affine import Affine
+from lisa_on_cuda.utils import session_logger
 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
-
-
-app_logger = logging.getLogger(__name__)
+from samgis_lisa_on_zero import app_logger
 
 
 @session_logger.set_uuid_logging

samgis_lisa_on_zero/io_package/raster_helpers.py

@@ -9,8 +9,7 @@ from lisa_on_cuda.utils import session_logger
 from samgis_lisa_on_zero.utilities.constants import OUTPUT_CRS_STRING
 from samgis_lisa_on_zero.utilities.type_hints import XYZTerrainProvidersNames
 
-
-app_logger = logging.getLogger(__name__)
+from samgis_lisa_on_zero import app_logger
 
 
 def get_nextzen_terrain_rgb_formula(red: ndarray, green: ndarray, blue: ndarray) -> ndarray:

samgis_lisa_on_zero/io_package/tms2geotiff.py

@@ -1,18 +1,17 @@
-import logging
 import os
 
+from lisa_on_cuda.utils import session_logger
 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,
                                                      ZOOM_AUTO, BOOL_USE_CACHE)
 from samgis_lisa_on_zero.utilities.type_hints import tuple_ndarray_transform
 
 
-app_logger = logging.getLogger(__name__)
 bool_use_cache = int(os.getenv("BOOL_USE_CACHE", BOOL_USE_CACHE))
 n_connection = int(os.getenv("N_CONNECTION", N_CONNECTION))
 n_max_retries = int(os.getenv("N_MAX_RETRIES", N_MAX_RETRIES))

samgis_lisa_on_zero/io_package/wrappers_helpers.py

@@ -1,20 +1,17 @@
 """lambda helper functions"""
-import logging
 from typing import Dict
 
-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 xyzservices import providers, TileProvider
+
+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
 from samgis_lisa_on_zero.utilities.type_hints import (
     ApiRequestBody, XYZTerrainProvidersNames, XYZDefaultProvidersNames, StringPromptApiRequestBody)
 
 
-app_logger = logging.getLogger(__name__)
-
-
 @session_logger.set_uuid_logging
 def get_parsed_bbox_points_with_string_prompt(request_input: StringPromptApiRequestBody) -> Dict:
     """

samgis_lisa_on_zero/prediction_api/lisa.py

@@ -1,18 +1,16 @@
-import logging
 from datetime import datetime
 
 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 import app_logger
 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..."
-app_logger = logging.getLogger(__name__)
 
 
 @session_logger.set_uuid_logging

samgis_lisa_on_zero/prediction_api/predictors.py

@@ -1,5 +1,4 @@
 """functions using machine learning instance model(s)"""
-import logging
 
 from lisa_on_cuda.utils import session_logger
 from samgis_core.prediction_api import sam_onnx2, sam_onnx_inference
@@ -7,6 +6,7 @@ from samgis_core.utilities.constants import MODEL_ENCODER_NAME, MODEL_DECODER_NA
 from samgis_core.utilities.type_hints import LlistFloat, DictStrInt, ListDict
 
 from samgis_lisa_on_zero import MODEL_FOLDER
+from samgis_lisa_on_zero import app_logger
 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
 from samgis_lisa_on_zero.io_package.tms2geotiff import download_extent
@@ -14,8 +14,6 @@ from samgis_lisa_on_zero.io_package.wrappers_helpers import check_source_type_is
 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
 
-app_logger = logging.getLogger(__name__)
-
 
 @session_logger.set_uuid_logging
 def samexporter_predict(