feat: Implement nearby parcel retrieval feature with sampling and add parcel repository

.gitignore

@@ -1 +1,2 @@
-*/__pycache__/*
+**/__pycache__/** 
+

app.py

@@ -1,6 +1,8 @@
 from fastapi import FastAPI, HTTPException, Query
-from typing import Dict, Any
+from typing import Dict, Any, List
 from api_sources.lexicon import LexiconAPI
+from domain.repositories.parcel_repository import ParcelRepository
+from domain.use_cases.get_nearby_parcels_by_sampling import GetNearbyParcelsBySamplingUseCase
 
 app = FastAPI(
     title="Data API",
@@ -11,6 +13,9 @@ app = FastAPI(
 # Instance de l'API Lexicon
 lexicon_api = LexiconAPI()
 
+# Repository et use cases
+parcel_repository = ParcelRepository(lexicon_api)
+
 @app.get("/")
 def greet_json():
     return {"Hello": "World!"}
@@ -40,3 +45,42 @@ async def get_parcel_identifier(
             status_code=500, 
             detail=f"Erreur lors de la récupération des données de parcelle: {str(e)}"
         )
+
+@app.get("/tools/get_nearby_parcel")
+async def get_nearby_parcels(
+    latitude: float = Query(..., description="Latitude du point central en degrés décimaux"),
+    longitude: float = Query(..., description="Longitude du point central en degrés décimaux"),
+    radius_m: float = Query(200, description="Rayon de recherche en mètres", gt=0),
+    step_m: float = Query(100, description="Pas d'échantillonnage en mètres (densité des points)", gt=0)
+) -> List[Dict[str, Any]]:
+    """
+    Récupère les parcelles à proximité d'un point donné par échantillonnage.
+    
+    Args:
+        latitude: Latitude du point central en degrés décimaux
+        longitude: Longitude du point central en degrés décimaux  
+        radius_m: Rayon de recherche en mètres
+        step_m: Pas d'échantillonnage en mètres (plus petit = plus dense)
+        
+    Returns:
+        Liste des parcelles trouvées dans la zone
+    """
+    try:
+
+        # Création du use case avec les paramètres
+        get_nearby_parcels_use_case = GetNearbyParcelsBySamplingUseCase(
+            parcel_repository=parcel_repository,
+            buffer_radius_m=radius_m,
+            step_m=step_m
+        )
+        
+        # Exécution du use case
+        nearby_parcels = await get_nearby_parcels_use_case(latitude, longitude)
+        
+        return nearby_parcels
+    
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Erreur lors de la récupération des parcelles à proximité: {str(e)}"
+        )

domain/__init__.py

@@ -0,0 +1 @@
+ 

domain/repositories/__init__.py

@@ -0,0 +1 @@
+ 

domain/repositories/parcel_repository.py

@@ -0,0 +1,34 @@
+from typing import Dict, Any, Optional
+from api_sources.lexicon import LexiconAPI
+
+
+class ParcelRepository:
+    """Repository pour récupérer les données de parcelles depuis les API externes."""
+    
+    def __init__(self, lexicon_api: LexiconAPI):
+        self.lexicon_api = lexicon_api
+    
+    async def get_parcel_from_point(self, latitude: float, longitude: float) -> Optional[Dict[str, Any]]:
+        """
+        Récupère les informations de parcelle pour un point donné.
+        
+        Args:
+            latitude: Latitude en degrés décimaux
+            longitude: Longitude en degrés décimaux
+            
+        Returns:
+            Dict contenant les données de la parcelle ou None si aucune parcelle trouvée
+        """
+        try:
+            parcel_data = await self.lexicon_api.get_parcel_from_lat_lon(latitude, longitude)
+            
+            # Si l'API ne retourne pas de données de parcelle, on retourne None
+            if not parcel_data or not parcel_data.get('@id'):
+                return None
+                
+            return parcel_data
+            
+        except Exception as e:
+            # Log de l'erreur mais on continue avec les autres points
+            print(f"Erreur lors de la récupération de la parcelle en ({latitude}, {longitude}): {e}")
+            return None 

domain/use_cases/__init__.py

@@ -0,0 +1 @@
+ 

domain/use_cases/get_nearby_parcels_by_sampling.py

@@ -0,0 +1,61 @@
+from shapely.geometry import Point
+from shapely.ops import transform
+from pyproj import Transformer
+from typing import List, Set
+import math
+import asyncio
+
+
+class GetNearbyParcelsBySamplingUseCase:
+    def __init__(self, parcel_repository, buffer_radius_m: float, step_m: float = 100):
+        self.repo = parcel_repository
+        self.radius = buffer_radius_m
+        self.step = step_m  # espacement des points (densité)
+        self.to_projected = Transformer.from_crs("EPSG:4326", "EPSG:3857", always_xy=True).transform
+        self.to_geographic = Transformer.from_crs("EPSG:3857", "EPSG:4326", always_xy=True).transform
+
+    async def __call__(self, lat: float, lon: float) -> List[dict]:
+        center = transform(self.to_projected, Point(lon, lat))
+
+        sampled_points = self._generate_sampling_points(center)
+
+        seen_ids: Set[str] = set()
+        nearby_parcels: List[dict] = []
+
+        # Traitement asynchrone en lot pour optimiser les performances
+        tasks = []
+        for pt in sampled_points:
+            lon_, lat_ = transform(self.to_geographic, pt).coords[0]
+            tasks.append(self.repo.get_parcel_from_point(lat_, lon_))
+        
+        print(f"len(tasks): {len(tasks)}")
+
+        # Exécution parallèle des requêtes
+        parcel_results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        for parcel in parcel_results:
+            if isinstance(parcel, Exception):
+                continue  # Ignorer les erreurs et continuer
+                
+            if parcel:
+                parcel_id = parcel.get("cadastre", {}).get("id", {}).get("value")
+                if parcel_id not in seen_ids:
+                    nearby_parcels.append(parcel)
+                    seen_ids.add(parcel_id)
+
+        return nearby_parcels
+
+    def _generate_sampling_points(self, center: Point) -> List[Point]:
+        points = []
+        step = self.step
+        radius = self.radius
+
+        min_x, min_y = center.x - radius, center.y - radius
+        max_x, max_y = center.x + radius, center.y + radius
+
+        for x in range(int(min_x), int(max_x), int(step)):
+            for y in range(int(min_y), int(max_y), int(step)):
+                pt = Point(x, y)
+                if pt.distance(center) <= radius:
+                    points.append(pt)
+        return points

requirements.txt

@@ -2,3 +2,7 @@ fastapi
 uvicorn[standard]
 requests
 httpx
+
+# Géométrie et traitement spatial
+shapely>=2.0.0
+pyproj>=3.6.0