feat : Add Get parcel tool

.gitignore

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

api_sources/__init__.py

@@ -0,0 +1 @@
+ 

api_sources/base.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+
+class BaseAPISource(ABC):
+    """Classe de base abstraite pour toutes les sources d'API externes."""
+    
+    def __init__(self, base_url: str, timeout: int = 30):
+        self.base_url = base_url.rstrip('/')
+        self.timeout = timeout
+    
+    @abstractmethod
+    async def get_parcel_from_lat_lon(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """
+        Récupère les informations de parcelle à partir des coordonnées GPS.
+        
+        Args:
+            latitude: Latitude en degrés décimaux
+            longitude: Longitude en degrés décimaux
+            
+        Returns:
+            Dict contenant les données de la parcelle
+        """
+        pass
+    
+    def _build_url(self, endpoint: str) -> str:
+        """Construit l'URL complète à partir du base_url et de l'endpoint."""
+        return f"{self.base_url}/{endpoint.lstrip('/')}" 

api_sources/config.py

@@ -0,0 +1,13 @@
+"""Configuration des API externes."""
+
+API_CONFIGS = {
+    "lexicon": {
+        "base_url": "https://lexicon.osfarm.org",
+        "timeout": 30
+    },
+    # Exemple pour futures API sources
+    # "autre_api": {
+    #     "base_url": "https://exemple.com",
+    #     "timeout": 45
+    # }
+} 

api_sources/example_new_source.py

@@ -0,0 +1,51 @@
+"""
+EXEMPLE : Comment ajouter une nouvelle source d'API
+
+Pour ajouter une nouvelle source d'API, suivez ces étapes :
+
+1. Créez une nouvelle classe qui hérite de BaseAPISource
+2. Implémentez la méthode get_parcel_from_lat_lon
+3. Ajoutez d'autres méthodes spécifiques si nécessaire
+4. Intégrez la nouvelle source dans app.py
+
+Exemple d'implémentation :
+"""
+
+import httpx
+from typing import Dict, Any
+from .base import BaseAPISource
+from .config import API_CONFIGS
+
+
+class ExempleAPI(BaseAPISource):
+    """Exemple d'implémentation d'une nouvelle source d'API."""
+    
+    def __init__(self):
+        config = API_CONFIGS.get("exemple_api", {
+            "base_url": "https://exemple.com",
+            "timeout": 30
+        })
+        super().__init__(
+            base_url=config["base_url"],
+            timeout=config["timeout"]
+        )
+    
+    async def get_parcel_from_lat_lon(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """Implémentation pour l'API exemple."""
+        url = self._build_url("/api/parcelle")
+        
+        params = {
+            "lat": latitude,
+            "lon": longitude
+        }
+        
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            response = await client.get(url, params=params)
+            response.raise_for_status()
+            return response.json()
+    
+    async def autre_methode_specifique(self, param: str) -> Dict[str, Any]:
+        """Exemple d'une méthode spécifique à cette API."""
+        url = self._build_url("/api/autre-endpoint")
+        # ... implémentation
+        pass 

api_sources/lexicon.py

@@ -0,0 +1,53 @@
+import httpx
+from typing import Dict, Any
+from .base import BaseAPISource
+from .config import API_CONFIGS
+
+
+class LexiconAPI(BaseAPISource):
+    """Implémentation de l'API Lexicon pour récupérer les données de parcelles."""
+    
+    def __init__(self):
+        config = API_CONFIGS["lexicon"]
+        super().__init__(
+            base_url=config["base_url"],
+            timeout=config["timeout"]
+        )
+    
+    async def get_parcel_from_lat_lon(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """
+        Récupère les informations de parcelle depuis l'API Lexicon.
+        
+        Args:
+            latitude: Latitude en degrés décimaux
+            longitude: Longitude en degrés décimaux
+            
+        Returns:
+            Dict contenant les données de la parcelle depuis Lexicon
+            
+        Raises:
+            httpx.HTTPStatusError: Si la requête échoue
+            httpx.RequestError: Si une erreur de connexion survient
+        """
+        url = self._build_url("/tools/parcel-identifier.json")
+        
+        params = {
+            "latitude": latitude,
+            "longitude": longitude
+        }
+        
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            try:
+                response = await client.get(url, params=params)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                raise Exception(f"Erreur HTTP {e.response.status_code}: {e.response.text}")
+            except httpx.RequestError as e:
+                raise Exception(f"Erreur de connexion à l'API Lexicon: {str(e)}")
+    
+    # Exemple : Vous pouvez ajouter d'autres méthodes spécifiques à Lexicon ici
+    # async def autre_methode_lexicon(self, param: str) -> Dict[str, Any]:
+    #     """Autre méthode spécifique à l'API Lexicon."""
+    #     url = self._build_url("/autre-endpoint")
+    #     # ... implémentation 

app.py

@@ -1,7 +1,42 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException, Query
+from typing import Dict, Any
+from api_sources.lexicon import LexiconAPI
 
-app = FastAPI()
+app = FastAPI(
+    title="Data API",
+    description="API pour récupérer des données de parcelles depuis différentes sources",
+    version="1.0.0"
+)
+
+# Instance de l'API Lexicon
+lexicon_api = LexiconAPI()
 
 @app.get("/")
 def greet_json():
     return {"Hello": "World!"}
+
+@app.get("/tools/parcel-identifier")
+async def get_parcel_identifier(
+    latitude: float = Query(..., description="Latitude en degrés décimaux"),
+    longitude: float = Query(..., description="Longitude en degrés décimaux")
+) -> Dict[str, Any]:
+    """
+    Récupère les informations d'identification de parcelle à partir des coordonnées GPS.
+    
+    Args:
+        latitude: Latitude en degrés décimaux
+        longitude: Longitude en degrés décimaux
+        
+    Returns:
+        Dict contenant les données de la parcelle
+    """
+    try:
+        # Appel de l'API Lexicon pour récupérer les données
+        parcel_data = await lexicon_api.get_parcel_from_lat_lon(latitude, longitude)
+        return parcel_data
+    
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erreur lors de la récupération des données de parcelle: {str(e)}"
+        )

requirements.txt

@@ -1,2 +1,4 @@
 fastapi
 uvicorn[standard]
+requests
+httpx