81 lines
No EOL
3.9 KiB
Python
81 lines
No EOL
3.9 KiB
Python
import httpx
|
|
import logging
|
|
from typing import List, Dict, Any, Optional
|
|
|
|
from core.config import settings
|
|
from services.oauth_service import OAuthService # Assurez-vous que ce service existe
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class RomeoService:
|
|
def __init__(self):
|
|
self.base_url = settings.FRANCE_TRAVAIL_ROMEO_API_URL # URL de base de l'API Romeo
|
|
self.scope = "api_romeov2" # Scope spécifique pour Romeo
|
|
self.oauth_service = OAuthService(settings.FRANCE_TRAVAIL_OAUTH_URL, settings.FRANCE_TRAVAIL_CLIENT_ID, settings.FRANCE_TRAVAIL_CLIENT_SECRET)
|
|
self.client = httpx.AsyncClient()
|
|
logger.info(f"RomeoService initialized with base_url: {self.base_url}")
|
|
|
|
async def _get_access_token(self) -> str:
|
|
"""Récupère le token d'accès spécifique à l'API Romeo."""
|
|
try:
|
|
token_response = await self.oauth_service.get_access_token(self.scope)
|
|
return token_response.access_token
|
|
except Exception as e:
|
|
logger.error(f"Erreur lors de la récupération du token d'accès pour Romeo: {e}")
|
|
raise RuntimeError(f"Impossible de récupérer le token d'accès pour Romeo: {e}")
|
|
|
|
async def _call_api(self, endpoint: str, text: str) -> Optional[Dict[str, Any]]:
|
|
"""
|
|
Appelle un endpoint de l'API Romeo avec le texte donné.
|
|
Gère l'authentification et les erreurs de base.
|
|
"""
|
|
token = await self._get_access_token()
|
|
headers = {
|
|
"Authorization": f"Bearer {token}",
|
|
"Content-Type": "application/json; charset=utf-8"
|
|
}
|
|
# Les APIs Romeo attendent le texte dans un champ 'texte' de l'objet JSON
|
|
data = {"texte": text}
|
|
|
|
url = f"{self.base_url}{endpoint}"
|
|
logger.info(f"Calling Romeo API: {url} with text length {len(text)}")
|
|
|
|
try:
|
|
response = await self.client.post(url, headers=headers, json=data, timeout=30.0)
|
|
response.raise_for_status() # Lève une exception pour les codes d'erreur HTTP (4xx ou 5xx)
|
|
return response.json()
|
|
except httpx.HTTPStatusError as e:
|
|
logger.error(f"Erreur HTTP lors de l'appel à Romeo {endpoint}: {e.response.status_code} - {e.response.text}")
|
|
raise RuntimeError(f"Erreur de l'API Romeo: {e.response.text}")
|
|
except httpx.RequestError as e:
|
|
logger.error(f"Erreur réseau ou de requête lors de l'appel à Romeo {endpoint}: {e}")
|
|
raise RuntimeError(f"Erreur de communication avec l'API Romeo: {e}")
|
|
except Exception as e:
|
|
logger.error(f"Une erreur inattendue est survenue lors de l'appel à Romeo {endpoint}: {e}")
|
|
raise RuntimeError(f"Erreur inattendue avec l'API Romeo: {e}")
|
|
|
|
async def predict_metiers(self, text: str) -> List[Dict[str, Any]]:
|
|
"""
|
|
Prédit les métiers ROME à partir d'un texte donné.
|
|
Retourne une liste de dictionnaires avec les détails des prédictions métiers.
|
|
"""
|
|
if not text:
|
|
return [] # Retourne une liste vide si le texte est vide
|
|
response_data = await self._call_api("/predictionMetiers", text)
|
|
# Romeo renvoie souvent une liste directe de prédictions si successful
|
|
return response_data if response_data is not None else []
|
|
|
|
|
|
async def predict_competences(self, text: str) -> List[Dict[str, Any]]:
|
|
"""
|
|
Prédit les compétences ROME à partir d'un texte donné.
|
|
Retourne une liste de dictionnaires avec les détails des prédictions de compétences.
|
|
"""
|
|
if not text:
|
|
return [] # Retourne une liste vide si le texte est vide
|
|
response_data = await self._call_api("/predictionCompetences", text)
|
|
# Romeo renvoie souvent une liste directe de prédictions si successful
|
|
return response_data if response_data is not None else []
|
|
|
|
# Instanciation unique du service Romeo
|
|
romeo_service = RomeoService() |