feat: refactor app.py using samgis-lisa

app.py

@@ -1,40 +1,67 @@
 import json
 import os
-import pathlib
+from pathlib import Path
 from typing import Callable, NoReturn
 
+from asgi_correlation_id import CorrelationIdMiddleware
 import gradio as gr
 import spaces
+from starlette.responses import JSONResponse
+import structlog
 import uvicorn
+from dotenv import load_dotenv
 from fastapi import FastAPI, HTTPException, Request, status
 from fastapi.exceptions import RequestValidationError
-from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+from fastapi.responses import FileResponse, HTMLResponse
 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, session_logger
 from pydantic import ValidationError
+from samgis_core.utilities import create_folders_if_not_exists
+from samgis_core.utilities import frontend_builder
+from samgis_core.utilities.session_logger import setup_logging
+from samgis_web.utilities.constants import GRADIO_EXAMPLES_TEXT_LIST, GRADIO_MARKDOWN, GRADIO_EXAMPLE_BODY_STRING_PROMPT
+from samgis_web.utilities.type_hints import StringPromptApiRequestBody
 
-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
 
+load_dotenv()
+project_root_folder = Path(globals().get("__file__", "./_")).absolute().parent
+workdir = Path(os.getenv("WORKDIR", project_root_folder))
+model_folder = Path(project_root_folder / "machine_learning_models")
 
-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")
-VITE_GRADIO_URL = os.getenv("VITE_GRADIO_URL", "/gradio")
-FASTAPI_TITLE = "samgis-lisa-on-zero"
-app = FastAPI(title=FASTAPI_TITLE, version="1.0")
+log_level = os.getenv("LOG_LEVEL", "INFO")
+setup_logging(log_level=log_level)
+app_logger = structlog.stdlib.get_logger()
+app_logger.info(f"PROJECT_ROOT_FOLDER:{project_root_folder}, WORKDIR:{workdir}.")
 
+folders_map = os.getenv("FOLDERS_MAP", "{}")
+markdown_text = os.getenv("MARKDOWN_TEXT", "")
+examples_text_list = os.getenv("EXAMPLES_TEXT_LIST", "").split("\n")
+example_body = json.loads(os.getenv("EXAMPLE_BODY", "{}"))
+mount_gradio_app = bool(os.getenv("MOUNT_GRADIO_APP", ""))
+
+static_dist_folder = workdir / "static" / "dist"
+input_css_path = os.getenv("INPUT_CSS_PATH", "src/input.css")
+vite_gradio_url = os.getenv("VITE_GRADIO_URL", "/gradio")
+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")
+fastapi_title = "samgis-lisa-on-zero2"
+app = FastAPI(title=fastapi_title, version="1.0")
+
+
+@app.middleware("http")
+async def request_middleware(request, call_next):
+    from samgis_web.web.middlewares import logging_middleware
+
+    return await logging_middleware(request, call_next)
 
 @spaces.GPU
-@session_logger.set_uuid_logging
 def gpu_initialization() -> None:
     app_logger.info("GPU initialization...")
 
 
 def get_example_complete(example_text):
-    example_dict = dict(**GRADIO_EXAMPLE_BODY)
+    example_dict = dict(**GRADIO_EXAMPLE_BODY_STRING_PROMPT)
     example_dict["string_prompt"] = example_text
     return json.dumps(example_dict)
 
@@ -64,15 +91,14 @@ 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
+        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}.")
     workdir_folder_content = subprocess.run(
-        f"ls -l {WORKDIR}/", shell=True, universal_newlines=True, stdout=subprocess.PIPE
+        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}.")
@@ -83,32 +109,21 @@ def handle_exception_response(exception: Exception) -> NoReturn:
 
 
 @app.get("/health")
-@session_logger.set_uuid_logging
-def health() -> JSONResponse:
-    import importlib.metadata
-    from importlib.metadata import PackageNotFoundError
-
-    core_version = lisa_on_cuda_version = samgis_lisa_on_cuda_version = ""
-    try:
-        core_version = importlib.metadata.version('samgis_core')
-        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}.")
-
-    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)
+async def health() -> JSONResponse:
+    from samgis_web.__version__ import __version__ as version_web
+    from samgis_core.__version__ import __version__ as version_core
+    from lisa_on_cuda.__version__ import __version__ as version_lisa_on_cuda
+    from samgis_lisa.__version__ import __version__ as version_samgis_lisa
+
+    app_logger.info(f"still alive, version_web:{version_web}, version_core:{version_core}.")
+    app_logger.info(f"still alive, version_lisa_on_cuda:{version_lisa_on_cuda}, version_samgis_lisa:{version_samgis_lisa}.")
     return JSONResponse(status_code=200, content={"msg": "still alive..."})
 
 
-@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
+    from samgis_lisa.io_package.wrappers_helpers import get_parsed_bbox_points_with_string_prompt
+    from samgis_lisa.prediction_api import lisa
+    from samgis_lisa.utilities.constants import LISA_INFERENCE_FN
 
     app_logger.info("starting lisa inference request...")
 
@@ -140,13 +155,15 @@ def infer_lisa_gradio(request_input: StringPromptApiRequestBody) -> str:
             app_logger.debug(f"complete json.dumps(body):{dumped}.")
             return dumped
         except Exception as inference_exception:
-            handle_exception_response(inference_exception)
+            app_logger.error(f"inference_exception:{inference_exception}.")
+            app_logger.error(f"inference_exception, request_input:{request_input}.")
+            raise HTTPException(status_code=500, detail="Internal Server Error")
     except ValidationError as va1:
         app_logger.error(f"validation error: {str(va1)}.")
-        raise ValidationError("Unprocessable Entity")
+        app_logger.error(f"ValidationError, request_input:{request_input}.")
+        raise RequestValidationError("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)
@@ -156,72 +173,46 @@ def infer_lisa(request_input: StringPromptApiRequestBody) -> JSONResponse:
 
 
 @app.exception_handler(RequestValidationError)
-@session_logger.set_uuid_logging
 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}.")
-    headers = request.headers.items()
-    app_logger.error(f'request header: {dict(headers)}.')
-    params = request.query_params.items()
-    app_logger.error(f'request query params: {dict(params)}.')
-    return JSONResponse(
-        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-        content={"msg": "Error - Unprocessable Entity"}
-    )
+    from samgis_web.web import exception_handlers
+
+    return exception_handlers.request_validation_exception_handler(request, exc)
 
 
 @app.exception_handler(HTTPException)
-@session_logger.set_uuid_logging
 def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
-    app_logger.error(f"exception: {str(exc)}.")
-    headers = request.headers.items()
-    app_logger.error(f'request header: {dict(headers)}.')
-    params = request.query_params.items()
-    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"}
-    )
+    from samgis_web.web import exception_handlers
+
+    return exception_handlers.http_exception_handler(request, exc)
 
 
+create_folders_if_not_exists.folders_creation(folders_map)
 write_tmp_on_disk = os.getenv("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:
-            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)
+        assert Path(write_tmp_on_disk).is_dir()
         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}...")
-        raise runtime_error
-    templates = Jinja2Templates(directory=WORKDIR / "static")
-
+        templates = Jinja2Templates(directory=str(project_root_folder / "static"))
 
-    @app.get("/vis_output", response_class=HTMLResponse)
-    def list_files(request: Request):
+        @app.get("/vis_output", response_class=HTMLResponse)
+        def list_files(request: Request):
 
-        files = os.listdir(write_tmp_on_disk)
-        files_paths = sorted([f"{request.url._url}/{f}" for f in files])
-        print(files_paths)
-        return templates.TemplateResponse(
-            "list_files.html", {"request": request, "files": files_paths}
-        )
+            files = os.listdir(write_tmp_on_disk)
+            files_paths = sorted([f"{request.url._url}/{f}" for f in files])
+            print(files_paths)
+            return templates.TemplateResponse(
+                "list_files.html", {"request": request, "files": files_paths}
+            )
+    except (AssertionError, RuntimeError) as rerr:
+        app_logger.error(f"{rerr} while loading the folder write_tmp_on_disk:{write_tmp_on_disk}...")
+        raise rerr
 
-static_dist_folder = WORKDIR / "static" / "dist"
 frontend_builder.build_frontend(
-    project_root_folder=frontend_builder.env_project_root_folder,
-    input_css_path=frontend_builder.env_input_css_path,
+    project_root_folder=workdir,
+    input_css_path=input_css_path,
     output_dist_folder=static_dist_folder
 )
-create_folders_and_variables_if_not_exists.folders_creation()
-
 app_logger.info("build_frontend ok!")
 
 templates = Jinja2Templates(directory="templates")
@@ -229,44 +220,46 @@ templates = Jinja2Templates(directory="templates")
 app.mount("/static", StaticFiles(directory=static_dist_folder, html=True), name="static")
 # important: the index() function and the app.mount MUST be at the end
 # samgis.html
-app.mount(VITE_SAMGIS_URL, StaticFiles(directory=static_dist_folder, html=True), name="samgis")
+app.mount(vite_samgis_url, StaticFiles(directory=static_dist_folder, html=True), name="samgis")
 
 
-@app.get(VITE_SAMGIS_URL)
+@app.get(vite_samgis_url)
 async def samgis() -> FileResponse:
-    return FileResponse(path=static_dist_folder / "samgis.html", media_type="text/html")
+    return FileResponse(path=str(static_dist_folder / "samgis.html"), media_type="text/html")
 
 
 # lisa.html
-app.mount(VITE_LISA_URL, StaticFiles(directory=static_dist_folder, html=True), name="lisa")
+app.mount(vite_lisa_url, StaticFiles(directory=static_dist_folder, html=True), name="lisa")
 
 
-@app.get(VITE_LISA_URL)
+@app.get(vite_lisa_url)
 async def lisa() -> FileResponse:
-    return FileResponse(path=static_dist_folder / "lisa.html", media_type="text/html")
+    return FileResponse(path=str(static_dist_folder / "lisa.html"), media_type="text/html")
 
 
 # index.html (lisa.html copy)
-app.mount(VITE_INDEX_URL, StaticFiles(directory=static_dist_folder, html=True), name="index")
+app.mount(vite_index_url, StaticFiles(directory=static_dist_folder, html=True), name="index")
 
 
-@app.get(VITE_INDEX_URL)
+@app.get(vite_index_url)
 async def index() -> FileResponse:
-    return FileResponse(path=static_dist_folder / "index.html", media_type="text/html")
+    return FileResponse(path=str(static_dist_folder / "index.html"), media_type="text/html")
+
 
+app_logger.info(f"creating gradio interface...")
+gr_interface = get_gradio_interface_geojson(infer_lisa_gradio)
+app_logger.info(f"gradio interface created, mounting gradio app on url {vite_gradio_url} within FastAPI...")
+app = gr.mount_gradio_app(app, gr_interface, path=vite_gradio_url)
+app_logger.info("mounted gradio app within fastapi")
 
-app_helpers.app_logger.info(f"creating gradio interface...")
-io = get_gradio_interface_geojson(infer_lisa_gradio)
-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.app_logger.info("mounted gradio app within fastapi")
+# add the CorrelationIdMiddleware AFTER the @app.middleware("http") decorated function to avoid missing request id
+app.add_middleware(CorrelationIdMiddleware)
 
 
 if __name__ == '__main__':
     try:
         uvicorn.run(host="0.0.0.0", port=7860, app=app)
     except Exception as ex:
-        app_logger.error(f"fastapi/gradio application {FASTAPI_TITLE}, exception:{ex}.")
-        print(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