Merge branch 'feature/lint-format' into develop

Author: ewlarson

app/api/v1/admin.py

@@ -8,13 +8,13 @@
 from app.api.v1.utils import create_response, sanitize_for_json
 from app.services.admin_service import (
     AdminService,
-    CacheManagementService,
-    ReindexingService,
-    ResourceProcessingService,
     CacheManagementError,
+    CacheManagementService,
     ReindexingError,
+    ReindexingService,
+    ResourceNotFoundError,
     ResourceProcessingError,
-    ResourceNotFoundError
+    ResourceProcessingService,
 )
 
 logger = logging.getLogger(__name__)
@@ -31,12 +31,16 @@ def get_admin_service() -> AdminService:
     return AdminService(cache_management_service, reindexing_service, resource_processing_service)
 
 
+# Module-level singleton for dependency injection
+_admin_service_dependency = Depends(get_admin_service)
+
+
 @router.post("/cache/clear")
 async def clear_cache(
     cache_type: Optional[str] = Query(
         None, description="Type of cache to clear (search, item, suggest, all)"
     ),
-    service: AdminService = Depends(get_admin_service),
+    service: AdminService = _admin_service_dependency,
 ):
     """Clear specified cache or all cache if not specified."""
     try:
@@ -53,26 +57,30 @@ async def clear_cache(
 @router.post("/reindex")
 async def reindex(
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: AdminService = Depends(get_admin_service),
+    service: AdminService = _admin_service_dependency,
 ):
     """Trigger reindexing of all items in Elasticsearch."""
     try:
         result = await service.reindex_resources()
         return create_response(result, callback)
     except ReindexingError as e:
         logger.error(f"Reindexing error: {str(e)}")
-        raise HTTPException(status_code=500, detail={"message": "Reindexing failed", "error": str(e)}) from e
+        raise HTTPException(
+            status_code=500, detail={"message": "Reindexing failed", "error": str(e)}
+        ) from e
     except Exception as e:
         logger.error(f"Unexpected error during reindexing: {str(e)}")
-        raise HTTPException(status_code=500, detail={"message": "Reindexing failed", "error": str(e)}) from e
+        raise HTTPException(
+            status_code=500, detail={"message": "Reindexing failed", "error": str(e)}
+        ) from e
 
 
 @router.post("/resources/{id}/summarize")
 async def summarize_resource(
     id: str,
     background_tasks: BackgroundTasks,
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: AdminService = Depends(get_admin_service),
+    service: AdminService = _admin_service_dependency,
 ):
     """
     Trigger the generation of a summary for a resource.
@@ -84,7 +92,7 @@ async def summarize_resource(
     """
     try:
         result = await service.summarize_resource(id)
-        
+
         # Sanitize the response data before returning
         sanitized_response = sanitize_for_json(result)
         return create_response(sanitized_response, callback)
@@ -104,7 +112,7 @@ async def identify_geo_entities(
     id: str,
     background_tasks: BackgroundTasks,
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: AdminService = Depends(get_admin_service),
+    service: AdminService = _admin_service_dependency,
 ):
     """
     Trigger the identification of geographic entities in a resource.
@@ -123,5 +131,8 @@ async def identify_geo_entities(
         logger.error(f"Resource processing error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e)) from e
     except Exception as e:
-        logger.error(f"Unexpected error triggering geographic entity identification for resource {id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e)) from e
+        logger.error(
+            f"Unexpected error triggering geographic entity identification "
+            f"for resource {id}: {str(e)}"
+        )
+        raise HTTPException(status_code=500, detail=str(e)) from e

app/api/v1/endpoint_modules/admin.py

@@ -8,13 +8,13 @@
 from app.api.v1.utils import create_response, sanitize_for_json
 from app.services.admin_service import (
     AdminService,
-    CacheManagementService,
-    ReindexingService,
-    ResourceProcessingService,
     CacheManagementError,
+    CacheManagementService,
     ReindexingError,
+    ReindexingService,
+    ResourceNotFoundError,
     ResourceProcessingError,
-    ResourceNotFoundError
+    ResourceProcessingService,
 )
 
 logger = logging.getLogger(__name__)
@@ -31,12 +31,16 @@ def get_admin_service() -> AdminService:
     return AdminService(cache_management_service, reindexing_service, resource_processing_service)
 
 
+# Module-level singleton for dependency injection
+_admin_service_dependency = Depends(get_admin_service)
+
+
 @router.post("/cache/clear")
 async def clear_cache(
     cache_type: Optional[str] = Query(
         None, description="Type of cache to clear (search, item, suggest, all)"
     ),
-    service: AdminService = Depends(get_admin_service),
+    service: AdminService = _admin_service_dependency,
 ):
     """Clear specified cache or all cache if not specified."""
     try:
@@ -53,26 +57,30 @@ async def clear_cache(
 @router.post("/reindex")
 async def reindex(
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: AdminService = Depends(get_admin_service),
+    service: AdminService = _admin_service_dependency,
 ):
     """Trigger reindexing of all items in Elasticsearch."""
     try:
         result = await service.reindex_resources()
         return create_response(result, callback)
     except ReindexingError as e:
         logger.error(f"Reindexing error: {str(e)}")
-        raise HTTPException(status_code=500, detail={"message": "Reindexing failed", "error": str(e)}) from e
+        raise HTTPException(
+            status_code=500, detail={"message": "Reindexing failed", "error": str(e)}
+        ) from e
     except Exception as e:
         logger.error(f"Unexpected error during reindexing: {str(e)}")
-        raise HTTPException(status_code=500, detail={"message": "Reindexing failed", "error": str(e)}) from e
+        raise HTTPException(
+            status_code=500, detail={"message": "Reindexing failed", "error": str(e)}
+        ) from e
 
 
 @router.post("/resources/{id}/summarize")
 async def summarize_resource(
     id: str,
     background_tasks: BackgroundTasks,
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: AdminService = Depends(get_admin_service),
+    service: AdminService = _admin_service_dependency,
 ):
     """
     Trigger the generation of a summary for a resource.
@@ -84,7 +92,7 @@ async def summarize_resource(
     """
     try:
         result = await service.summarize_resource(id)
-        
+
         # Sanitize the response data before returning
         sanitized_response = sanitize_for_json(result)
         return create_response(sanitized_response, callback)
@@ -104,7 +112,7 @@ async def identify_geo_entities(
     id: str,
     background_tasks: BackgroundTasks,
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: AdminService = Depends(get_admin_service),
+    service: AdminService = _admin_service_dependency,
 ):
     """
     Trigger the identification of geographic entities in a resource.
@@ -123,5 +131,8 @@ async def identify_geo_entities(
         logger.error(f"Resource processing error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e)) from e
     except Exception as e:
-        logger.error(f"Unexpected error triggering geographic entity identification for resource {id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e)) from e
+        logger.error(
+            f"Unexpected error triggering geographic entity identification "
+            f"for resource {id}: {str(e)}"
+        )
+        raise HTTPException(status_code=500, detail=str(e)) from e

app/api/v1/endpoint_modules/resources.py

@@ -304,41 +304,35 @@ async def get_resource_spatial_facets(
             query = select(resources.c.id, resources.c.dcat_bbox).where(resources.c.id == id)
             result = await session.execute(query)
             row = result.fetchone()
-            
+
             if not row:
                 # Return empty response for nonexistent resource
-                response_data = {
-                    "id": id,
-                    "type": "spatial_facets",
-                    "attributes": {}
-                }
+                response_data = {"id": id, "type": "spatial_facets", "attributes": {}}
                 request_url = str(request.url) if request else None
                 return create_jsonapi_response(response_data, request_url, callback)
-            
+
             # Convert to dict
             resource_dict = dict(row._mapping)
-            
+
             # Get spatial facets using the SpatialFacetService with the resource data
             service = SpatialFacetService(resource_dict)
             spatial_facets = await service.get_spatial_facets_with_wof_ids(session, debug=debug)
-            
+
             # Prepare attributes with dcat_bbox first, then spatial facets
             attributes = {}
             if resource_dict.get("dcat_bbox"):
                 attributes["dcat_bbox"] = resource_dict["dcat_bbox"]
             # Add spatial facets after dcat_bbox
             attributes.update(spatial_facets)
-            
+
             # Create JSON:API compliant response
-            response_data = {
-                "id": id,
-                "type": "spatial_facets",
-                "attributes": attributes
-            }
-            
+            response_data = {"id": id, "type": "spatial_facets", "attributes": attributes}
+
             request_url = str(request.url) if request else None
             return create_jsonapi_response(response_data, request_url, callback)
-        
+
     except Exception as e:
         logger.error(f"Error getting spatial facets for resource {id}: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Error retrieving spatial facets: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error retrieving spatial facets: {str(e)}"
+        ) from e

app/api/v1/endpoint_modules/shapefiles.py

@@ -7,12 +7,12 @@
 
 from app.api.v1.utils import create_response
 from app.services.shapefile_service import (
-    ShapefileService, 
-    DefaultDownloadService, 
+    DefaultDownloadService,
     DefaultDuckDBService,
     DuckDBConnectionError,
+    ShapefileDownloadError,
     ShapefileProcessingError,
-    ShapefileDownloadError
+    ShapefileService,
 )
 
 # Load environment variables
@@ -35,12 +35,16 @@ def get_shapefile_service() -> ShapefileService:
     return ShapefileService(download_service, duckdb_service)
 
 
+# Module-level singleton for dependency injection
+_shapefile_service_dependency = Depends(get_shapefile_service)
+
+
 @router.get("/shapefiles/query")
 async def query_endpoint(
     s3_uri: str = Query(..., description="S3 URI or URL of the shapefile"),
     sql: str = Query(..., description="SQL WHERE clause to filter the data"),
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: ShapefileService = Depends(get_shapefile_service),
+    service: ShapefileService = _shapefile_service_dependency,
 ):
     """Query a shapefile using SQL WHERE clauses."""
     try:
@@ -50,23 +54,23 @@ async def query_endpoint(
 
     except DuckDBConnectionError as e:
         logger.error(f"DuckDB connection error: {str(e)}")
-        raise HTTPException(status_code=503, detail=str(e))
+        raise HTTPException(status_code=503, detail=str(e)) from e
     except ShapefileDownloadError as e:
         logger.error(f"Shapefile download error: {str(e)}")
-        raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=400, detail=str(e)) from e
     except ShapefileProcessingError as e:
         logger.error(f"Shapefile processing error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e)) from e
     except Exception as e:
         logger.error(f"Unexpected error querying shapefile: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Error querying shapefile: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error querying shapefile: {str(e)}") from e
 
 
 @router.get("/shapefiles/schema")
 async def schema_endpoint(
     s3_uri: str = Query(..., description="S3 URI or URL of the shapefile"),
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: ShapefileService = Depends(get_shapefile_service),
+    service: ShapefileService = _shapefile_service_dependency,
 ):
     """Get the schema of a shapefile."""
     try:
@@ -76,24 +80,26 @@ async def schema_endpoint(
 
     except DuckDBConnectionError as e:
         logger.error(f"DuckDB connection error: {str(e)}")
-        raise HTTPException(status_code=503, detail=str(e))
+        raise HTTPException(status_code=503, detail=str(e)) from e
     except ShapefileDownloadError as e:
         logger.error(f"Shapefile download error: {str(e)}")
-        raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=400, detail=str(e)) from e
     except ShapefileProcessingError as e:
         logger.error(f"Shapefile processing error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e)) from e
     except Exception as e:
         logger.error(f"Unexpected error getting shapefile schema: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Error getting shapefile schema: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Error getting shapefile schema: {str(e)}"
+        ) from e
 
 
 @router.get("/shapefiles/preview")
 async def preview_endpoint(
     s3_uri: str = Query(..., description="S3 URI or URL of the shapefile"),
     limit: int = Query(10, description="Maximum number of rows to return", ge=1, le=1000),
     callback: Optional[str] = Query(None, description="JSONP callback name"),
-    service: ShapefileService = Depends(get_shapefile_service),
+    service: ShapefileService = _shapefile_service_dependency,
 ):
     """Preview a shapefile with a limited number of rows."""
     try:
@@ -103,13 +109,13 @@ async def preview_endpoint(
 
     except DuckDBConnectionError as e:
         logger.error(f"DuckDB connection error: {str(e)}")
-        raise HTTPException(status_code=503, detail=str(e))
+        raise HTTPException(status_code=503, detail=str(e)) from e
     except ShapefileDownloadError as e:
         logger.error(f"Shapefile download error: {str(e)}")
-        raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=400, detail=str(e)) from e
     except ShapefileProcessingError as e:
         logger.error(f"Shapefile processing error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e)) from e
     except Exception as e:
         logger.error(f"Unexpected error previewing shapefile: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"Error previewing shapefile: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error previewing shapefile: {str(e)}") from e

app/api/v1/utils.py

@@ -19,6 +19,8 @@ def sanitize_for_json(obj: Any) -> Any:
         return obj.isoformat()
     elif hasattr(obj, "__dict__"):  # Handle objects with __dict__
         return sanitize_for_json(obj.__dict__)
+    elif isinstance(obj, bool):  # Handle boolean objects (before float conversion)
+        return obj
     # Handle Decimal objects from database
     elif hasattr(obj, "__float__"):
         return float(obj)