[feat] handle requests with errors

.gitignore

@@ -0,0 +1,6 @@
+venv/
+*.pyc
+__cache__
+.idea
+tmp/
+.env*

Dockerfile

@@ -0,0 +1,32 @@
+FROM ghcr.io/osgeo/gdal:ubuntu-small-3.7.2
+
+WORKDIR /code
+COPY ./requirements.txt /code/requirements.txt
+COPY ./requirements_pip.txt /code/requirements_pip.txt
+
+RUN apt update && apt install -y g++ make cmake unzip libcurl4-openssl-dev python3-pip
+
+# avoid segment-geospatial exception caused by missing libGL.so.1 library
+RUN apt install -y libgl1 curl
+RUN ls -ld /usr/lib/x86_64-linux-gnu/libGL.so* || echo "libGL.so* not found..."
+
+RUN which python
+RUN python --version
+RUN python -m pip install --no-cache-dir --upgrade -r /code/requirements_pip.txt
+RUN python -m pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
+RUN python -m pip install --no-cache-dir -r /code/requirements.txt
+
+RUN useradd -m -u 1000 user
+
+USER user
+
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+RUN curl -o ${HOME}/sam_vit_h_4b8939.pth https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth
+RUN ls -l ${HOME}/
+COPY --chown=user . $HOME/app
+
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,5 +1,5 @@
 ---
-title: Segment Anything
+title: Segment Geospatial
 emoji: 📉
 colorFrom: red
 colorTo: blue
@@ -7,4 +7,27 @@ sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Build the docker image:
+
+```bash
+# clean any old active containers
+docker stop $(docker ps -a -q); docker rm $(docker ps -a -q)
+
+# build the image, use the tag "semgeo"
+docker build . --tag semgeo --progress=plain
+```
+
+Run the container (keep it on background) and show logs
+
+```bash
+docker run  -d --name semgeo -p 7860:7860 semgeo; docker logs -f semgeo
+```
+
+Test it with curl:
+
+```bash
+curl -X 'POST' \
+  'http://localhost:7860/infer_samgeo' \
+  -H 'accept: application/json' \
+  -d '{}'
+```

requirements.txt

@@ -0,0 +1,5 @@
+fastapi
+bson
+python-dotenv
+segment-geospatial
+uvicorn[standard]

requirements_pip.txt

@@ -0,0 +1,3 @@
+pip
+wheel
+setuptools

src/main.py

@@ -0,0 +1,115 @@
+import json
+from typing import List
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+from src.utilities.utilities import setup_logging
+
+
+app = FastAPI()
+local_logger = setup_logging()
+
+
+class Input(BaseModel):
+    name: str
+    bbox: List[float]
+    points_coords: List[List[float]]
+
+
+@app.post("/post_test")
+async def post_test(input: Input) -> JSONResponse:
+    bbox = input.bbox
+    name = input.name
+    points_coords = input.points_coords
+    return JSONResponse(
+        status_code=200,
+        content={
+            "msg": name, "bbox": bbox, "points_coords": points_coords
+        }
+    )
+
+
+@app.get("/hello")
+async def hello() -> JSONResponse:
+    return JSONResponse(status_code=200, content={"msg": "hello"})
+
+
+@app.post("/infer_samgeo")
+def samgeo():
+    import subprocess
+
+    from src.prediction_api.predictor import base_predict
+
+    local_logger = setup_logging()
+    local_logger.info("starting inference request...")
+
+    try:
+        import time
+
+        time_start_run = time.time()
+        # debug = True
+        # local_logger = setup_logging(debug)
+        message = "point_coords_segmentation"
+        bbox = [-122.1497, 37.6311, -122.1203, 37.6458]
+        point_coords = [[-122.1419, 37.6383]]
+        try:
+            output = base_predict(bbox=bbox, point_coords=point_coords)
+
+            duration_run = time.time() - time_start_run
+            body = {
+                "message": message,
+                "duration_run": duration_run,
+                # "request_id": request_id
+            }
+            local_logger.info(f"body:{body}.")
+            body["output"] = output
+            # local_logger.info(f"End_request::{request_id}...")
+            return JSONResponse(status_code=200, content={"body": json.dumps(body)})
+        except Exception as inference_exception:
+            home_content = subprocess.run("ls -l /home/user", shell=True, universal_newlines=True, stdout=subprocess.PIPE)
+            local_logger.error(f"/home/user ls -l: {home_content.stdout}.")
+            local_logger.error(f"inference error:{inference_exception}.")
+            return HTTPException(status_code=500, detail="Internal server error on inference")
+    except Exception as generic_exception:
+        local_logger.error(f"generic error:{generic_exception}.")
+        return HTTPException(status_code=500, detail="Generic internal server error")
+
+
+@app.exception_handler(RequestValidationError)
+async def request_validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
+    local_logger.error(f"exception errors: {exc.errors()}.")
+    local_logger.error(f"exception body: {exc.body}.")
+    headers = request.headers.items()
+    local_logger.error(f'request header: {dict(headers)}.' )
+    params = request.query_params.items()
+    local_logger.error(f'request query params: {dict(params)}.')
+    return JSONResponse(
+        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+        content={"msg": "Error - Unprocessable Entity"}
+    )
+
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
+    local_logger.error(f"exception: {str(exc)}.")
+    headers = request.headers.items()
+    local_logger.error(f'request header: {dict(headers)}.' )
+    params = request.query_params.items()
+    local_logger.error(f'request query params: {dict(params)}.')
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={"msg": "Error - Internal Server Error"}
+    )
+
+
+# important: the index() function and the app.mount MUST be at the end
+app.mount("/", StaticFiles(directory="static", html=True), name="static")
+
+
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(path="/app/static/index.html", media_type="text/html")
+

src/prediction_api/predictor.py

@@ -0,0 +1,43 @@
+# Press the green button in the gutter to run the script.
+import json
+
+from src.utilities.constants import ROOT
+from src.utilities.utilities import setup_logging
+
+
+local_logger = setup_logging()
+
+
+def base_predict(bbox, point_coords, point_crs="EPSG:4326", zoom=16, model_name:str="vit_h", root_folder:str=ROOT) -> str:
+    from samgeo import SamGeo, tms_to_geotiff
+
+    image = f"{root_folder}/satellite.tif"
+    local_logger.info("start tms_to_geotiff")
+    # bbox: image input coordinate
+    tms_to_geotiff(output=image, bbox=bbox, zoom=zoom, source="Satellite", overwrite=True)
+
+    local_logger.info(f"geotiff created, start to initialize samgeo instance (read model {model_name} from {root_folder})...")
+    predictor = SamGeo(
+        model_type=model_name,
+        checkpoint_dir=root_folder,
+        automatic=False,
+        sam_kwargs=None,
+    )
+    local_logger.info(f"initialized samgeo instance, start to set_image {image}...")
+    predictor.set_image(image)
+    output_name = f"{root_folder}/output.tif"
+    
+    local_logger.info(f"done set_image, start prediction...")
+    predictor.predict(point_coords, point_labels=len(point_coords), point_crs=point_crs, output=output_name)
+    
+    local_logger.info(f"done prediction, start tiff to geojson conversion...")
+
+    # geotiff to geojson
+    vector = f"{root_folder}/feats.geojson"
+    predictor.tiff_to_geojson(output_name, vector, bidx=1)
+    local_logger.info(f"start reading geojson...")
+
+    with open(vector) as out_gdf:
+        out_gdf_str = json.load(out_gdf)
+        local_logger.info(f"number of fields in geojson output:{len(out_gdf_str)}.")
+        return out_gdf_str

src/utilities/__init__.py

@@ -0,0 +1 @@
+"""various helpers utilities"""

src/utilities/constants.py

@@ -0,0 +1,19 @@
+"""Project constants"""
+CHANNEL_EXAGGERATIONS_LIST = [2.5, 1.1, 2.0]
+INPUT_CRS_STRING = "EPSG:4326"
+OUTPUT_CRS_STRING = "EPSG:3857"
+ROOT = "/home/user"
+NODATA_VALUES = -32768
+SKIP_CONDITIONS_LIST = [{"skip_key": "confidence", "skip_value": 0.5, "skip_condition": "major"}]
+FEATURE_SQUARE_TEMPLATE = [
+    {'type': 'Feature', 'properties': {'id': 1},
+     'geometry': {
+         'type': 'MultiPolygon',
+         'coordinates': [[]]
+     }}
+]
+GEOJSON_SQUARE_TEMPLATE = {
+    'type': 'FeatureCollection', 'name': 'etna_wgs84p',
+    'crs': {'type': 'name', 'properties': {'name': 'urn:ogc:def:crs:OGC:1.3:CRS84'}},
+    'features': FEATURE_SQUARE_TEMPLATE
+}

src/utilities/measures.py

@@ -0,0 +1,76 @@
+"""helpers for compute measures: hash, time benchmarks"""
+from pathlib import Path
+
+
+def hash_calculate(arr: any, debug: bool = False) -> str or bytes:
+    """
+    Return computed hash from input variable (typically a numpy array).
+
+    Args:
+        arr: input variable
+        debug: logging debug argument
+
+    Returns:
+        str or bytes: computed hash from input variable
+
+    """
+    import hashlib
+    import numpy as np
+    from base64 import b64encode
+
+    from src.utilities.utilities import setup_logging
+    local_logger = setup_logging(debug)
+
+    if isinstance(arr, np.ndarray):
+        hash_fn = hashlib.sha256(arr.data)
+    elif isinstance(arr, dict):
+        import json
+        from src.utilities.serialize import serialize
+
+        serialized = serialize(arr)
+        variable_to_hash = json.dumps(serialized, sort_keys=True).encode('utf-8')
+        hash_fn = hashlib.sha256(variable_to_hash)
+    elif isinstance(arr, str):
+        try:
+            hash_fn = hashlib.sha256(arr)
+        except TypeError:
+            local_logger.warning(f"TypeError, re-try encoding arg:{arr},type:{type(arr)}.")
+            hash_fn = hashlib.sha256(arr.encode('utf-8'))
+    elif isinstance(arr, bytes):
+        hash_fn = hashlib.sha256(arr)
+    else:
+        raise ValueError(f"variable 'arr':{arr} not yet handled.")
+    return b64encode(hash_fn.digest())
+
+
+def sha256sum(filename: Path or str) -> str:
+    """
+    Return computed hash for input file.
+
+    Args:
+        filename: input variable
+
+    Returns:
+        str: computed hash
+
+    """
+    import hashlib
+    import mmap
+
+    h = hashlib.sha256()
+    with open(filename, 'rb') as f:
+        with mmap.mmap(f.fileno(), 0, prot=mmap.PROT_READ) as mm:
+            h.update(mm)
+    return h.hexdigest()
+
+
+def perf_counter() -> float:
+    """
+    Performance counter for benchmarking.
+
+    Returns:
+        float: computed time value at execution time
+
+    """
+    import time
+    return time.perf_counter()

src/utilities/serialize.py

@@ -0,0 +1,86 @@
+"""Serialize objects"""
+from typing import Mapping
+
+from src.utilities.type_hints import ts_dict_str3, ts_dict_str2
+
+
+def serialize(obj:any, include_none:bool=False) -> object:
+    """
+    Return the input object into a serializable one
+
+    Args:
+        obj: Object to serialize
+        include_none: bool to indicate if include also keys with None values during dict serialization
+
+    Returns:
+        object: serialized object
+
+    """
+    return _serialize(obj, include_none)
+
+
+def _serialize(obj:any, include_none:bool) -> any:
+    import numpy as np
+
+    primitive = (int, float, str, bool)
+    # print(type(obj))
+    try:
+        if obj is None:
+            return None
+        elif isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()
+        elif isinstance(obj, primitive):
+            return obj
+        elif type(obj) is list:
+            return _serialize_list(obj, include_none)
+        elif type(obj) is tuple:
+            return list(obj)
+        elif type(obj) is bytes:
+            return _serialize_bytes(obj)
+        elif isinstance(obj, Exception):
+            return _serialize_exception(obj)
+        # elif isinstance(obj, object):
+        #     return _serialize_object(obj, include_none)
+        else:
+            return _serialize_object(obj, include_none)
+    except Exception as e_serialize:
+        from src.utilities.utilities import setup_logging
+        serialize_logger = setup_logging()
+        serialize_logger.error(f"e_serialize::{e_serialize}, type_obj:{type(obj)}, obj:{obj}.")
+        return f"object_name:{str(obj)}__object_type_str:{str(type(obj))}."
+
+
+def _serialize_object(obj:Mapping[any, object], include_none:bool) -> dict[any]:
+    from bson import ObjectId
+
+    res = {}
+    if type(obj) is not dict:
+        keys = [i for i in obj.__dict__.keys() if (getattr(obj, i) is not None) or include_none]
+    else:
+        keys = [i for i in obj.keys() if (obj[i] is not None) or include_none]
+    for key in keys:
+        if type(obj) is not dict:
+            res[key] = _serialize(getattr(obj, key), include_none)
+        elif isinstance(obj[key], ObjectId):
+            continue
+        else:
+            res[key] = _serialize(obj[key], include_none)
+    return res
+
+
+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:
+    import base64
+    encoded = base64.b64encode(b)
+    return {"value": encoded.decode('ascii'), "type": "bytes"}
+
+
+def _serialize_exception(e: Exception) -> ts_dict_str3:
+    return {"msg": str(e), "type": str(type(e)), **e.__dict__}

src/utilities/type_hints.py

@@ -0,0 +1,30 @@
+"""custom type hints"""
+from typing import List, Dict, Tuple
+
+import numpy as np
+
+# ts_ddict1, ts_float64_1, ts_float64_2, ts_dict_str3, ts_dict_str2
+input_floatlist = List[float]
+input_floatlist2 = List[input_floatlist]
+ts_ddict1 = Dict[str, Dict[str, any], Dict, Dict, any]
+ts_dict_str2 = Dict[str, str]
+ts_dict_str3 = Dict[str, str, any]
+ts_float64_1 = Tuple[np.float64, np.float64, np.float64, np.float64, np.float64, np.float64]
+ts_float64_2 = Tuple[np.float64, np.float64, np.float64, np.float64, np.float64, np.float64, np.float64]
+
+"""
+ts_list_str1 = List[str]
+ts_http2 = Tuple[ts_list_str1, ts_list_str1]
+ts_list_float2 = List[float, float]
+ts_llist_float2 = List[ts_list_float2, ts_list_float2]
+ts_geojson = Dict[str, str, Dict[str, Dict[str]], List[str, Dict[int], Dict[str, List]]]
+ts_dict_str2b = Dict[str, any]
+ts_ddict2 = Dict[str, Dict, Dict[str, List]]
+ts_tuple_str2 = Tuple[str, str]
+ts_tuple_arr2 = Tuple[np.ndarray, np.ndarray]
+ts_tuple_flat2 = Tuple[float, float]
+ts_tuple_flat4 = Tuple[float, float, float, float]
+ts_list_float4 = List[float, float, float, float]
+ts_tuple_int4 = Tuple[int, int, int, int]
+ts_ddict3 = Dict[List[Dict[float | int | str]], Dict[float | int]]
+"""

src/utilities/utilities.py

@@ -0,0 +1,100 @@
+"""Various utilities (logger, time benchmark, args dump, numerical and stats info)"""
+import logging
+
+from src.utilities.constants import ROOT
+
+
+def setup_logging(debug: bool = False, formatter: str = '%(asctime)s - %(name)s - %(funcName)s(): line %(lineno)d - %(levelname)s - %(message)s') -> logging.Logger:
+    """
+    Create a logging instance with log string formatter.
+
+    Args:
+        debug: logging debug argument
+        formatter: log string formatter
+
+    Returns:
+        Logger
+
+    """
+    import logging
+    import sys
+
+    logger = logging.getLogger()
+    for h in logger.handlers:
+        logger.removeHandler(h)
+
+    h = logging.StreamHandler(sys.stdout)
+
+    h.setFormatter(logging.Formatter(formatter))
+    logger.addHandler(h)
+    logger.setLevel(logging.INFO)
+
+    if debug:
+        logger.setLevel(logging.DEBUG)
+    logger.debug(f"type_logger:{type(logger)}.")
+    return logger
+
+
+def get_constants(event: dict, root: str = ROOT, dotenv_filename: str = ".env", debug=False) -> dict:
+    """
+    Return constants we need to use from event, context and environment variables (both production and test).
+    
+    Args:
+        event: request event
+        root: path containing the dotenv file
+        dotenv_filename: dotenv filename
+        debug: logging debug argument
+
+    Returns:
+        dict: project constants object
+
+    """
+    import json
+    import os
+    # from dotenv import dotenv_values
+
+    from src.utilities.constants import SKIP_CONDITIONS_LIST
+    local_logger = setup_logging(debug)
+    try:
+        body = event["body"]
+    except Exception as e_constants1:
+        local_logger.error(f"e_constants1:{e_constants1}.")
+        body = event
+
+    if isinstance(body, str):
+        body = json.loads(event["body"])
+
+    try:
+        debug = body["debug"]
+        local_logger.info(f"re-try get debug value:{debug}, log_level:{local_logger.level}.")
+        local_logger = setup_logging(debug)
+    except KeyError:
+        local_logger.error("get_constants:: no debug key, pass...")
+    local_logger.debug(f"constants debug:{debug}, log_level:{local_logger.level}, body:{body}.")
+
+    try:
+        dotenv_file_path = os.path.join(root, dotenv_filename)
+        local_logger.info(f"root_path:{root}, dotenv file:{dotenv_file_path}.")
+        # secrets = dotenv_values(dotenv_file_path)
+
+        try:
+            skip_conditions_list = body["skip_conditions_list"]
+            local_logger.info(f"found skip_conditions_list, using it: {skip_conditions_list}.")
+        except KeyError:
+            skip_conditions_list = SKIP_CONDITIONS_LIST
+
+        return {
+            "bounding_box": body["bounding_box"],
+            "zoom": body["zoom"],
+            "debug": debug,
+            "slope_cellsize": body["slope_cellsize"],
+            "model_project_name": body["model_project_name"],
+            "model_version": body["model_version"],
+            "skip_conditions_list": skip_conditions_list
+        }
+    except KeyError as e_key_constants2:
+        local_logger.error(f"e_key_constants2:{e_key_constants2}.")
+        raise KeyError(f"e_key_constants2:{e_key_constants2}.")
+    except Exception as e_constants2:
+        local_logger.error(f"e_constants2:{e_constants2}.")
+        raise e_constants2

static/index.html

@@ -0,0 +1,24 @@
+<main>
+    <section id="coords-gen">
+      <h2>Segment Geospatial: Instance segmentation within images based on Segment Anything</h2>
+      <p>
+        Model:
+        <a
+          href="https://github.com/opengeos/segment-geospatial/"
+          rel="noreferrer"
+          target="_blank"
+          >opengeos/segment-geospatial
+        </a>
+      </p>
+      <form class="coords-gen-form">
+        <label for="coords-gen-input">Text prompt</label>
+        <input
+          id="coords-gen-input"
+          type="coords"
+          value=""
+        />
+        <button id="coords-gen-submit">Submit</button>
+        <p class="coords-gen-output"></p>
+      </form>
+    </section>
+  </main>

static/script.js

@@ -0,0 +1,17 @@
+const coordsGenForm = document.querySelector(".coords-gen-form");
+
+const segmentCoords = async (coords) => {
+  const inferResponse = await fetch(`infer_samgeo?input=${coords}`);
+  const inferJson = await inferResponse.json();
+
+  return inferJson.output;
+};
+
+coordsGenForm.addEventListener("submit", async (event) => {
+  event.preventDefault();
+
+  const coordsGenInput = document.getElementById("coords-gen-input");
+  const coordsGenParagraph = document.querySelector(".coords-gen-output");
+
+  coordsGenParagraph.coordsContent = await segmentCoords(coordsGenInput.value);
+});