re

app.py

@@ -1,200 +1,431 @@
-# import os
-# import mlflow
-# import pandas as pd
-# from fastapi import FastAPI, HTTPException
-# from pydantic import BaseModel
-# import uvicorn
-# from dotenv import load_dotenv
+# # import os
+# # import mlflow
+# # import pandas as pd
+# # from fastapi import FastAPI, HTTPException
+# # from pydantic import BaseModel
+# # import uvicorn
+# # from dotenv import load_dotenv
+
+
+# # # --------------------------
+# # # 📘 FastAPI Metadata
+# # # --------------------------
+# # description = """
+# # # 🚗 Getaround API Documentation
+
+# # Bienvenue sur l'API Getaround ! Cette application permet d’analyser les retards de retour de véhicules et d’optimiser la tarification via Machine Learning.
+
+# # ## 🔗 Dashboard interactif
+# # 👉 [Dashboard Streamlit](https://flodussart-getaround-streamlit.hf.space)
+
+# # ## 🤖 Endpoint ML : `/predict`
+# # - Entrée : liste de caractéristiques numériques
+# # - Sortie : prédiction du prix
+
+# # Exemple :
+# # ```json
+# # {
+# #   "input": [[7.0, 0.27, 0.36, 20.7, 0.045, 45.0, 170.0, 1.001, 3.0, 0.45, 8.8]]
+# # }
+# # """
+# # tags_metadata = [
+# # {
+# # "name": "Machine Learning",
+# # "description": "Prédiction du prix de location via MLflow"
+# # }
+# # ]
 
+# # load_dotenv()
 
-# # --------------------------
-# # 📘 FastAPI Metadata
-# # --------------------------
-# description = """
-# # 🚗 Getaround API Documentation
+# # # Charger modèle MLflow
+# # mlflow.set_tracking_uri(os.getenv("APP_URI"))
+# # model = mlflow.pyfunc.load_model("models:/getaround-project-v4/1")
 
-# Bienvenue sur l'API Getaround ! Cette application permet d’analyser les retards de retour de véhicules et d’optimiser la tarification via Machine Learning.
+# # app = FastAPI(
+# #     title="🚗 Getaround Pricing API",
+# #     description="API de prédiction du prix de location — modèle ML",
+# #     version="1.0",
+# #     docs_url="/docs"
+# # )
 
-# ## 🔗 Dashboard interactif
-# 👉 [Dashboard Streamlit](https://flodussart-getaround-streamlit.hf.space)
+# # class PredictionInput(BaseModel):
+# #     input: list[list[float]]
 
-# ## 🤖 Endpoint ML : `/predict`
-# - Entrée : liste de caractéristiques numériques
-# - Sortie : prédiction du prix
+# # @app.post("/predict")
+# # def predict(payload: PredictionInput):
+# #     try:
+# #         df = pd.DataFrame(payload.input, columns=[
+# #             'model_key', 'mileage', 'engine_power', 'fuel', 'paint_color', 'car_type',
+# #             'private_parking_available', 'has_gps', 'has_air_conditioning',
+# #             'automatic_car', 'has_getaround_connect', 'has_speed_regulator', 'winter_tires'
+# #         ])
+# #         prediction = model.predict(df)
+# #         return {"prediction": prediction.tolist()}
+# #     except Exception as e:
+# #         raise HTTPException(status_code=500, detail=f"Erreur lors de la prédiction : {e}")
 
-# Exemple :
-# ```json
-# {
-#   "input": [[7.0, 0.27, 0.36, 20.7, 0.045, 45.0, 170.0, 1.001, 3.0, 0.45, 8.8]]
-# }
-# """
-# tags_metadata = [
-# {
-# "name": "Machine Learning",
-# "description": "Prédiction du prix de location via MLflow"
-# }
-# ]
 
-# load_dotenv()
+# # if __name__ == "__main__":
+# #     uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", 8080)))
+# # # app = FastAPI(
+# # # title="Getaround API",
+# # # description=description,
+# # # version="1.0",
+# # # contact={
+# # # "name": "Floriane Dussart",
+# # # "email": "floriane.dussart@gmail.com",
+# # # },
+# # # openapi_tags=tags_metadata
+# # # )
+
+
+# # # # === Charger les variables d'environnement ===
+# # # load_dotenv()
+
+# # # # === Définir le port imposé par Hugging Face ===
+# # # PORT = int(os.getenv("PORT", 8080))
+
+# # # # === Configurer le serveur MLflow ===
+# # # mlflow.set_tracking_uri(os.getenv("APP_URI") or "https://flodussart-getaroundproject.hf.space")
+
+# # # # === Charger le modèle MLflow ===
+# # # try:
+# # #     model = mlflow.pyfunc.load_model("models:/getaround-project-v4/1")
+# # # except Exception as e:
+# # #     raise RuntimeError(f"❌ Erreur de chargement du modèle MLflow : {e}")
+
+# # # # === Création de l'application FastAPI ===
+# # # app = FastAPI(
+# # #     title="🚗 Getaround Price API",
+# # #     description="Prédiction du prix journalier de location de voiture",
+# # #     version="1.0",
+# # #     docs_url="/docs",
+# # #     redoc_url="/redoc"
+# # # )
+
+# # # # === Schéma d’entrée utilisateur ===
+# # # class PredictionInput(BaseModel):
+# # #     model_key: str
+# # #     mileage: float
+# # #     engine_power: float
+# # #     fuel: str
+# # #     paint_color: str
+# # #     car_type: str
+# # #     private_parking_available: bool
+# # #     has_gps: bool
+# # #     has_air_conditioning: bool
+# # #     automatic_car: bool
+# # #     has_getaround_connect: bool
+# # #     has_speed_regulator: bool
+# # #     winter_tires: bool
+
+# # #     model_config = {"protected_namespaces": ()}
+
+# # #     @field_validator("paint_color")
+# # #     @classmethod
+# # #     def validate_paint_color(cls, v):
+# # #         allowed = ['black', 'grey', 'white', 'green', 'red', 'silver', 'blue', 'beige', 'brown', 'other']
+# # #         return v if v in allowed else "other"
+
+# # #     @field_validator("fuel")
+# # #     @classmethod
+# # #     def validate_fuel(cls, v):
+# # #         allowed = ['diesel', 'petrol', 'other']
+# # #         return v if v in allowed else "other"
+
+# # #     @field_validator("model_key")
+# # #     @classmethod
+# # #     def validate_model_key(cls, v):
+# # #         allowed = ['Citroën','Peugeot','PGO','Renault','Audi','BMW','Mercedes','Opel',
+# # #                    'Volkswagen','Ferrari','Mitsubishi','Nissan','SEAT','Maserati',
+# # #                    'Subaru','Toyota','Other']
+# # #         return v if v in allowed else "Other"
+
+# # #     @field_validator("car_type")
+# # #     @classmethod
+# # #     def validate_car_type(cls, v):
+# # #         allowed = ['convertible','coupe','estate','hatchback','sedan','subcompact','suv','van']
+# # #         return v if v in allowed else "other"
+
+# # # # === Page d’accueil ===
+# # # @app.get("/")
+# # # def welcome():
+# # #     return {"message": "Bienvenue sur l’API Getaround 🚗 — utilisez /predict pour estimer un prix."}
+
+# # # # === Endpoint de prédiction ===
+# # # @app.post("/predict")
+# # # def predict(input_data: PredictionInput):
+# # #     try:
+# # #         df = pd.DataFrame([input_data.dict()])
+# # #         prediction = model.predict(df)
+# # #         return {
+# # #             "prediction": round(float(prediction[0]), 2),
+# # #             "input": input_data.dict()
+# # #         }
+# # #     except Exception as e:
+# # #         raise HTTPException(status_code=500, detail=f"Erreur interne : {e}")
+
+# # # # === Optionnel : Exécution locale (inutile sur HF, mais pratique pour debug) ===
+# # # if __name__ == "__main__":
+# # #     uvicorn.run("app:app", host="0.0.0.0", port=PORT)
 
-# # Charger modèle MLflow
-# mlflow.set_tracking_uri(os.getenv("APP_URI"))
-# model = mlflow.pyfunc.load_model("models:/getaround-project-v4/1")
+# import os
+# import json
+# from pathlib import Path
+# from typing import Optional, List
 
+# import pandas as pd
+# from fastapi import FastAPI, HTTPException
+# from pydantic import BaseModel, Field
+# import uvicorn
+# import mlflow.pyfunc
+
+
+# # =======================
+# # Config
+# # =======================
+# PORT = int(os.getenv("PORT", 8080))
+# LOCAL_MODEL_PATH = os.getenv("MODEL_PATH", "model_bundle/model")
+
+
+# # =======================
+# # Helpers
+# # =======================
+# def load_features_from_artifacts(model_dir: str) -> List[str]:
+#     """
+#     Essaie de lire artifacts/features_used.json (déposé lors du training).
+#     Si absent, fallback vers une liste cohérente avec le meilleur modèle signalé.
+#     """
+#     fp = Path(model_dir) / "artifacts" / "features_used.json"
+#     if fp.exists():
+#         data = json.loads(fp.read_text())
+#         return list(data.get("numeric", [])) + \
+#                list(data.get("categorical", [])) + \
+#                list(data.get("boolean", []))
+
+#     # Fallback (conforme à ton features_used.json partagé)
+#     return [
+#         # numeric
+#         "mileage", "engine_power",
+#         # categorical
+#         "model_key", "fuel_grouped", "paint_color", "car_type_grouped",
+#         # boolean
+#         "private_parking_available", "has_gps", "has_air_conditioning",
+#         "automatic_car", "has_getaround_connect", "has_speed_regulator", "winter_tires",
+#     ]
+
+
+# # =======================
+# # App + model loading
+# # =======================
 # app = FastAPI(
 #     title="🚗 Getaround Pricing API",
-#     description="API de prédiction du prix de location — modèle ML",
+#     description=(
+#         "Prédiction du prix journalier de location.\n\n"
+#         "• Dashboard : https://flodussart-getaround-streamlit.hf.space\n"
+#         "• Endpoint ML : POST /predict — body: {\"rows\": [...] } (recommandé) "
+#         "ou {\"input\": [[...], ...]} (ordre strict des features).\n"
+#     ),
 #     version="1.0",
-#     docs_url="/docs"
+#     docs_url="/docs",
+#     redoc_url="/redoc",
 # )
 
-# class PredictionInput(BaseModel):
-#     input: list[list[float]]
+# try:
+#     model = mlflow.pyfunc.load_model(LOCAL_MODEL_PATH)
+# except Exception as e:
+#     raise RuntimeError(f"❌ Impossible de charger le modèle local '{LOCAL_MODEL_PATH}': {e}")
 
-# @app.post("/predict")
-# def predict(payload: PredictionInput):
-#     try:
-#         df = pd.DataFrame(payload.input, columns=[
-#             'model_key', 'mileage', 'engine_power', 'fuel', 'paint_color', 'car_type',
-#             'private_parking_available', 'has_gps', 'has_air_conditioning',
-#             'automatic_car', 'has_getaround_connect', 'has_speed_regulator', 'winter_tires'
-#         ])
-#         prediction = model.predict(df)
-#         return {"prediction": prediction.tolist()}
-#     except Exception as e:
-#         raise HTTPException(status_code=500, detail=f"Erreur lors de la prédiction : {e}")
+# FEATURES: List[str] = load_features_from_artifacts(LOCAL_MODEL_PATH)
 
 
-# if __name__ == "__main__":
-#     uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", 8080)))
-# # app = FastAPI(
-# # title="Getaround API",
-# # description=description,
-# # version="1.0",
-# # contact={
-# # "name": "Floriane Dussart",
-# # "email": "floriane.dussart@gmail.com",
-# # },
-# # openapi_tags=tags_metadata
-# # )
+# # =======================
+# # Schemas (typés)
+# # =======================
 
+# from pydantic import BaseModel, validator
+# from unidecode import unidecode
 
-# # # === Charger les variables d'environnement ===
-# # load_dotenv()
+# ALLOWED_FUEL = {"diesel", "petrol", "other"}
+# ALLOWED_PAINT = {"black", "grey", "blue", "white", "brown", "silver", "red", "beige", "green", "orange"}
+# ALLOWED_CARTYPE = {"estate", "sedan", "suv", "hatchback", "other"}
 
-# # # === Définir le port imposé par Hugging Face ===
-# # PORT = int(os.getenv("PORT", 8080))
+# # mets ici les modèles fréquents ; sinon ça tombera sur "other"
+# KNOWN_MODELS = {
+#     "citroen","renault","bmw","peugeot","audi","nissan","mitsubishi","mercedes",
+#     "volkswagen","toyota","seat","subaru","pgo","opel","ferrari","maserati",
+#     "suzuki","ford","porsche","alfa romeo","kia motors","fiat","lamborghini",
+#     "lexus","honda","mazda","yamaha"
+# }
 
-# # # === Configurer le serveur MLflow ===
-# # mlflow.set_tracking_uri(os.getenv("APP_URI") or "https://flodussart-getaroundproject.hf.space")
+# STRICT = False  # True pour rejeter les valeurs inconnues (400)
+
+# def _norm(x: str) -> str:
+#     return unidecode(str(x)).strip().lower()  # "Citroën" -> "citroen"
+
+# class PredictRow(BaseModel):
+#     mileage: float
+#     engine_power: float
+#     model_key: str
+#     fuel_grouped: str
+#     paint_color: str
+#     car_type_grouped: str
+#     private_parking_available: bool
+#     has_gps: bool
+#     has_air_conditioning: bool
+#     automatic_car: bool
+#     has_getaround_connect: bool
+#     has_speed_regulator: bool
+#     winter_tires: bool
+
+#     @validator("model_key", "fuel_grouped", "paint_color", "car_type_grouped", pre=True)
+#     def _normalize(cls, v): return _norm(v)
+
+#     @validator("fuel_grouped")
+#     def _fuel(cls, v):
+#         if v in ALLOWED_FUEL: return v
+#         if STRICT: raise ValueError(f"fuel_grouped in {sorted(ALLOWED_FUEL)}")
+#         return "other"
+
+#     @validator("paint_color")
+#     def _paint(cls, v):
+#         if v in ALLOWED_PAINT: return v
+#         if STRICT: raise ValueError(f"paint_color in {sorted(ALLOWED_PAINT)}")
+#         return "other"
+
+#     @validator("car_type_grouped")
+#     def _ctype(cls, v):
+#         if v in ALLOWED_CARTYPE: return v
+#         if STRICT: raise ValueError(f"car_type_grouped in {sorted(ALLOWED_CARTYPE)}")
+#         return "other"
+
+#     @validator("model_key")
+#     def _model(cls, v):
+#         if v in KNOWN_MODELS: return v
+#         return "other" if not STRICT else (_ for _ in ()).throw(ValueError("unknown model_key"))
+
+# class PredictRow(BaseModel):
+#     # Types explicites = /docs plus fiable ✨
+#     mileage: float
+#     engine_power: float
+#     model_key: str
+#     fuel_grouped: str
+#     paint_color: str
+#     car_type_grouped: str
+#     private_parking_available: bool
+#     has_gps: bool
+#     has_air_conditioning: bool
+#     automatic_car: bool
+#     has_getaround_connect: bool
+#     has_speed_regulator: bool
+#     winter_tires: bool
+
+
+# class PredictPayload(BaseModel):
+#     # On accepte l’un OU l’autre format.
+#     rows: Optional[List[PredictRow]] = Field(
+#         default=None, description="Format recommandé : liste d'objets typés."
+#     )
+#     input: Optional[List[List[float]]] = Field(
+#         default=None,
+#         description=f"Format legacy : matrice. Chaque ligne doit suivre l'ordre strict: {FEATURES}",
+#     )
+
+
+# # =======================
+# # Routes
+# # =======================
+# @app.get("/")
+# def root():
+#     return {
+#         "message": "Bienvenue sur l’API Getaround 🚗 — utilisez POST /predict",
+#         "docs": "/docs",
+#         "dashboard": "https://flodussart-getaround-streamlit.hf.space",
+#         "model_path": LOCAL_MODEL_PATH,
+#         "features": FEATURES,
+#     }
+
+
+# @app.get("/healthz")
+# def healthz():
+#     return {"status": "ok", "features": FEATURES}
+
+
+# def build_df_from_payload(payload: PredictPayload) -> pd.DataFrame:
+#     """
+#     Construit le DataFrame d'entrée à partir du payload.
+#     Priorité au format 'rows' (typé). Sinon 'input' (ordre strict).
+#     """
+#     if payload.rows:
+#         df = pd.DataFrame([r.dict() for r in payload.rows])
+#         missing = [c for c in FEATURES if c not in df.columns]
+#         if missing:
+#             raise HTTPException(
+#                 status_code=400,
+#                 detail=f"Colonnes manquantes: {missing}. Attendu: {FEATURES}",
+#             )
+#         return df[FEATURES]
+
+#     if payload.input:
+#         n_feat = len(FEATURES)
+#         bad = [i for i, row in enumerate(payload.input) if len(row) != n_feat]
+#         if bad:
+#             raise HTTPException(
+#                 status_code=400,
+#                 detail=f"Lignes {bad} n'ont pas {n_feat} valeurs. Ordre attendu: {FEATURES}",
+#             )
+#         return pd.DataFrame(payload.input, columns=FEATURES)
+
+#     raise HTTPException(
+#         status_code=400,
+#         detail="Fournis soit 'rows': [{feature: value}], soit 'input': [[...]].",
+#     )
 
-# # # === Charger le modèle MLflow ===
-# # try:
-# #     model = mlflow.pyfunc.load_model("models:/getaround-project-v4/1")
-# # except Exception as e:
-# #     raise RuntimeError(f"❌ Erreur de chargement du modèle MLflow : {e}")
 
-# # # === Création de l'application FastAPI ===
-# # app = FastAPI(
-# #     title="🚗 Getaround Price API",
-# #     description="Prédiction du prix journalier de location de voiture",
-# #     version="1.0",
-# #     docs_url="/docs",
-# #     redoc_url="/redoc"
-# # )
+# @app.post("/predict")
+# def predict(payload: PredictPayload):
+#     try:
+#         df = build_df_from_payload(payload)
+#         y_hat = model.predict(df)
+#         preds = [float(x) for x in (y_hat.tolist() if hasattr(y_hat, "tolist") else y_hat)]
+#         return {"prediction": preds}
+#     except HTTPException:
+#         raise
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=f"Erreur lors de la prédiction : {e}")
 
-# # # === Schéma d’entrée utilisateur ===
-# # class PredictionInput(BaseModel):
-# #     model_key: str
-# #     mileage: float
-# #     engine_power: float
-# #     fuel: str
-# #     paint_color: str
-# #     car_type: str
-# #     private_parking_available: bool
-# #     has_gps: bool
-# #     has_air_conditioning: bool
-# #     automatic_car: bool
-# #     has_getaround_connect: bool
-# #     has_speed_regulator: bool
-# #     winter_tires: bool
-
-# #     model_config = {"protected_namespaces": ()}
-
-# #     @field_validator("paint_color")
-# #     @classmethod
-# #     def validate_paint_color(cls, v):
-# #         allowed = ['black', 'grey', 'white', 'green', 'red', 'silver', 'blue', 'beige', 'brown', 'other']
-# #         return v if v in allowed else "other"
-
-# #     @field_validator("fuel")
-# #     @classmethod
-# #     def validate_fuel(cls, v):
-# #         allowed = ['diesel', 'petrol', 'other']
-# #         return v if v in allowed else "other"
-
-# #     @field_validator("model_key")
-# #     @classmethod
-# #     def validate_model_key(cls, v):
-# #         allowed = ['Citroën','Peugeot','PGO','Renault','Audi','BMW','Mercedes','Opel',
-# #                    'Volkswagen','Ferrari','Mitsubishi','Nissan','SEAT','Maserati',
-# #                    'Subaru','Toyota','Other']
-# #         return v if v in allowed else "Other"
-
-# #     @field_validator("car_type")
-# #     @classmethod
-# #     def validate_car_type(cls, v):
-# #         allowed = ['convertible','coupe','estate','hatchback','sedan','subcompact','suv','van']
-# #         return v if v in allowed else "other"
-
-# # # === Page d’accueil ===
-# # @app.get("/")
-# # def welcome():
-# #     return {"message": "Bienvenue sur l’API Getaround 🚗 — utilisez /predict pour estimer un prix."}
-
-# # # === Endpoint de prédiction ===
-# # @app.post("/predict")
-# # def predict(input_data: PredictionInput):
-# #     try:
-# #         df = pd.DataFrame([input_data.dict()])
-# #         prediction = model.predict(df)
-# #         return {
-# #             "prediction": round(float(prediction[0]), 2),
-# #             "input": input_data.dict()
-# #         }
-# #     except Exception as e:
-# #         raise HTTPException(status_code=500, detail=f"Erreur interne : {e}")
 
-# # # === Optionnel : Exécution locale (inutile sur HF, mais pratique pour debug) ===
-# # if __name__ == "__main__":
-# #     uvicorn.run("app:app", host="0.0.0.0", port=PORT)
+# if __name__ == "__main__":
+#     uvicorn.run(app, host="0.0.0.0", port=4000)
 
 import os
 import json
 from pathlib import Path
-from typing import Optional, List
+from typing import Optional, Any
 
 import pandas as pd
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel, Field
-import uvicorn
 import mlflow.pyfunc
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field, field_validator
+from unidecode import unidecode
 
 
 # =======================
 # Config
 # =======================
-PORT = int(os.getenv("PORT", 8080))
+PORT = int(os.getenv("PORT", 7860))  # HF fournit $PORT; 7860 par défaut
 LOCAL_MODEL_PATH = os.getenv("MODEL_PATH", "model_bundle/model")
 
 
 # =======================
 # Helpers
 # =======================
-def load_features_from_artifacts(model_dir: str) -> List[str]:
+def load_features_from_artifacts(model_dir: str) -> list[str]:
     """
     Essaie de lire artifacts/features_used.json (déposé lors du training).
-    Si absent, fallback vers une liste cohérente avec le meilleur modèle signalé.
+    Fallback : colonnes cohérentes avec la version 'grouped' (alignée API).
     """
     fp = Path(model_dir) / "artifacts" / "features_used.json"
     if fp.exists():
@@ -203,12 +434,12 @@ def load_features_from_artifacts(model_dir: str) -> List[str]:
                list(data.get("categorical", [])) + \
                list(data.get("boolean", []))
 
-    # Fallback (conforme à ton features_used.json partagé)
+    # Fallback : 100% colonnes grouped pour rester cohérent.
     return [
         # numeric
         "mileage", "engine_power",
-        # categorical
-        "model_key", "fuel_grouped", "paint_color", "car_type_grouped",
+        # categorical (grouped/normalisées)
+        "model_key", "fuel_grouped", "paint_color", "car_type",
         # boolean
         "private_parking_available", "has_gps", "has_air_conditioning",
         "automatic_car", "has_getaround_connect", "has_speed_regulator", "winter_tires",
@@ -216,7 +447,7 @@ def load_features_from_artifacts(model_dir: str) -> List[str]:
 
 
 # =======================
-# App + model loading
+# App
 # =======================
 app = FastAPI(
     title="🚗 Getaround Pricing API",
@@ -231,24 +462,51 @@ app = FastAPI(
     redoc_url="/redoc",
 )
 
+# CORS (utile si l'app Streamlit appelle directement l'API depuis le navigateur)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],   # ou mets ton domaine exact si tu préfères
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Charger le modèle MLflow (depuis le bundle local)
 try:
     model = mlflow.pyfunc.load_model(LOCAL_MODEL_PATH)
 except Exception as e:
     raise RuntimeError(f"❌ Impossible de charger le modèle local '{LOCAL_MODEL_PATH}': {e}")
 
-FEATURES: List[str] = load_features_from_artifacts(LOCAL_MODEL_PATH)
+FEATURES: list[str] = load_features_from_artifacts(LOCAL_MODEL_PATH)
 
 
 # =======================
-# Schemas (typés)
+# Pydantic v2 Schemas (+ normalisation)
 # =======================
+ALLOWED_FUEL = {"diesel", "petrol", "other"}
+ALLOWED_PAINT = {"black", "grey", "blue", "white", "brown", "silver", "red", "beige", "green", "orange", "other"}
+ALLOWED_CARTYPE = {"estate", "sedan", "suv", "hatchback", "subcompact", "coupe", "convertible", "van", "other"}
+
+KNOWN_MODELS = {
+    "citroen","renault","bmw","peugeot","audi","nissan","mitsubishi","mercedes",
+    "volkswagen","toyota","seat","subaru","pgo","opel","ferrari","maserati",
+    "suzuki","ford","porsche","alfa romeo","kia motors","fiat","lamborghini",
+    "lexus","honda","mazda","yamaha","other",
+}
+
+STRICT = False  # True => rejette les valeurs inconnues (400)
+
+def _norm(x: Any) -> str:
+    return unidecode(str(x)).strip().lower()  # "Citroën" -> "citroen"
+
+
 class PredictRow(BaseModel):
-    # Types explicites = /docs plus fiable ✨
+    # colonnes alignées avec le training (version grouped)
     mileage: float
     engine_power: float
-    model_key: str
+    model_key_grouped: str
     fuel_grouped: str
-    paint_color: str
+    paint_color_grouped: str
     car_type_grouped: str
     private_parking_available: bool
     has_gps: bool
@@ -258,15 +516,60 @@ class PredictRow(BaseModel):
     has_speed_regulator: bool
     winter_tires: bool
 
+    # --- Normalisation en amont (before) ---
+    @field_validator("model_key_grouped", "fuel_grouped", "paint_color_grouped", "car_type_grouped", mode="before")
+    @classmethod
+    def _normalize(cls, v):
+        return _norm(v)
+
+    # --- Contrôles de domaine + fallback "other" ---
+    @field_validator("fuel_grouped")
+    @classmethod
+    def _fuel(cls, v: str):
+        if v in ALLOWED_FUEL: 
+            return v
+        if STRICT:
+            raise ValueError(f"fuel_grouped must be in {sorted(ALLOWED_FUEL)}")
+        return "other"
+
+    @field_validator("paint_color_grouped")
+    @classmethod
+    def _paint(cls, v: str):
+        if v in ALLOWED_PAINT:
+            return v
+        if STRICT:
+            raise ValueError(f"paint_color_grouped must be in {sorted(ALLOWED_PAINT)}")
+        return "other"
+
+    @field_validator("car_type_grouped")
+    @classmethod
+    def _ctype(cls, v: str):
+        if v in ALLOWED_CARTYPE:
+            return v
+        if STRICT:
+            raise ValueError(f"car_type_grouped must be in {sorted(ALLOWED_CARTYPE)}")
+        return "other"
+
+    @field_validator("model_key_grouped")
+    @classmethod
+    def _model(cls, v: str):
+        if v in KNOWN_MODELS:
+            return v
+        if STRICT:
+            raise ValueError("unknown model_key_grouped")
+        return "other"
+
 
 class PredictPayload(BaseModel):
-    # On accepte l’un OU l’autre format.
-    rows: Optional[List[PredictRow]] = Field(
-        default=None, description="Format recommandé : liste d'objets typés."
-    )
-    input: Optional[List[List[float]]] = Field(
+    """
+    On accepte l’un OU l’autre format :
+    - rows : recommandé (objets typés)
+    - input : legacy (matrice) — l'ordre doit suivre FEATURES.
+    """
+    rows: Optional[list[PredictRow]] = Field(default=None)
+    input: Optional[list[list[Any]]] = Field(
         default=None,
-        description=f"Format legacy : matrice. Chaque ligne doit suivre l'ordre strict: {FEATURES}",
+        description="Format legacy : matrice. Chaque ligne doit suivre l'ordre strict: {}".format(FEATURES),
     )
 
 
@@ -295,13 +598,15 @@ def build_df_from_payload(payload: PredictPayload) -> pd.DataFrame:
     Priorité au format 'rows' (typé). Sinon 'input' (ordre strict).
     """
     if payload.rows:
-        df = pd.DataFrame([r.dict() for r in payload.rows])
+        # Pydantic v2 -> .model_dump()
+        df = pd.DataFrame([r.model_dump() for r in payload.rows])
         missing = [c for c in FEATURES if c not in df.columns]
         if missing:
             raise HTTPException(
                 status_code=400,
                 detail=f"Colonnes manquantes: {missing}. Attendu: {FEATURES}",
             )
+        # Réordonne les colonnes exactement comme au training
         return df[FEATURES]
 
     if payload.input:
@@ -325,6 +630,7 @@ def predict(payload: PredictPayload):
     try:
         df = build_df_from_payload(payload)
         y_hat = model.predict(df)
+        # numpy array -> python floats
         preds = [float(x) for x in (y_hat.tolist() if hasattr(y_hat, "tolist") else y_hat)]
         return {"prediction": preds}
     except HTTPException:
@@ -334,4 +640,6 @@ def predict(payload: PredictPayload):
 
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=4000)
+    # Uvicorn direct (utile en local). Sur HF, le CMD du Dockerfile lancera ça.
+    uvicorn.run("app:app", host="0.0.0.0", port=PORT)
+

model_bundle/model/MLmodel

@@ -14,7 +14,7 @@ flavors:
     serialization_format: cloudpickle
     sklearn_version: 1.7.2
 mlflow_version: 2.9.2
-model_size_bytes: 1024217
-model_uuid: fbd87ce7587c4bc9af89a2cd1a641c46
-run_id: 31dc5fd4868d4e8b8eb76736b79b4f7f
-utc_time_created: '2025-10-26 10:52:57.335412'
+model_size_bytes: 1006815
+model_uuid: 514add3140a2447bb144ef25fdd35803
+run_id: c525ab61c63348f48171b68ee556b6b5
+utc_time_created: '2025-10-27 10:50:29.219164'

model_bundle/model/model.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:59019bf878ec9fe6b25dc236d357788aa483ba4ecd6873931dea9d49322db680
-size 1024217
+oid sha256:6a156e7ebf77ac9080867b389d6899fddad7e283984ab93fd8641eabc6cdbe73
+size 1006815

requirements.txt

@@ -1,12 +1,13 @@
-fastapi[standard]
-pydantic
+fastapi[standard]>=0.103
+pydantic>=2.4,<3
 pandas
 scikit-learn==1.7.2
 mlflow==2.9.2
 lightgbm==4.6.0
 uvicorn
 python-dotenv
-fsspec
+fspec
 s3fs
 boto3
-setuptools>=68,<72
+setuptools>=68,<72
+unidecode