Deploy to HuggingFace Spaces from main branch

.env.example

@@ -0,0 +1,188 @@
+# =============================================================================
+# FICHIER DE CONFIGURATION ENVIRONNEMENT - PROJECT5
+# =============================================================================
+# Copiez ce fichier vers .env et modifiez les valeurs selon vos besoins
+# ATTENTION: Ne commitez jamais le fichier .env (il contient des secrets)
+
+# =============================================================================
+# CONFIGURATION DE L'APPLICATION
+# =============================================================================
+APP_NAME=Project5 API
+VERSION=0.1.0
+ENVIRONMENT=development
+DEBUG=true
+
+# Host et port pour le serveur
+HOST=0.0.0.0
+PORT=8000
+
+# =============================================================================
+# SÉCURITÉ - CHANGEZ CES VALEURS EN PRODUCTION !
+# =============================================================================
+# Clé secrète pour JWT et sessions (génération: openssl rand -hex 32)
+SECRET_KEY=votre-cle-secrete-super-longue-et-complexe-changez-moi-en-production-123456789abcdef
+
+# Algorithme de hachage pour JWT
+ALGORITHM=HS256
+
+# Durée de validité des tokens (en minutes)
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+
+# Clé pour le refresh token (optionnel)
+REFRESH_TOKEN_EXPIRE_DAYS=7
+
+# =============================================================================
+# BASE DE DONNÉES - POSTGRESQL
+# =============================================================================
+# URL complète de la base de données PostgreSQL
+DATABASE_URL=postgresql://project5_user:project5_password@localhost:5432/project5_db
+
+# Paramètres séparés (utilisés par Docker Compose)
+POSTGRES_HOST=localhost
+POSTGRES_PORT=5432
+POSTGRES_DB=project5_db
+POSTGRES_USER=project5_user
+POSTGRES_PASSWORD=project5_password
+
+# Configuration SQLAlchemy
+SQLALCHEMY_ECHO=false
+SQLALCHEMY_POOL_SIZE=5
+SQLALCHEMY_MAX_OVERFLOW=10
+SQLALCHEMY_POOL_PRE_PING=true
+SQLALCHEMY_POOL_RECYCLE=300
+
+# =============================================================================
+# BASE DE DONNÉES DE TEST - SQLITE
+# =============================================================================
+# Utilisée pour les tests unitaires (plus rapide que PostgreSQL)
+TEST_DATABASE_URL=sqlite:///./test_project5.db
+
+# =============================================================================
+# LOGGING
+# =============================================================================
+LOG_LEVEL=INFO
+LOG_FORMAT=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+LOG_FILE=logs/project5.log
+LOG_MAX_SIZE=10MB
+LOG_BACKUP_COUNT=5
+
+# =============================================================================
+# CORS - Configuration des domaines autorisés
+# =============================================================================
+# Domaines autorisés pour les requêtes CORS (séparés par des virgules)
+ALLOWED_ORIGINS=http://localhost:3000,http://localhost:8080,http://127.0.0.1:3000
+ALLOWED_METHODS=GET,POST,PUT,DELETE,PATCH,OPTIONS
+ALLOWED_HEADERS=*
+
+# =============================================================================
+# REDIS - Cache et sessions (optionnel)
+# =============================================================================
+# REDIS_URL=redis://localhost:6379/0
+# REDIS_HOST=localhost
+# REDIS_PORT=6379
+# REDIS_DB=0
+# REDIS_PASSWORD=
+# REDIS_EXPIRE_TIME=3600
+
+# =============================================================================
+# EMAIL - Configuration SMTP (optionnel)
+# =============================================================================
+# SMTP_HOST=smtp.gmail.com
+# SMTP_PORT=587
+# SMTP_USER=votre.email@gmail.com
+# SMTP_PASSWORD=votre-mot-de-passe-app
+# SMTP_TLS=true
+# SMTP_FROM_EMAIL=noreply@project5.com
+# SMTP_FROM_NAME=Project5 API
+
+# =============================================================================
+# STOCKAGE DE FICHIERS (optionnel)
+# =============================================================================
+# Répertoire local pour les uploads
+# UPLOAD_DIRECTORY=uploads
+# MAX_FILE_SIZE=10MB
+# ALLOWED_FILE_EXTENSIONS=jpg,jpeg,png,gif,pdf,doc,docx
+
+# Configuration AWS S3 (optionnel)
+# AWS_ACCESS_KEY_ID=votre-access-key
+# AWS_SECRET_ACCESS_KEY=votre-secret-key
+# AWS_BUCKET_NAME=votre-bucket
+# AWS_REGION=eu-west-1
+
+# =============================================================================
+# MONITORING ET OBSERVABILITÉ (optionnel)
+# =============================================================================
+# Sentry pour le monitoring d'erreurs
+# SENTRY_DSN=https://votre-sentry-dsn@sentry.io/project-id
+
+# Prometheus metrics
+# ENABLE_METRICS=false
+# METRICS_PORT=9090
+
+# =============================================================================
+# RATE LIMITING (optionnel)
+# =============================================================================
+# RATE_LIMIT_REQUESTS=100
+# RATE_LIMIT_WINDOW=3600
+# RATE_LIMIT_STORAGE=memory
+
+# =============================================================================
+# CONFIGURATION DOCKER COMPOSE
+# =============================================================================
+# Variables utilisées par docker-compose.yml
+COMPOSE_PROJECT_NAME=project5
+COMPOSE_FILE=docker-compose.yml
+
+# Ports exposés
+API_PORT=8000
+DB_PORT=5432
+
+# =============================================================================
+# DÉVELOPPEMENT LOCAL
+# =============================================================================
+# Rechargement automatique en développement
+AUTO_RELOAD=true
+
+# Affichage détaillé des requêtes SQL
+SQL_DEBUG=false
+
+# Mode de développement pour FastAPI
+FASTAPI_DEBUG=true
+FASTAPI_RELOAD=true
+
+# =============================================================================
+# TESTS
+# =============================================================================
+# Configuration spécifique aux tests
+TESTING=false
+TEST_LOG_LEVEL=WARNING
+
+# Base de données de test séparée
+TEST_POSTGRES_DB=project5_test_db
+TEST_POSTGRES_USER=project5_test_user
+TEST_POSTGRES_PASSWORD=project5_test_password
+
+# =============================================================================
+# PRODUCTION - Variables critiques à définir
+# =============================================================================
+# En production, assurez-vous de définir:
+# - SECRET_KEY (généré de manière sécurisée)
+# - DATABASE_URL (avec les vrais credentials)
+# - ALLOWED_ORIGINS (domaines de production)
+# - ENVIRONMENT=production
+# - DEBUG=false
+# - LOG_LEVEL=WARNING ou ERROR
+
+# =============================================================================
+# NOTES D'UTILISATION
+# =============================================================================
+# 1. Copiez ce fichier: cp .env.example .env
+# 2. Modifiez les valeurs dans .env selon vos besoins
+# 3. Le fichier .env ne doit JAMAIS être commité dans Git
+# 4. Utilisez des valeurs différentes pour dev/test/production
+# 5. Générez des clés secrètes fortes pour la production
+# 
+# Génération de SECRET_KEY sécurisée:
+# python -c "import secrets; print(secrets.token_urlsafe(32))"
+# ou
+# openssl rand -base64 32

.flake8

@@ -0,0 +1,18 @@
+[flake8]
+max-line-length = 88
+extend-ignore = 
+    E203, 
+    W503,  
+    E402,  
+    E501  
+
+exclude = 
+    .git,
+    __pycache__,
+    .venv,
+    venv,
+    .jupyter,
+    .ipynb_checkpoints
+
+per-file-ignores =
+    *.ipynb:E402,E501

.gitattributes

@@ -0,0 +1,37 @@
+# Git LFS configuration for large files (e.g., models, datasets)
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+model/model.pkl filter=lfs diff=lfs merge=lfs -text

.github/workflows/cicd.yml

@@ -0,0 +1,197 @@
+name: Project5 CI/CD
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: 'Environnement'
+        type: choice
+        options: ['dev', 'production']
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+      with:
+        version: latest
+        virtualenvs-create: true
+        virtualenvs-in-project: true
+        installer-parallel: true
+
+    - name: Load cached venv
+      id: cached-poetry-dependencies
+      uses: actions/cache@v3
+      with:
+        path: .venv
+        key: venv-${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('**/poetry.lock') }}
+
+    - name: Install dependencies
+      if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+      run: poetry install --no-interaction --no-root
+
+    - name: Install project
+      run: poetry install --no-interaction
+
+    - name: Run tests with pytest
+      run: |
+        DATABASE_URL="sqlite:///:memory:" poetry run pytest tests/ --cov=src/project5 --cov-report=xml --cov-report=html --cov-report=term-missing --cov-fail-under=80 -v 
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v3
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        file: ./coverage.xml
+        flags: unittests
+        name: codecov-umbrella
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.11"
+
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+      with:
+        version: latest
+        virtualenvs-create: true
+        virtualenvs-in-project: true
+
+    - name: Install dependencies
+      run: poetry install --no-interaction
+
+    - name: Run Black
+      run: poetry run black --check ./src
+
+    - name: Run isort
+      run: poetry run isort --check-only .
+
+    - name: Run flake8
+      run: poetry run flake8 ./src
+
+    # - name: Run mypy
+    #   run: poetry run mypy ./src
+
+  security:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.11"
+
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+
+    - name: Install dependencies
+      run: poetry install --no-interaction
+
+    - name: Run Bandit security linter
+      run: poetry run bandit -r ./src -f json
+
+    - name: Run Safety check
+      run: poetry run safety check --output json
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: [test, lint, security]
+    if: github.ref == 'refs/heads/main' &&  github.event.inputs.environment == 'production'
+    environment: production  # Nécessite approbation dans Settings > Environments
+    
+    steps:
+    - name: Setup Git LFS
+      run: |
+        git lfs install
+
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        lfs: true
+
+    - name: Pull LFS files
+      run: git lfs pull
+
+    - name: Push to Hugging Face Space
+      env:
+        HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        HF_SPACE_NAME: ${{ secrets.HF_SPACE_NAME }}
+      run: |
+        echo "Configuration Git pour HF"
+        git config --global user.email "action@github.com"
+        git config --global user.name "GitHub Action"
+        
+        echo "Ajouter remote HF si pas déjà présent"
+        if ! git remote | grep -q huggingface; then
+          git remote add huggingface https://huggingface.co/spaces/$HF_SPACE_NAME
+        fi
+        
+        echo "Créer une branche orpheline pour éviter l'historique"
+        git checkout --orphan deploy-hf
+
+        echo "Configuration Git LFS pour HuggingFace"
+        git lfs track "*.pkl"
+
+        echo "Copier le Dockerfile pour HF (renommer)"
+        cp Dockerfile_app Dockerfile
+        git rm -f README.md
+        echo "Créer README.md pour HF Spaces si absent"
+        if [ ! -f README.md ]; then
+          cat > README.md << EOF
+        ---
+        title: Building Energy Prediction API
+        emoji: 🏢
+        colorFrom: blue
+        colorTo: green
+        sdk: docker
+        app_port: 7860
+        pinned: false
+        license: mit
+        ---
+
+        # Building Energy Prediction API
+
+        API FastAPI pour la prédiction de consommation énergétique des bâtiments.
+
+        ## Fonctionnalités
+        - 🏢 Gestion des quartiers, bâtiments et propriétés
+        - 🤖 Prédictions ML avec RandomForest
+        - 📊 API REST complète avec documentation Swagger
+
+        EOF
+        fi
+
+        echo "Echo suppression des données non nécessaires en production"
+        git rm -f *.pdf
+        git rm -rf docs
+        git rm -rf sql
+        git rm -rf tests
+        echo "Ajouter tous les fichiers nécessaires (y compris LFS)"
+        git add -A
+        git commit -m "Deploy to HuggingFace Spaces from main branch"
+        
+        echo "Push vers HF avec authentification (LFS supporté)"
+        git push https://oauth2:$HF_TOKEN@huggingface.co/spaces/$HF_SPACE_NAME deploy-hf:main --force
+
+      

.github/workflows/doc.yml

@@ -0,0 +1,53 @@
+name: Build and Deploy Documentation
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.11'
+    
+    - name: Install Poetry
+      uses: snok/install-poetry@v1
+      with:
+        version: latest
+        virtualenvs-create: true
+        virtualenvs-in-project: true
+    
+    - name: Load cached venv
+      id: cached-poetry-dependencies
+      uses: actions/cache@v3
+      with:
+        path: .venv
+        key: venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-${{ hashFiles('**/poetry.lock') }}
+    
+    - name: Install dependencies
+      if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true'
+      run: poetry install --no-interaction --no-root
+    
+    - name: Build Sphinx documentation
+      run: |
+        cd docs && make sphinx-html
+    
+    - name: Deploy to GitHub Pages
+      uses: peaceiris/actions-gh-pages@v3
+      if: github.ref == 'refs/heads/main'
+      with:
+        personal_token: ${{ secrets.DOCS_DEPLOY_TOKEN }}
+        external_repository: ${{ secrets.DOCS_REPOSITORY }}
+        publish_dir: ./docs/build/html
+        publish_branch: gh-pages
+        user_name: 'github-actions[bot]'
+        user_email: 'github-actions[bot]@users.noreply.github.com'
+        commit_message: 'Deploy documentation from ${{ github.repository }}@${{ github.sha }}'

.gitignore

@@ -0,0 +1,685 @@
+# Created by https://www.toptal.com/developers/gitignore/api/pycharm,python,git
+# Edit at https://www.toptal.com/developers/gitignore?templates=pycharm,python,git
+
+### Git ###
+# Created by git for backups. To disable backups in Git:
+# $ git config --global mergetool.keepBackup false
+*.orig
+
+# Created by git when using merge tools for conflicts
+*.BACKUP.*
+*.BASE.*
+*.LOCAL.*
+*.REMOTE.*
+*_BACKUP_*.txt
+*_BASE_*.txt
+*_LOCAL_*.txt
+*_REMOTE_*.txt
+
+### PyCharm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### PyCharm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+# https://plugins.jetbrains.com/plugin/7973-sonarlint
+.idea/**/sonarlint/
+
+# SonarQube Plugin
+# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
+.idea/**/sonarIssues.xml
+
+# Markdown Navigator plugin
+# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator-enh.xml
+.idea/**/markdown-navigator/
+
+# Cache file creation bug
+# See https://youtrack.jetbrains.com/issue/JBR-2257
+.idea/$CACHE_FILE$
+
+# CodeStream plugin
+# https://plugins.jetbrains.com/plugin/12206-codestream
+.idea/codestream.xml
+
+# Azure Toolkit for IntelliJ plugin
+# https://plugins.jetbrains.com/plugin/8053-azure-toolkit-for-intellij
+.idea/**/azureSettings.xml
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/pycharm,python,git
+.env
+
+# Created by https://www.toptal.com/developers/gitignore/api/visualstudiocode
+# Edit at https://www.toptal.com/developers/gitignore?templates=visualstudiocode
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+# End of https://www.toptal.com/developers/gitignore/api/visualstudiocode
+# Created by https://www.toptal.com/developers/gitignore/api/macos
+# Edit at https://www.toptal.com/developers/gitignore?templates=macos
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+# End of https://www.toptal.com/developers/gitignore/api/macos
+# Created by https://www.toptal.com/developers/gitignore/api/latex
+# Edit at https://www.toptal.com/developers/gitignore?templates=latex
+
+### LaTeX ###
+## Core latex/pdflatex auxiliary files:
+*.aux
+*.lof
+*.log
+*.lot
+*.fls
+*.out
+*.toc
+*.fmt
+*.fot
+*.cb
+*.cb2
+.*.lb
+
+## Intermediate documents:
+*.dvi
+*.xdv
+*-converted-to.*
+# these rules might exclude image files for figures etc.
+# *.ps
+# *.eps
+# *.pdf
+
+## Generated if empty string is given at "Please type another file name for output:"
+.pdf
+
+## Bibliography auxiliary files (bibtex/biblatex/biber):
+*.bbl
+*.bcf
+*.blg
+*-blx.aux
+*-blx.bib
+*.run.xml
+
+## Build tool auxiliary files:
+*.fdb_latexmk
+*.synctex
+*.synctex(busy)
+*.synctex.gz
+*.synctex.gz(busy)
+*.pdfsync
+
+## Build tool directories for auxiliary files
+# latexrun
+latex.out/
+
+## Auxiliary and intermediate files from other packages:
+# algorithms
+*.alg
+*.loa
+
+# achemso
+acs-*.bib
+
+# amsthm
+*.thm
+
+# beamer
+*.nav
+*.pre
+*.snm
+*.vrb
+
+# changes
+*.soc
+
+# comment
+*.cut
+
+# cprotect
+*.cpt
+
+# elsarticle (documentclass of Elsevier journals)
+*.spl
+
+# endnotes
+*.ent
+
+# fixme
+*.lox
+
+# feynmf/feynmp
+*.mf
+*.mp
+*.t[1-9]
+*.t[1-9][0-9]
+*.tfm
+
+#(r)(e)ledmac/(r)(e)ledpar
+*.end
+*.?end
+*.[1-9]
+*.[1-9][0-9]
+*.[1-9][0-9][0-9]
+*.[1-9]R
+*.[1-9][0-9]R
+*.[1-9][0-9][0-9]R
+*.eledsec[1-9]
+*.eledsec[1-9]R
+*.eledsec[1-9][0-9]
+*.eledsec[1-9][0-9]R
+*.eledsec[1-9][0-9][0-9]
+*.eledsec[1-9][0-9][0-9]R
+
+# glossaries
+*.acn
+*.acr
+*.glg
+*.glo
+*.gls
+*.glsdefs
+*.lzo
+*.lzs
+*.slg
+*.slo
+*.sls
+
+# uncomment this for glossaries-extra (will ignore makeindex's style files!)
+# *.ist
+
+# gnuplot
+*.gnuplot
+*.table
+
+# gnuplottex
+*-gnuplottex-*
+
+# gregoriotex
+*.gaux
+*.glog
+*.gtex
+
+# htlatex
+*.4ct
+*.4tc
+*.idv
+*.lg
+*.trc
+*.xref
+
+# hyperref
+*.brf
+
+# knitr
+*-concordance.tex
+# TODO Uncomment the next line if you use knitr and want to ignore its generated tikz files
+# *.tikz
+*-tikzDictionary
+
+# listings
+*.lol
+
+# luatexja-ruby
+*.ltjruby
+
+# makeidx
+*.idx
+*.ilg
+*.ind
+
+# minitoc
+*.maf
+*.mlf
+*.mlt
+*.mtc[0-9]*
+*.slf[0-9]*
+*.slt[0-9]*
+*.stc[0-9]*
+
+# minted
+_minted*
+*.pyg
+
+# morewrites
+*.mw
+
+# newpax
+*.newpax
+
+# nomencl
+*.nlg
+*.nlo
+*.nls
+
+# pax
+*.pax
+
+# pdfpcnotes
+*.pdfpc
+
+# sagetex
+*.sagetex.sage
+*.sagetex.py
+*.sagetex.scmd
+
+# scrwfile
+*.wrt
+
+# svg
+svg-inkscape/
+
+# sympy
+*.sout
+*.sympy
+sympy-plots-for-*.tex/
+
+# pdfcomment
+*.upa
+*.upb
+
+# pythontex
+*.pytxcode
+pythontex-files-*/
+
+# tcolorbox
+*.listing
+
+# thmtools
+*.loe
+
+# TikZ & PGF
+*.dpth
+*.md5
+*.auxlock
+
+# titletoc
+*.ptc
+
+# todonotes
+*.tdo
+
+# vhistory
+*.hst
+*.ver
+
+# easy-todo
+*.lod
+
+# xcolor
+*.xcp
+
+# xmpincl
+*.xmpi
+
+# xindy
+*.xdy
+
+# xypic precompiled matrices and outlines
+*.xyc
+*.xyd
+
+# endfloat
+*.ttt
+*.fff
+
+# Latexian
+TSWLatexianTemp*
+
+## Editors:
+# WinEdt
+*.bak
+*.sav
+
+# Texpad
+.texpadtmp
+
+# LyX
+*.lyx~
+
+# Kile
+*.backup
+
+# gummi
+.*.swp
+
+# KBibTeX
+*~[0-9]*
+
+# TeXnicCenter
+*.tps
+
+# auto folder when using emacs and auctex
+./auto/*
+*.el
+
+# expex forward references with \gathertags
+*-tags.tex
+
+# standalone packages
+*.sta
+
+# Makeindex log files
+*.lpz
+
+# xwatermark package
+*.xwm
+
+# REVTeX puts footnotes in the bibliography by default, unless the nofootinbib
+# option is specified. Footnotes are the stored in a file with suffix Notes.bib.
+# Uncomment the next line to have this generated file ignored.
+#*Notes.bib
+
+### LaTeX Patch ###
+# LIPIcs / OASIcs
+*.vtc
+
+# glossaries
+*.glstex
+
+# End of https://www.toptal.com/developers/gitignore/api/latex
+.gradio
+.env
+sql/data/psql_data
+app.db
+model/backup

.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "python": "${workspaceFolder}/.venv/bin/python"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,48 @@
+{
+    "python.defaultInterpreterPath": "./venv/bin/python",
+    "python.terminal.activateEnvironment": true,
+    // Linting avec Poetry
+    "python.linting.enabled": true,
+    "python.linting.flake8Enabled": true,
+    "python.linting.lintOnSave": true,
+    "python.linting.flake8Path": "./venv/bin/flake8",
+    // Configuration spécifique pour Jupyter
+    "jupyter.linting.enabled": true,
+    // Formatting (si vous utilisez Black)
+    "python.formatting.provider": "black",
+    "python.formatting.blackPath": "./venv/bin/black",
+    "editor.formatOnSave": true,
+    // Désactiver autres linters
+    "python.linting.pylintEnabled": false,
+    "python.linting.pycodestyleEnabled": false,
+    "makefile.configureOnOpen": false,
+    "python.linting.flake8Args": [
+        "--max-line-length=88",
+        "--extend-ignore=E203,W503,E402"
+    ],
+    "editor.rulers": [
+        88
+    ],
+    // === ACTIONS SUR SAUVEGARDE NOTEBOOKS ===
+    "notebook.codeActionsOnSave": {
+        "source.organizeImports": true, // Organise les imports
+        "source.fixAll": false, // Désactiver les fix auto (optionnel)
+    },
+    // === ACTIONS SUR SAUVEGARDE FICHIERS PYTHON ===
+    "[python]": {
+        "editor.codeActionsOnSave": {
+            "source.organizeImports": "explicit",
+            "source.fixAll.flake8": "explicit"
+        },
+        "editor.defaultFormatter": "ms-python.black-formatter",
+        "editor.formatOnSave": true
+    },
+    // === CONFIGURATION ISORT (pour organiser imports) ===
+    "python.sortImports.args": [
+        "--profile=black", // Compatible avec Black
+        "--line-length=88"
+    ],
+    "black-formatter.args": [
+        "--line-length=88"
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,24 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "poetry install",
+            "type": "shell",
+            "command": "poetry",
+            "args": [
+                "install"
+            ],
+            "group": "build"
+        },
+        {
+            "label": "poetry run tests",
+            "type": "shell",
+            "command": "poetry",
+            "args": [
+                "run",
+                "pytest"
+            ],
+            "group": "test"
+        }
+    ]
+}

Dockerfile

@@ -0,0 +1,47 @@
+FROM python:3.11-slim
+
+# Installer Poetry et les dépendances système pour SQLite
+RUN apt-get update && apt-get install -y \
+    sqlite3 \
+    libsqlite3-dev \
+    && rm -rf /var/lib/apt/lists/* \
+    && pip install poetry
+
+# Configuration Poetry
+ENV POETRY_NO_INTERACTION=1 \
+    POETRY_VENV_IN_PROJECT=1 \
+    POETRY_CACHE_DIR=/tmp/poetry_cache \
+    VIRTUAL_ENV=/code/.venv \
+    PATH="/code/.venv/bin:$PATH"
+
+WORKDIR /code
+
+# Copier les fichiers de dépendances
+COPY pyproject.toml poetry.lock ./
+
+# Copier le code source d'abord
+COPY . .
+
+# Configurer Poetry pour créer le venv dans le projet
+
+RUN poetry config virtualenvs.in-project true && \
+    poetry install --only main --no-interaction --no-ansi
+
+# Installer toutes les dépendances et le projet
+#RUN poetry install --only=main && rm -rf $POETRY_CACHE_DIR
+
+# Configuration pour SQLite et HuggingFace Spaces
+ENV DATABASE_URL="sqlite:///:memory:" \
+    ENVIRONMENT="production" \
+    PORT=7860
+
+ENV ML_MODEL_PATH=../model/model.pkl
+
+# Exposer le port requis par HF Spaces
+EXPOSE 7860
+
+# Rendre le script d'initialisation exécutable
+RUN chmod +x init_db.py
+
+# Commande de démarrage avec initialisation de la base
+CMD ["sh", "-c", " poetry env activate && cd src && poetry run uvicorn project5.main:app --host 0.0.0.0 --port 7860"]

Dockerfile_app

@@ -0,0 +1,47 @@
+FROM python:3.11-slim
+
+# Installer Poetry et les dépendances système pour SQLite
+RUN apt-get update && apt-get install -y \
+    sqlite3 \
+    libsqlite3-dev \
+    && rm -rf /var/lib/apt/lists/* \
+    && pip install poetry
+
+# Configuration Poetry
+ENV POETRY_NO_INTERACTION=1 \
+    POETRY_VENV_IN_PROJECT=1 \
+    POETRY_CACHE_DIR=/tmp/poetry_cache \
+    VIRTUAL_ENV=/code/.venv \
+    PATH="/code/.venv/bin:$PATH"
+
+WORKDIR /code
+
+# Copier les fichiers de dépendances
+COPY pyproject.toml poetry.lock ./
+
+# Copier le code source d'abord
+COPY . .
+
+# Configurer Poetry pour créer le venv dans le projet
+
+RUN poetry config virtualenvs.in-project true && \
+    poetry install --only main --no-interaction --no-ansi
+
+# Installer toutes les dépendances et le projet
+#RUN poetry install --only=main && rm -rf $POETRY_CACHE_DIR
+
+# Configuration pour SQLite et HuggingFace Spaces
+ENV DATABASE_URL="sqlite:///:memory:" \
+    ENVIRONMENT="production" \
+    PORT=7860
+
+ENV ML_MODEL_PATH=../model/model.pkl
+
+# Exposer le port requis par HF Spaces
+EXPOSE 7860
+
+# Rendre le script d'initialisation exécutable
+RUN chmod +x init_db.py
+
+# Commande de démarrage avec initialisation de la base
+CMD ["sh", "-c", " poetry env activate && cd src && poetry run uvicorn project5.main:app --host 0.0.0.0 --port 7860"]

Makefile

@@ -0,0 +1,73 @@
+# Makefile pour FastAPI avec Poetry et Docker
+.PHONY: help build up down restart logs shell db-shell test lint format clean install migrate seed backup restore
+
+# Variables
+DOCKER_COMPOSE = docker-compose
+SERVICE_API = api
+SERVICE_DB = db
+PYTHON_FILES = src/project5/ tests/ docs/
+PROJECT_NAME = project5
+
+# Format des images par default
+FORMAT=png
+
+# Couleurs pour l'affichage
+GREEN = \033[0;32m
+YELLOW = \033[0;33m
+RED = \033[0;31m
+NC = \033[0m
+
+# Help - Affiche l'aide
+help: ## Affiche cette aide
+	@echo "$(GREEN)Makefile pour $(PROJECT_NAME) - FastAPI avec Poetry$(NC)"
+	@echo ""
+	@echo "$(YELLOW)Developpement LOCAL (recommande):$(NC)"
+	@grep -E '^[a-zA-Z_-]*-local:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "  $(YELLOW)%-25s$(NC) %s\n", $$1, $$2}'
+
+# Developpement local (sans Docker)
+dev-local: ## Lance l'API en local avec Poetry
+	@echo "$(GREEN)Demarrage local avec Poetry...$(NC)"
+	poetry run uvicorn src.$(PROJECT_NAME).main:app --host 0.0.0.0 --port 8000 --reload
+
+start-local: ## Alias pour dev-local
+	$(MAKE) dev-local
+
+install-local: ## Installe les dependances avec Poetry
+	@echo "$(GREEN)Installation des dependances avec Poetry...$(NC)"
+	poetry install
+
+update-local: ## Met a jour les dependances
+	@echo "$(GREEN)Mise a jour des dependances...$(NC)"
+	poetry update
+
+
+# Qualite de code (local)
+lint-local: ## Verifie le code avec flake8 et mypy en local
+	@echo "$(GREEN)Verification du code en local...$(NC)"
+	poetry run flake8 $(PYTHON_FILES)
+	poetry run mypy $(PYTHON_FILES) --ignore-missing-imports
+
+format-local: ## Formate le code avec black et isort en local
+	@echo "$(GREEN)Formatage du code en local...$(NC)"
+	poetry run black $(PYTHON_FILES)
+	poetry run isort $(PYTHON_FILES)
+
+format-check-local: ## Verifie le formatage sans modifier en local
+	@echo "$(GREEN)Verification du formatage en local...$(NC)"
+	poetry run black --check $(PYTHON_FILES)
+	poetry run isort --check-only $(PYTHON_FILES)
+
+check-local: format-check-local lint-local ## Verifie le formatage et la qualite du code en local
+
+# Tests local
+test-local: ## Lance les tests en local avec Poetry
+	@echo "$(GREEN)Execution des tests en local...$(NC)"
+	poetry run pytest -v
+
+test-cov-local: ## Lance les tests avec couverture en local
+	@echo "$(GREEN)Tests avec couverture en local...$(NC)"
+	poetry run pytest --cov=src/$(PROJECT_NAME) --cov-report=html --cov-report=term-missing
+
+
+# Commande par defaut
+.DEFAULT_GOAL := help

README.md

@@ -0,0 +1,20 @@
+---
+title: Building Energy Prediction API
+emoji: 🏢
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+---
+
+# Building Energy Prediction API
+
+API FastAPI pour la prédiction de consommation énergétique des bâtiments.
+
+## Fonctionnalités
+- 🏢 Gestion des quartiers, bâtiments et propriétés
+- 🤖 Prédictions ML avec RandomForest
+- 📊 API REST complète avec documentation Swagger
+

alembic.ini

@@ -0,0 +1,116 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

alembic/env.py

@@ -0,0 +1,75 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config, pool
+
+from alembic import context
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = None
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

alembic/script.py.mako

@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

init_db.py

@@ -0,0 +1,746 @@
+#!/usr/bin/env python3
+"""Script d'initialisation de la base de données SQLite pour HuggingFace Spaces."""
+
+import os
+import sqlite3
+import sys
+
+# Ajouter le répertoire src au path pour les imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+# Connexion globale en mémoire partagée
+_db_connection = None
+
+
+def get_db_connection():
+    """Retourne la connexion SQLite partagée en mémoire."""
+    global _db_connection
+    if _db_connection is None:
+        _db_connection = sqlite3.connect(":memory:", check_same_thread=False)
+    return _db_connection
+
+
+def init_sqlite_data():
+    """Initialise la base SQLite avec les données essentielles en utilisant SQLite direct."""
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+
+        # Vérifier les tables existantes
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+        tables = cursor.fetchall()
+        print(f"📋 Tables existantes: {[table[0] for table in tables]}")
+
+        print("📊 Insertion des données de référence...")
+
+        # Données Neighborhoods
+        neighborhoods = [
+            (1, "UNKNOWN", -1, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (2, "BALLARD", 0, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (3, "CENTRAL", 1, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (4, "DELRIDGE", 2, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (5, "DOWNTOWN", 3, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (6, "EAST", 4, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (7, "GREATER DUWAMISH", 5, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (8, "LAKE UNION", 6, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (
+                9,
+                "MAGNOLIA / QUEEN ANNE",
+                7,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (10, "NORTH", 8, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (11, "NORTHEAST", 9, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (12, "NORTHWEST", 10, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (13, "SOUTHEAST", 11, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (14, "SOUTHWEST", 12, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (15, "WEST", 13, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+        ]
+
+        cursor.executemany(
+            "INSERT OR REPLACE INTO neighborhood (id, neighborhood_name, model_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
+            neighborhoods,
+        )
+
+        # Données Building Types
+        building_types = [
+            (
+                1,
+                -1,
+                "UNKNOWN",
+                "Type de bâtiment inconnu ou non spécifié",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                2,
+                0,
+                "CAMPUS",
+                "Campus building complex",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                3,
+                1,
+                "NONRESIDENTIAL",
+                "Non-residential building",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                4,
+                2,
+                "NONRESIDENTIAL COS",
+                "Non-residential COS type",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                5,
+                3,
+                "NONRESIDENTIAL WA",
+                "Non-residential WA type",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                6,
+                4,
+                "SPS-DISTRICT K-12",
+                "Seattle Public Schools District K-12",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                7,
+                5,
+                "Multifamily MR (5-9)",
+                "Multifamily Mid-Rise 5-9 units",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                8,
+                6,
+                "Multifamily HR (10+)",
+                "Multifamily High-Rise 10+ units",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                9,
+                7,
+                "Multifamily LR (2-4)",
+                "Multifamily Low-Rise 2-4 units",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+        ]
+
+        cursor.executemany(
+            "INSERT OR REPLACE INTO building_type (id, model_id, building_type_name, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+            building_types,
+        )
+
+        # Données Categories
+        categories = [
+            (
+                1,
+                "UNKNOWN",
+                "UNKNOWN",
+                "Catégorie inconnue ou non spécifiée",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                2,
+                "CAMPUS",
+                "Campus",
+                "Complexes de campus et installations multiples",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                3,
+                "EDUCATION",
+                "Éducation",
+                "Établissements denseignement et de formation",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                4,
+                "ENTERTAINMENT",
+                "Divertissement",
+                "Théâtres, cinémas et espaces de divertissement",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                5,
+                "FINANCIAL",
+                "Services financiers",
+                "Banques, bureaux financiers et services monétaires",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                6,
+                "HEALTHCARE",
+                "Santé",
+                "Hôpitaux, cliniques et établissements de soins médicaux",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                7,
+                "INDUSTRIAL",
+                "Industrie",
+                "Usines et installations industrielles",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                8,
+                "LODGING",
+                "Hébergement",
+                "Hôtels et logements temporaires",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                9,
+                "MIXED",
+                "Usage mixte",
+                "Propriétés à usage multiple",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                10,
+                "NONE",
+                "Aucun",
+                "Aucune utilisation spécifique",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                11,
+                "OFFICE",
+                "Bureaux",
+                "Espaces de bureaux et administratifs",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                12,
+                "PARKING",
+                "Stationnement",
+                "Structures et espaces de stationnement",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                13,
+                "PUBLIC",
+                "Services publics",
+                "Services gouvernementaux et publics",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                14,
+                "RECREATION",
+                "Loisirs",
+                "Installations sportives et récréatives",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                15,
+                "RELIGIOUS",
+                "Religieux",
+                "Églises et lieux de culte",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                16,
+                "RESIDENTIAL",
+                "Résidentiel",
+                "Logements et habitations",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                17,
+                "RESTAURANT",
+                "Restauration",
+                "Restaurants et services alimentaires",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                18,
+                "RETAIL",
+                "Commerce de détail",
+                "Magasins et commerces",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                19,
+                "SOCIAL",
+                "Social",
+                "Clubs et espaces sociaux",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                20,
+                "STORE",
+                "Magasins",
+                "Commerces et magasins divers",
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+        ]
+
+        cursor.executemany(
+            "INSERT OR REPLACE INTO categories (id, category_code, category_name, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+            categories,
+        )
+
+        # Données Properties (sélection des principales)
+        properties = [
+            (1, -1, "UNKNOWN", 1, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (2, 0, "ADULT EDUCATION", 3, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (
+                3,
+                1,
+                "AUTOMOBILE DEALERSHIP",
+                20,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (4, 2, "BANK BRANCH", 5, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (5, 3, "BAR/NIGHTCLUB", 19, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (
+                6,
+                4,
+                "COLLEGE/UNIVERSITY",
+                3,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                7,
+                5,
+                "CONVENIENCE STORE WITHOUT GAS STATION",
+                20,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (8, 6, "COURTHOUSE", 15, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (9, 7, "DATA CENTER", 11, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (
+                10,
+                8,
+                "DISTRIBUTION CENTER",
+                7,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                11,
+                9,
+                "FINANCIAL OFFICE",
+                5,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (12, 10, "FOOD SALES", 17, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (
+                13,
+                11,
+                "HOSPITAL (GENERAL MEDICAL & SURGICAL)",
+                6,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (14, 12, "HOTEL", 8, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (15, 13, "K-12 SCHOOL", 3, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (16, 14, "LIBRARY", 3, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (17, 15, "MEDICAL OFFICE", 6, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (
+                18,
+                16,
+                "MULTIFAMILY HOUSING",
+                16,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                19,
+                17,
+                "MUNICIPAL WASTEWATER TREATMENT PLANT",
+                7,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (20, 18, "OFFICE", 11, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (21, 19, "OTHER", 1, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (22, 20, "PARKING", 12, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (23, 21, "RESTAURANT", 17, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (24, 22, "RETAIL STORE", 18, "2025-09-09 09:56:21", "2025-09-09 09:56:21"),
+            (
+                25,
+                23,
+                "SELF-STORAGE FACILITY",
+                7,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                26,
+                24,
+                "SENIOR LIVING COMMUNITY",
+                8,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                27,
+                25,
+                "SUPERMARKET/GROCERY STORE",
+                17,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                28,
+                26,
+                "WAREHOUSE (UNREFRIGERATED)",
+                7,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                29,
+                27,
+                "WORSHIP FACILITY",
+                15,
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+        ]
+
+        cursor.executemany(
+            "INSERT OR REPLACE INTO property (id, model_id, property_name, category_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+            properties,
+        )
+
+        # Données Building Models (exemples pour tester l'API)
+        building_models = [
+            (
+                1,
+                "SEATTLE001",
+                "123 Main Street",
+                "Seattle",
+                "WA",
+                "98101",
+                "TAX001",
+                "DISTRICT1",
+                47.6062,
+                -122.3321,
+                1995,
+                1,
+                15,
+                50000.0,
+                5000.0,
+                2000.0,
+                500.0,
+                0,  # multiusage
+                0,  # steam
+                1,  # electricity
+                1,  # natural_gas
+                2,  # neighborhood_id (BALLARD)
+                3,  # building_type_id (NONRESIDENTIAL)
+                20,  # largest_property_use_type_id (OFFICE)
+                20,  # primary_property_type_id (OFFICE)
+                1,  # second_largest_property_use_type_id (UNKNOWN)
+                1,  # third_largest_property_use_type_id (UNKNOWN)
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                2,
+                "SEATTLE002",
+                "456 Pine Avenue",
+                "Seattle",
+                "WA",
+                "98102",
+                "TAX002",
+                "DISTRICT2",
+                47.6205,
+                -122.3493,
+                2010,
+                1,
+                8,
+                25000.0,
+                2000.0,
+                0.0,
+                0.0,
+                0,  # multiusage
+                0,  # steam
+                1,  # electricity
+                1,  # natural_gas
+                5,  # neighborhood_id (DOWNTOWN)
+                7,  # building_type_id (Multifamily MR 5-9)
+                18,  # largest_property_use_type_id (MULTIFAMILY HOUSING)
+                18,  # primary_property_type_id (MULTIFAMILY HOUSING)
+                1,  # second_largest_property_use_type_id (UNKNOWN)
+                1,  # third_largest_property_use_type_id (UNKNOWN)
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+            (
+                3,
+                "SEATTLE003",
+                "789 University Way",
+                "Seattle",
+                "WA",
+                "98105",
+                "TAX003",
+                "DISTRICT3",
+                47.6587,
+                -122.3128,
+                1980,
+                1,
+                3,
+                15000.0,
+                1000.0,
+                500.0,
+                200.0,
+                1,  # multiusage
+                0,  # steam
+                1,  # electricity
+                1,  # natural_gas
+                11,  # neighborhood_id (NORTHEAST)
+                6,  # building_type_id (SPS-DISTRICT K-12)
+                15,  # largest_property_use_type_id (K-12 SCHOOL)
+                15,  # primary_property_type_id (K-12 SCHOOL)
+                16,  # second_largest_property_use_type_id (LIBRARY)
+                1,  # third_largest_property_use_type_id (UNKNOWN)
+                "2025-09-09 09:56:21",
+                "2025-09-09 09:56:21",
+            ),
+        ]
+
+        cursor.executemany(
+            """INSERT OR REPLACE INTO building_models (
+                id, ose_building_id, address, city, state, zip_code,
+                tax_parcel_identification_number, council_district_code,
+                latitude, longitude, year_built, number_of_buildings, number_of_floors,
+                property_gfa_total, property_gfa_parking,
+                second_largest_property_use_type_gfa, third_largest_property_use_type_gfa,
+                multiusage, steam, electricity, natural_gas,
+                neighborhood_id, building_type_id,
+                largest_property_use_type_id, primary_property_type_id,
+                second_largest_property_use_type_id, third_largest_property_use_type_id,
+                created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            building_models,
+        )
+
+        # Données Building Energy Predictions (exemples de prédictions)
+        energy_predictions = [
+            (
+                1,
+                1,  # building_id (correspond à SEATTLE001)
+                45678.5,  # site_energy_use_wn_kbtu
+                1,  # predicted (True)
+                "2025-09-09 10:30:00",
+            ),
+            (
+                2,
+                2,  # building_id (correspond à SEATTLE002)
+                23456.7,  # site_energy_use_wn_kbtu
+                1,  # predicted (True)
+                "2025-09-09 11:15:00",
+            ),
+            (
+                3,
+                3,  # building_id (correspond à SEATTLE003)
+                12345.3,  # site_energy_use_wn_kbtu
+                1,  # predicted (True)
+                "2025-09-09 12:00:00",
+            ),
+        ]
+
+        cursor.executemany(
+            """INSERT OR REPLACE INTO building_energy_predictions (
+                id, building_id, site_energy_use_wn_kbtu, predicted, updated_at
+            ) VALUES (?, ?, ?, ?, ?)""",
+            energy_predictions,
+        )
+
+        conn.commit()
+        # Ne pas fermer la connexion - elle reste en mémoire
+
+        print(f"✅ {len(neighborhoods)} quartiers insérés")
+        print(f"✅ {len(building_types)} types de bâtiments insérés")
+        print(f"✅ {len(categories)} catégories insérées")
+        print(f"✅ {len(properties)} propriétés insérées")
+        print(f"✅ {len(building_models)} bâtiments d'exemple insérés")
+        print(f"✅ {len(energy_predictions)} prédictions d'exemple insérées")
+
+    except Exception as e:
+        print(f"❌ Erreur lors de l'insertion des données: {e}")
+        raise
+
+
+def create_sqlite_tables():
+    """Crée les tables SQLite nécessaires avec raw SQL."""
+
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+
+        # Créer les tables de référence principales
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS neighborhood (
+                id INTEGER PRIMARY KEY,
+                neighborhood_name VARCHAR(50) NOT NULL UNIQUE,
+                model_id INTEGER NOT NULL UNIQUE,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            );
+        """
+        )
+
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS building_type (
+                id INTEGER PRIMARY KEY,
+                model_id INTEGER NOT NULL UNIQUE,
+                building_type_name VARCHAR(100) NOT NULL UNIQUE,
+                description TEXT,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            );
+        """
+        )
+
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS categories (
+                id INTEGER PRIMARY KEY,
+                category_code VARCHAR(50) NOT NULL UNIQUE,
+                category_name VARCHAR(100) NOT NULL,
+                description TEXT,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            );
+        """
+        )
+
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS property (
+                id INTEGER PRIMARY KEY,
+                model_id INTEGER NOT NULL UNIQUE,
+                property_name VARCHAR(150) NOT NULL UNIQUE,
+                category_id INTEGER NOT NULL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (category_id) REFERENCES categories (id)
+            );
+        """
+        )
+
+        # Créer les tables principales
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS building_energy_predictions (
+                id INTEGER PRIMARY KEY,
+                building_id INTEGER NOT NULL,
+                site_energy_use_wn_kbtu FLOAT NOT NULL,
+                predicted BOOLEAN DEFAULT 0,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            );
+        """
+        )
+
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS building_models (
+                id INTEGER PRIMARY KEY,
+                ose_building_id INTEGER NOT NULL UNIQUE,
+                address VARCHAR(255) NOT NULL,
+                city VARCHAR(100) NULL,
+                state VARCHAR(50)  NULL,
+                zip_code VARCHAR(20) NULL,
+                tax_parcel_identification_number VARCHAR(100) NULL,
+                council_district_code varchar(20) NULL,
+                latitude FLOAT NULL,
+                longitude FLOAT NULL,
+                year_built INTEGER NULL,
+                number_of_buildings INTEGER NULL,
+                number_of_floors INTEGER NULL,
+                property_gfa_total FLOAT NULL,
+                property_gfa_parking FLOAT NULL,
+                second_largest_property_use_type_gfa FLOAT NULL,
+                third_largest_property_use_type_gfa FLOAT NULL,
+                multiusage BOOLEAN DEFAULT 0,
+                steam BOOLEAN DEFAULT 0,
+                electricity BOOLEAN DEFAULT 0,
+                natural_gas BOOLEAN DEFAULT 0,
+                neighborhood_id INTEGER NULL,
+                building_type_id INTEGER NULL,
+                largest_property_use_type_id INTEGER NULL,
+                primary_property_type_id INTEGER NULL,
+                second_largest_property_use_type_id INTEGER NULL,
+                third_largest_property_use_type_id INTEGER NULL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (id) REFERENCES building_energy_predictions (building_id),
+                FOREIGN KEY (largest_property_use_type_id) REFERENCES property (id),
+                FOREIGN KEY (primary_property_type_id) REFERENCES property (id),
+                FOREIGN KEY (second_largest_property_use_type_id) REFERENCES property (id),
+                FOREIGN KEY (third_largest_property_use_type_id) REFERENCES property (id),
+                FOREIGN KEY (neighborhood_id) REFERENCES neighborhood (id),
+                FOREIGN KEY (building_type_id) REFERENCES building_type (id)
+            );
+        """
+        )
+
+        conn.commit()
+        # Ne pas fermer la connexion - elle reste en mémoire
+        print("🗄️ Structure des tables créée avec succès!")
+
+    except Exception as e:
+        print(f"❌ Erreur lors de la création des tables: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    try:
+        print("🚀 Initialisation de la base de données SQLite...")
+
+        # Créer les tables avec raw SQL
+        create_sqlite_tables()
+
+        print("📊 Insertion des données de référence...")
+        init_sqlite_data()
+        print("✅ Base de données SQLite initialisée avec succès!")
+
+    except Exception as e:
+        print(f"❌ Erreur lors de l'initialisation: {e}")
+        import traceback
+
+        traceback.print_exc()
+        sys.exit(1)

model/Makefile

@@ -0,0 +1,178 @@
+# Makefile pour la génération et gestion du modèle ML
+.PHONY: help model train validate clean info backup restore test
+
+# Variables
+PYTHON = python
+MODEL_FILE = model.pkl
+MODEL_INFO = model_info.json
+BACKUP_DIR = backup
+TIMESTAMP = $(shell date +%Y%m%d_%H%M%S)
+
+# Couleurs pour l'affichage
+GREEN = \033[0;32m
+YELLOW = \033[0;33m
+RED = \033[0;31m
+NC = \033[0m
+
+# Help - Affiche l'aide
+help: ## Affiche cette aide
+	@echo "$(GREEN)Makefile pour la gestion du modele ML$(NC)"
+	@echo ""
+	@echo "$(YELLOW)Generation du modele:$(NC)"
+	@echo "  $(YELLOW)model               $(NC) Alias pour train"
+	@echo "  $(YELLOW)train               $(NC) Genere le modele ML via model.py"
+	@echo "  $(YELLOW)retrain             $(NC) Force la regeneration du modele"
+	@echo "  $(YELLOW)setup               $(NC) Configuration et generation complete"
+	@echo ""
+	@echo "$(YELLOW)Validation et tests:$(NC)"
+	@echo "  $(YELLOW)validate            $(NC) Valide l'existence et l'integrite du modele"
+	@echo "  $(YELLOW)test                $(NC) Lance les tests de validation du modele"
+	@echo "  $(YELLOW)test-prediction     $(NC) Test une prediction simple"
+	@echo ""
+	@echo "$(YELLOW)Gestion et maintenance:$(NC)"
+	@echo "  $(YELLOW)info                $(NC) Affiche les informations detaillees du modele"
+	@echo "  $(YELLOW)model-size          $(NC) Affiche la taille des fichiers du modele"
+	@echo "  $(YELLOW)backup              $(NC) Sauvegarde le modele actuel"
+	@echo "  $(YELLOW)restore             $(NC) Restaure le dernier modele sauvegarde"
+	@echo "  $(YELLOW)list-backups        $(NC) Liste toutes les sauvegardes disponibles"
+	@echo "  $(YELLOW)clean               $(NC) Supprime les fichiers du modele actuel"
+	@echo "  $(YELLOW)clean-all           $(NC) Supprime tout (modele + sauvegardes)"
+	@echo ""
+	@echo "$(YELLOW)Environnement et verifications:$(NC)"
+	@echo "  $(YELLOW)check-deps          $(NC) Verifie les dependances Python"
+	@echo "  $(YELLOW)check-db            $(NC) Verifie la connexion a la base de donnees"
+
+# Génération du modèle
+model: train ## Alias pour train
+
+train: ## Génère le modèle ML via model.py
+	@echo "$(GREEN)Generation du modele de Machine Learning...$(NC)"
+	@if [ ! -f "$(MODEL_FILE)" ]; then \
+		echo "$(YELLOW)Aucun modele existant trouve. Generation d'un nouveau modele...$(NC)"; \
+	else \
+		echo "$(YELLOW)Un modele existant a ete trouve. Sauvegarde avant regeneration...$(NC)"; \
+		$(MAKE) backup; \
+	fi
+	$(PYTHON) model.py
+	@echo "$(GREEN)✅ Modele genere avec succes!$(NC)"
+	@if [ -f "$(MODEL_INFO)" ]; then \
+		echo "$(YELLOW)Informations du modele:$(NC)"; \
+		cat $(MODEL_INFO) | head -10; \
+	fi
+
+retrain: clean train ## Force la régénération du modèle
+
+# Validation et tests
+validate: ## Valide l'existence et l'intégrité du modèle
+	@echo "$(GREEN)Validation du modele...$(NC)"
+	@if [ ! -f "$(MODEL_FILE)" ]; then \
+		echo "$(RED)❌ Fichier modele manquant: $(MODEL_FILE)$(NC)"; \
+		exit 1; \
+	else \
+		echo "$(GREEN)✅ Fichier modele trouve: $(MODEL_FILE)$(NC)"; \
+	fi
+	@if [ ! -f "$(MODEL_INFO)" ]; then \
+		echo "$(RED)❌ Fichier d'information manquant: $(MODEL_INFO)$(NC)"; \
+		exit 1; \
+	else \
+		echo "$(GREEN)✅ Fichier d'information trouve: $(MODEL_INFO)$(NC)"; \
+	fi
+	@echo "$(GREEN)✅ Modele valide avec succes!$(NC)"
+
+test: validate ## Lance les tests de validation du modèle
+	@echo "$(GREEN)Test de chargement du modele...$(NC)"
+	@$(PYTHON) -c "import joblib; model = joblib.load('$(MODEL_FILE)'); print('✅ Modele charge avec succes'); print(f'Type: {type(model).__name__}'); import json; info = json.load(open('$(MODEL_INFO)')); print(f'Accuracy: {info.get(\"accuracy\", \"N/A\")}'); print(f'Features: {len(info.get(\"features\", []))} variables')"
+
+test-prediction: validate ## Test une prédiction simple
+	@echo "$(GREEN)Test de prediction...$(NC)"
+	@$(PYTHON) -c "import joblib; import json; import numpy as np; model = joblib.load('$(MODEL_FILE)'); info = json.load(open('$(MODEL_INFO)')); features = info['features']; test_data = np.random.random((1, len(features))); pred = model.predict(test_data); print(f'✅ Prediction test reussie: {pred[0]:.4f}')"
+
+# Gestion et maintenance
+info: ## Affiche les informations détaillées du modèle
+	@echo "$(GREEN)Informations du modele:$(NC)"
+	@if [ -f "$(MODEL_INFO)" ]; then \
+		cat $(MODEL_INFO); \
+	else \
+		echo "$(RED)❌ Fichier d'information non trouve$(NC)"; \
+		exit 1; \
+	fi
+
+model-size: ## Affiche la taille des fichiers du modèle
+	@echo "$(GREEN)Taille des fichiers:$(NC)"
+	@if [ -f "$(MODEL_FILE)" ]; then \
+		ls -lh $(MODEL_FILE) | awk '{print "Modele: " $$5 " (" $$9 ")"}'; \
+	fi
+	@if [ -f "$(MODEL_INFO)" ]; then \
+		ls -lh $(MODEL_INFO) | awk '{print "Info: " $$5 " (" $$9 ")"}'; \
+	fi
+
+backup: ## Sauvegarde le modèle actuel
+	@echo "$(GREEN)Sauvegarde du modele...$(NC)"
+	@mkdir -p $(BACKUP_DIR)
+	@if [ -f "$(MODEL_FILE)" ]; then \
+		cp $(MODEL_FILE) $(BACKUP_DIR)/model_$(TIMESTAMP).pkl; \
+		echo "$(GREEN)✅ Modele sauvegarde: $(BACKUP_DIR)/model_$(TIMESTAMP).pkl$(NC)"; \
+	fi
+	@if [ -f "$(MODEL_INFO)" ]; then \
+		cp $(MODEL_INFO) $(BACKUP_DIR)/model_info_$(TIMESTAMP).json; \
+		echo "$(GREEN)✅ Info sauvegardee: $(BACKUP_DIR)/model_info_$(TIMESTAMP).json$(NC)"; \
+	fi
+
+restore: ## Restaure le dernier modèle sauvegardé
+	@echo "$(GREEN)Restauration du dernier modele...$(NC)"
+	@if [ ! -d "$(BACKUP_DIR)" ]; then \
+		echo "$(RED)❌ Aucune sauvegarde trouvee$(NC)"; \
+		exit 1; \
+	fi
+	@LATEST_MODEL=$$(ls -t $(BACKUP_DIR)/model_*.pkl 2>/dev/null | head -1); \
+	LATEST_INFO=$$(ls -t $(BACKUP_DIR)/model_info_*.json 2>/dev/null | head -1); \
+	if [ -n "$$LATEST_MODEL" ]; then \
+		cp "$$LATEST_MODEL" $(MODEL_FILE); \
+		echo "$(GREEN)✅ Modele restaure: $$LATEST_MODEL$(NC)"; \
+	fi; \
+	if [ -n "$$LATEST_INFO" ]; then \
+		cp "$$LATEST_INFO" $(MODEL_INFO); \
+		echo "$(GREEN)✅ Info restauree: $$LATEST_INFO$(NC)"; \
+	fi
+
+list-backups: ## Liste toutes les sauvegardes disponibles
+	@echo "$(GREEN)Sauvegardes disponibles:$(NC)"
+	@if [ -d "$(BACKUP_DIR)" ]; then \
+		ls -la $(BACKUP_DIR)/ | grep -E '\.(pkl|json)$$' | awk '{print $$9 " (" $$5 " bytes, " $$6 " " $$7 " " $$8 ")"}' || echo "$(YELLOW)Aucune sauvegarde trouvee$(NC)"; \
+	else \
+		echo "$(YELLOW)Aucun dossier de sauvegarde$(NC)"; \
+	fi
+
+clean: ## Supprime les fichiers du modèle actuel
+	@echo "$(GREEN)Nettoyage des fichiers du modele...$(NC)"
+	@if [ -f "$(MODEL_FILE)" ]; then \
+		rm $(MODEL_FILE); \
+		echo "$(GREEN)✅ $(MODEL_FILE) supprime$(NC)"; \
+	fi
+	@if [ -f "$(MODEL_INFO)" ]; then \
+		rm $(MODEL_INFO); \
+		echo "$(GREEN)✅ $(MODEL_INFO) supprime$(NC)"; \
+	fi
+
+clean-all: clean ## Supprime tout (modèle + sauvegardes)
+	@echo "$(GREEN)Nettoyage complet...$(NC)"
+	@if [ -d "$(BACKUP_DIR)" ]; then \
+		rm -rf $(BACKUP_DIR); \
+		echo "$(GREEN)✅ Dossier de sauvegarde supprime$(NC)"; \
+	fi
+
+# Environnement et dépendances
+check-deps: ## Vérifie les dépendances Python
+	@echo "$(GREEN)Verification des dependances...$(NC)"
+	@$(PYTHON) -c "import sklearn, pandas, numpy, joblib; print('✅ Toutes les dependances sont disponibles')" || (echo "$(RED)❌ Dependances manquantes$(NC)" && exit 1)
+
+check-db: ## Vérifie la connexion à la base de données
+	@echo "$(GREEN)Verification de la connexion DB...$(NC)"
+	@$(PYTHON) -c "from sqlalchemy import create_engine; import os; engine = create_engine(os.getenv('DATABASE_URL', 'postgresql://user:password@localhost/dbname')); engine.connect(); print('✅ Connexion DB reussie')" || (echo "$(RED)❌ Erreur de connexion DB$(NC)" && exit 1)
+
+# Workflow complet
+setup: check-deps check-db train ## Configuration et génération complète
+	@echo "$(GREEN)✅ Setup complet termine!$(NC)"
+
+# Commande par défaut
+.DEFAULT_GOAL := help

model/README.md

@@ -0,0 +1,205 @@
+# 🤖 Modèle de Machine Learning - Project5
+
+Ce dossier contient le modèle de Machine Learning pour la prédiction de consommation énergétique des bâtiments.
+
+## 📁 Structure des fichiers
+
+```
+model/
+├── model.py                    # Script de génération du modèle
+├── model.pkl                   # Modèle RandomForest sérialisé (26MB)
+├── model_info.json            # Métadonnées et métriques du modèle
+├── generate_model_report.py    # Générateur de rapport HTML
+├── Makefile                   # Automatisation des tâches
+├── backup/                    # Sauvegardes des modèles
+└── README.md                  # Cette documentation
+```
+
+## 🎯 Modèle actuel
+
+### Informations générales
+- **Type** : RandomForestRegressor
+- **Version** : 1.0
+- **Créé le** : 2025-09-21T11:07:42
+- **Taille** : 26.0 MB
+- **Variables** : 17 features
+
+### Métriques de performance
+```json
+{
+  "accuracy": 0.916,
+  "RMSE": 0.09,
+  "MAE": 0.22,
+  "R²": 0.92
+}
+```
+
+### Variables d'entrée (17 features)
+```
+year_built
+number_of_buildings
+number_of_floors
+property_gfa_total
+property_gfa_parking
+second_largest_property_use_type_gfa
+third_largest_property_use_type_gfa
+multiusage
+steam
+electricity
+natural_gas
+neighborhood_id
+building_type_id
+largest_property_use_type_id
+primary_property_type_id
+second_largest_property_use_type_id
+third_largest_property_use_type_id
+```
+
+## 🚀 Utilisation rapide
+
+### Génération du modèle
+```bash
+# Installation et génération complète
+make setup
+
+# Génération simple
+make train
+
+# Force la régénération
+make retrain
+```
+
+### Validation et tests
+```bash
+# Valider l'intégrité du modèle
+make validate
+
+# Tester le chargement
+make test
+
+# Tester une prédiction
+make test-prediction
+```
+
+### Rapport et informations
+```bash
+# Générer un rapport HTML complet
+make report
+
+# Informations rapides
+make info
+
+# Taille des fichiers
+make model-size
+```
+
+## 📊 Commandes disponibles
+
+### **Génération du modèle**
+- `make model` / `make train` - Génère le modèle via model.py
+- `make retrain` - Force la régénération (supprime + recrée)
+- `make setup` - Workflow complet (dépendances + DB + génération)
+
+### **Validation et tests**
+- `make validate` - Vérifie l'existence et l'intégrité des fichiers
+- `make test` - Test de chargement et validation du modèle
+- `make test-prediction` - Test d'une prédiction avec données aléatoires
+
+### **Gestion et maintenance**
+- `make info` - Affiche les informations détaillées (JSON)
+- `make model-size` - Affiche la taille des fichiers
+- `make backup` - Sauvegarde avec timestamp
+- `make restore` - Restaure la dernière sauvegarde
+- `make list-backups` - Liste toutes les sauvegardes
+- `make clean` / `make clean-all` - Nettoyage
+
+### **Environnement**
+- `make check-deps` - Vérifie les dépendances Python
+- `make check-db` - Teste la connexion à la base de données
+
+
+## 🔧 Configuration technique
+
+### Prérequis
+```python
+# Dépendances principales
+import sklearn
+import pandas
+import numpy
+import joblib
+```
+
+### Variables d'environnement
+```bash
+DATABASE_URL=postgresql://user:password@localhost/dbname
+```
+
+### Source des données
+Le modèle est entraîné sur la vue `model_view` de la base de données PostgreSQL qui agrège :
+- Données Seattle (2016_Building_Energy_Benchmarking.csv)
+- Données OSE (building_consumption_OSEBuildingID.csv)
+
+## 🛠️ Développement
+
+### Regeneration du modèle
+1. Modifier les hyperparamètres dans `model.py`
+2. Exécuter `make train`
+3. Valider avec `make test`
+4. Générer le rapport avec `make report`
+
+### Sauvegarde et versioning
+```bash
+# Sauvegarde manuelle
+make backup
+
+# Lister les versions
+make list-backups
+
+# Restaurer une version précédente
+make restore
+```
+
+### Structure du modèle
+```python
+# Configuration RandomForest
+RandomForestRegressor(
+    n_estimators=500,
+    max_features=0.5,
+    random_state=42,
+    min_samples_split=5,
+    max_depth=20
+)
+```
+
+## 📊 Pipeline de données
+
+1. **Source** : Vue `model_view` (PostgreSQL)
+2. **Transformation** : Log de la variable cible `site_energy_use_wn_kbtu`
+3. **Split** : 80/20 train/test (random_state=42)
+4. **Validation** : Cross-validation 5-fold
+5. **Métriques** : RMSE, MAE, R², Accuracy
+
+## 🔗 Intégration API
+
+Le modèle est automatiquement chargé par l'API FastAPI au démarrage :
+
+```python
+# Dans main.py
+from project5.ml.model import MLModel
+
+model = MLModel()
+model.load_model()  # Charge model.pkl
+```
+
+## 📞 Support
+
+Pour toute question ou problème :
+
+1. **Vérifier l'intégrité** : `make validate`
+2. **Tester le modèle** : `make test`
+3. **Générer un rapport** : `make report`
+4. **Consulter les logs** : Vérifier les sorties des commandes make
+
+---
+
+**🏢 Project5 - API de gestion énergétique des bâtiments**

model/model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40c2d682207023def3bfbebf149e5c33e219aa80b5a95f7daec8452ccee1f697
+size 27298225

model/model.py

@@ -0,0 +1,130 @@
+# This Python file uses the following encoding: utf-8
+# Permet de générer le modèle à partir de la base de données
+# Reprise et adaptation du notebook du projet3
+import json
+import os
+from datetime import datetime
+
+import joblib
+import numpy as np
+import pandas as pd
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+from sklearn.model_selection import cross_validate, train_test_split
+from sqlalchemy import create_engine
+
+DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://user:password@localhost/dbname")
+
+
+def get_for_model(features):
+    # Separation du jeu de données en train, test
+    X = building_consumption[features]
+    y = building_consumption["log_" + var_a_predire]
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, shuffle=True
+    )
+
+    # X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=42)
+    print(f"Shape de X_train: {X_train.shape}")
+    print(f"Shape de y_train: {y_train.shape}")
+    print(f"Shape de X_test: {X_test.shape}")
+    print(f"Shape de y_train: {y_test.shape}")
+    return X_train, X_test, y_train, y_test
+
+
+def get_score(y, prediction):
+    mse = mean_squared_error(y, prediction)
+    mae = mean_absolute_error(y, prediction)
+    r2 = r2_score(y, prediction)
+    return mse, mae, r2
+
+
+scores = {}
+
+engine = create_engine(DATABASE_URL)
+
+query = "SELECT * FROM model_view"
+building_consumption = pd.read_sql(query, engine)
+
+print(building_consumption.info())
+engine.dispose()
+
+var_a_predire = "site_energy_use_wn_kbtu"
+building_consumption["log_" + var_a_predire] = np.log(
+    building_consumption[var_a_predire]
+)
+
+
+# Features
+features = [
+    "year_built",
+    "number_of_buildings",
+    "number_of_floors",
+    "property_gfa_total",
+    "property_gfa_parking",
+    "second_largest_property_use_type_gfa",
+    "third_largest_property_use_type_gfa",
+    "multiusage",
+    "steam",
+    "electricity",
+    "natural_gas",
+    "neighborhood_id",
+    "building_type_id",
+    "largest_property_use_type_id",
+    "primary_property_type_id",
+    "second_largest_property_use_type_id",
+    "third_largest_property_use_type_id",
+]
+X_train, X_test, y_train, y_test = get_for_model(features)
+
+# Initialisation du modèle
+rf = RandomForestRegressor(
+    n_estimators=500,
+    max_features=0.5,
+    random_state=42,
+    min_samples_split=5,
+    max_depth=20,
+)
+
+# Entraînement sur l'ensemble des données
+X = building_consumption[features]
+y = building_consumption["log_" + var_a_predire]
+rf.fit(X, y)
+
+# Prédiction
+y_pred = rf.predict(X_test)
+scores_cross = cross_validate(
+    rf, X_train, y_train, cv=5
+)  # cv=5 pour une validation croisée à 5 plis
+fit_time = scores_cross["fit_time"].mean()
+score_time = scores_cross["score_time"].mean()
+scores.update(
+    {"RandomForestRegressor HP": get_score(y_test, y_pred) + (fit_time, score_time)}
+)
+
+resultats = pd.DataFrame(scores).T
+resultats.columns = ["RMSE", "MAE", "R^2", "Fit Time", "Score Time"]
+resultats = resultats.round(2)
+print(resultats[-1:1]["RMSE"].values)
+
+# Sauvegarde du modèle
+# Informations du modèle
+model_info = {
+    "model_type": type(rf).__name__,
+    "model_module": type(rf).__module__,
+    "has_feature_importances": hasattr(rf, "feature_importances_"),
+    "has_coefficients": hasattr(rf, "coef_"),
+    "has_predict_proba": hasattr(rf, "predict_proba"),
+    "version": "1.0",
+    "created_at": datetime.now().isoformat(),
+    "features": list(X_train.columns),
+    "accuracy": rf.score(X_test, y_test),
+    "RMSE": resultats[-1:1]["RMSE"].values[0],
+    "MAE": resultats[-1:1]["MAE"].values[0],
+    "R^2": resultats[-1:1]["R^2"].values[0],
+}
+
+# Sauvegarder modèle et métadonnées
+joblib.dump(rf, "model.pkl")
+with open("model_info.json", "w") as f:
+    json.dump(model_info, f, indent=2)

model/model_info.json

@@ -0,0 +1,32 @@
+{
+  "model_type": "RandomForestRegressor",
+  "model_module": "sklearn.ensemble._forest",
+  "has_feature_importances": true,
+  "has_coefficients": false,
+  "has_predict_proba": false,
+  "version": "1.0",
+  "created_at": "2025-09-21T11:07:42.926661",
+  "features": [
+    "year_built",
+    "number_of_buildings",
+    "number_of_floors",
+    "property_gfa_total",
+    "property_gfa_parking",
+    "second_largest_property_use_type_gfa",
+    "third_largest_property_use_type_gfa",
+    "multiusage",
+    "steam",
+    "electricity",
+    "natural_gas",
+    "neighborhood_id",
+    "building_type_id",
+    "largest_property_use_type_id",
+    "primary_property_type_id",
+    "second_largest_property_use_type_id",
+    "third_largest_property_use_type_id"
+  ],
+  "accuracy": 0.9160018446396789,
+  "RMSE": 0.09,
+  "MAE": 0.22,
+  "R^2": 0.92
+}

model/model_report.html

@@ -0,0 +1,449 @@
+
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Rapport Modèle ML - Project5</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            line-height: 1.6;
+            margin: 0;
+            padding: 20px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: #333;
+            min-height: 100vh;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 15px;
+            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+        .header {
+            background: linear-gradient(135deg, #2c3e50 0%, #3498db 100%);
+            color: white;
+            padding: 30px;
+            text-align: center;
+        }
+        .header h1 {
+            margin: 0;
+            font-size: 2.5em;
+            font-weight: 300;
+        }
+        .header p {
+            margin: 10px 0 0 0;
+            opacity: 0.9;
+            font-size: 1.1em;
+        }
+        .content {
+            padding: 30px;
+        }
+        .section {
+            margin-bottom: 30px;
+            background: #f8f9fa;
+            border-radius: 10px;
+            padding: 25px;
+            border-left: 5px solid #3498db;
+        }
+        .section h2 {
+            color: #2c3e50;
+            margin-top: 0;
+            margin-bottom: 20px;
+            font-size: 1.5em;
+            display: flex;
+            align-items: center;
+        }
+        .section h2::before {
+            content: "📊";
+            margin-right: 10px;
+            font-size: 1.2em;
+        }
+        .metrics-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin: 20px 0;
+        }
+        .metric-card {
+            background: white;
+            padding: 20px;
+            border-radius: 8px;
+            text-align: center;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+            border: 1px solid #e1e8ed;
+        }
+        .metric-value {
+            font-size: 2em;
+            font-weight: bold;
+            color: #3498db;
+            margin-bottom: 5px;
+        }
+        .metric-label {
+            color: #7f8c8d;
+            font-size: 0.9em;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+        .info-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 15px;
+        }
+        .info-item {
+            background: white;
+            padding: 15px;
+            border-radius: 8px;
+            border-left: 4px solid #3498db;
+        }
+        .info-label {
+            font-weight: bold;
+            color: #2c3e50;
+            margin-bottom: 5px;
+        }
+        .info-value {
+            color: #7f8c8d;
+        }
+        .features-list {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 10px;
+            margin-top: 15px;
+        }
+        .feature-item {
+            background: white;
+            padding: 10px 15px;
+            border-radius: 6px;
+            border-left: 3px solid #2ecc71;
+            font-size: 0.9em;
+        }
+        .importance-table {
+            background: white;
+            border-radius: 8px;
+            overflow: hidden;
+            margin-top: 20px;
+        }
+        .importance-table table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+        .importance-table th {
+            background: #3498db;
+            color: white;
+            padding: 15px;
+            text-align: left;
+        }
+        .importance-table td {
+            padding: 12px 15px;
+            border-bottom: 1px solid #ecf0f1;
+        }
+        .importance-table tr:nth-child(even) {
+            background: #f8f9fa;
+        }
+        .importance-bar {
+            background: #ecf0f1;
+            height: 20px;
+            border-radius: 10px;
+            overflow: hidden;
+            position: relative;
+        }
+        .importance-fill {
+            background: linear-gradient(90deg, #3498db, #2ecc71);
+            height: 100%;
+            border-radius: 10px;
+            transition: width 0.3s ease;
+        }
+        .footer {
+            background: #2c3e50;
+            color: white;
+            text-align: center;
+            padding: 20px;
+            margin-top: 30px;
+        }
+        .status-badge {
+            display: inline-block;
+            padding: 5px 15px;
+            border-radius: 20px;
+            font-size: 0.8em;
+            font-weight: bold;
+            text-transform: uppercase;
+        }
+        .status-success {
+            background: #2ecc71;
+            color: white;
+        }
+        .status-info {
+            background: #3498db;
+            color: white;
+        }
+        @media (max-width: 768px) {
+            .container {
+                margin: 10px;
+                border-radius: 0;
+            }
+            .metrics-grid {
+                grid-template-columns: 1fr;
+            }
+            .info-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🤖 Rapport Modèle ML</h1>
+            <p>Project5 - Prédiction énergétique des bâtiments</p>
+            <p>Généré le 21/09/2025 à 11:11:02</p>
+        </div>
+
+        <div class="content">
+
+            <div class="section">
+                <h2>Informations Générales</h2>
+                <div class="info-grid">
+                    <div class="info-item">
+                        <div class="info-label">Type de Modèle</div>
+                        <div class="info-value">RandomForestRegressor</div>
+                    </div>
+                    <div class="info-item">
+                        <div class="info-label">Version</div>
+                        <div class="info-value">1.0</div>
+                    </div>
+                    <div class="info-item">
+                        <div class="info-label">Date de Création</div>
+                        <div class="info-value">2025-09-21T11:07:42.926661</div>
+                    </div>
+                    <div class="info-item">
+                        <div class="info-label">Module Python</div>
+                        <div class="info-value">sklearn.ensemble._forest</div>
+                    </div>
+                    <div class="info-item">
+                        <div class="info-label">Taille du Modèle</div>
+                        <div class="info-value">26.0 MB</div>
+                    </div>
+                    <div class="info-item">
+                        <div class="info-label">Nombre de Features</div>
+                        <div class="info-value">17</div>
+                    </div>
+                </div>
+            </div>
+
+            <div class="section">
+                <h2>Métriques de Performance</h2>
+                <div class="metrics-grid">
+                    <div class="metric-card">
+                        <div class="metric-value">0.916</div>
+                        <div class="metric-label">Accuracy (R²)</div>
+                    </div>
+                    <div class="metric-card">
+                        <div class="metric-value">0.090</div>
+                        <div class="metric-label">RMSE</div>
+                    </div>
+                    <div class="metric-card">
+                        <div class="metric-value">0.220</div>
+                        <div class="metric-label">MAE</div>
+                    </div>
+                    <div class="metric-card">
+                        <div class="metric-value">0.920</div>
+                        <div class="metric-label">R² Score</div>
+                    </div>
+                </div>
+            </div>
+
+            <div class="section">
+                <h2>Capacités du Modèle</h2>
+                <div class="info-grid">
+                    <div class="info-item">
+                        <div class="info-label">Feature Importances</div>
+                        <div class="info-value">
+                            <span class="status-badge status-success">
+                                ✓ Disponible
+                            </span>
+                        </div>
+                    </div>
+                    <div class="info-item">
+                        <div class="info-label">Coefficients</div>
+                        <div class="info-value">
+                            <span class="status-badge status-info">
+                                ✗ Non disponible
+                            </span>
+                        </div>
+                    </div>
+                    <div class="info-item">
+                        <div class="info-label">Prédiction Probabiliste</div>
+                        <div class="info-value">
+                            <span class="status-badge status-info">
+                                ✗ Non disponible
+                            </span>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <div class="section">
+                <h2>Variables d'Entrée (17 features)</h2>
+                <div class="features-list">
+                    <div class="feature-item">year_built</div>
+                    <div class="feature-item">number_of_buildings</div>
+                    <div class="feature-item">number_of_floors</div>
+                    <div class="feature-item">property_gfa_total</div>
+                    <div class="feature-item">property_gfa_parking</div>
+                    <div class="feature-item">second_largest_property_use_type_gfa</div>
+                    <div class="feature-item">third_largest_property_use_type_gfa</div>
+                    <div class="feature-item">multiusage</div>
+                    <div class="feature-item">steam</div>
+                    <div class="feature-item">electricity</div>
+                    <div class="feature-item">natural_gas</div>
+                    <div class="feature-item">neighborhood_id</div>
+                    <div class="feature-item">building_type_id</div>
+                    <div class="feature-item">largest_property_use_type_id</div>
+                    <div class="feature-item">primary_property_type_id</div>
+                    <div class="feature-item">second_largest_property_use_type_id</div>
+                    <div class="feature-item">third_largest_property_use_type_id</div>
+
+                </div>
+            </div>
+
+            <div class="section">
+                <h2>Importance des Variables</h2>
+                <div class="importance-table">
+                    <table>
+                        <thead>
+                            <tr>
+                                <th>Variable</th>
+                                <th>Importance</th>
+                                <th>Pourcentage</th>
+                                <th>Visualisation</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+
+                            <tr>
+                                <td><strong>property_gfa_total</strong></td>
+                                <td>0.4159</td>
+                                <td>41.59%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 100.0%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>primary_property_type_id</strong></td>
+                                <td>0.1205</td>
+                                <td>12.05%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 28.96743295740477%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>largest_property_use_type_id</strong></td>
+                                <td>0.0907</td>
+                                <td>9.07%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 21.803967049724744%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>year_built</strong></td>
+                                <td>0.0760</td>
+                                <td>7.60%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 18.264056040746727%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>second_largest_property_use_type_gfa</strong></td>
+                                <td>0.0665</td>
+                                <td>6.65%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 15.990714913050171%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>number_of_floors</strong></td>
+                                <td>0.0649</td>
+                                <td>6.49%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 15.614344234190247%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>natural_gas</strong></td>
+                                <td>0.0444</td>
+                                <td>4.44%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 10.669995866214208%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>neighborhood_id</strong></td>
+                                <td>0.0368</td>
+                                <td>3.68%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 8.854359706938872%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>property_gfa_parking</strong></td>
+                                <td>0.0209</td>
+                                <td>2.09%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 5.020163876222049%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                            <tr>
+                                <td><strong>second_largest_property_use_type_id</strong></td>
+                                <td>0.0206</td>
+                                <td>2.06%</td>
+                                <td>
+                                    <div class="importance-bar">
+                                        <div class="importance-fill" style="width: 4.95439652964564%"></div>
+                                    </div>
+                                </td>
+                            </tr>
+
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+
+        </div>
+
+        <div class="footer">
+            <p>🏢 Project5 - API de gestion énergétique des bâtiments</p>
+            <p>Généré automatiquement le 21/09/2025 à 11:11:02</p>
+        </div>
+    </div>
+</body>
+</html>

pyproject.toml

@@ -0,0 +1,168 @@
+# pyproject.toml corrigé pour Poetry
+[tool.poetry]
+name = "project5"
+version = "0.1.0"
+description = "Prédiction de consommation énergétique des bâtiments"
+authors = ["francois hellebuyck <formation.fhellebuyck@pm.me>"]
+packages = [{include = "project5", from = "src"}]
+
+[tool.poetry.group.docs.dependencies]
+# Sphinx et extensions essentielles
+sphinx = "^7.2.6"
+sphinx-rtd-theme = "^1.3.0"
+sphinx-autodoc-typehints = "^1.25.2"
+sphinx-copybutton = "^0.5.2"
+myst-parser = "^2.0.0"
+sphinx-autobuild = "^2021.3.14"
+sphinxcontrib-napoleon = "^0.7"
+
+# Extensions optionnelles mais recommandées
+sphinx-book-theme = "^1.0.1"           # Thème moderne alternatif
+sphinxext-rediraffe = "^0.2.7"         # Redirections
+sphinx-design = "^0.5.0"               # Composants modernes
+sphinx-tabs = "^3.4.4"                 # Onglets
+sphinx-togglebutton = "^0.3.2"         # Boutons pliables
+
+[tool.poetry.dependencies]
+python = "^3.11"
+fastapi = "^0.116.1"
+uvicorn = {extras = ["standard"], version = "^0.35.0"}
+# Base de données
+sqlalchemy = "^2.0.23"
+alembic = "^1.12.1"
+psycopg2-binary = "^2.9.9"
+# Configuration et sécurité
+pydantic = "^2.5.0"
+pydantic-settings = "^2.1.0"
+python-dotenv = "^1.0.0"
+passlib = {extras = ["bcrypt"], version = "^1.7.4"}
+# Utilitaires
+httpx = "^0.25.0"
+python-jwt = "^4.1.0"
+joblib = "^1.5.2"
+numpy = "^2.3.3"
+scikit-learn = "1.7.1"
+pandas = "^2.3.2"
+shibuya = "^2025.8.16"
+eralchemy = "^1.3.0"
+graphviz = "^0.20.0"
+
+
+[tool.poetry.group.dev.dependencies]
+pylint = "^3.3.8"
+pytest = "^7.4.0"
+pytest-cov = "^4.1.0" 
+pytest-asyncio = "^0.21.0"
+httpx = "^0.25.0"
+black = "^24.0.0"
+isort = "^5.12.0"
+flake8 = "^6.1.0"
+mypy = "^1.6.0"
+bandit = "^1.7.5"
+safety = "^2.3.0"
+# Tests de base de données
+pytest-postgresql = "^5.0.0"
+aiosqlite = "^0.19.0"
+sqlacodegen = "^3.1.0"
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 88
+target-version = ['py311']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | build
+  | dist
+  | alembic/versions
+)/
+'''
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+use_parentheses = true
+ensure_newline_before_comments = true
+line_length = 88
+
+[tool.mypy]
+python_version = "3.11"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+plugins = ["sqlalchemy.ext.mypy.plugin"]
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q --strict-markers"
+testpaths = [
+    "tests",
+]
+pythonpath = ["./src"] 
+asyncio_mode = "auto"
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+    "database: Tests requiring database",
+    "slow: Slow running tests",
+]
+
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "*/tests/*",
+    "*/venv/*",
+    "*/.venv/*",
+    "*/env/*",
+    "*/alembic/*",
+    "*/migrations/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if self.debug:",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+    "class .*\\bProtocol\\):",
+    "@(abc\\.)?abstractmethod",
+]
+
+[tool.flake8]
+max-line-length = 88
+extend-ignore = [
+    "E203",
+    "W503",
+    "E402",
+    "E501",
+]
+exclude = [
+    ".git",
+    "__pycache__",
+    ".venv", 
+    "venv",
+    ".jupyter",
+    "alembic/versions",
+    "migrations",
+]
+per-file-ignores = [
+    "*.ipynb:E402",
+    "alembic/*:E402,F401",
+]

src/project5/__init__.py

@@ -0,0 +1,10 @@
+"""API REST pour gérer les bâtiments"""
+
+__version__ = "1.0.0"
+__author__ = "François Hellebuyck"
+
+# Exposer certaines classes au niveau du package
+from .database import engine, get_db
+from .models import Neighborhood
+
+__all__ = ["get_db", "engine", "Neighborhood"]

src/project5/alembic.ini

@@ -0,0 +1,72 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+file_template = %%(year)d%%(month).2d%%(day).2d_%%(hour).2d%%(minute).2d_%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version number format.  This value should be incrementing integer,
+# typically starting at 1.
+# version_num_format = %d
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

src/project5/config.py

@@ -0,0 +1,63 @@
+"""Configuration de l'application."""
+
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Configuration de l'application via variables d'environnement."""
+
+    # Configuration de l'application
+    app_name: str = Field(
+        default="API de gestion énergétique des bâtiments", env="APP_NAME"
+    )
+    app_version: str = Field(default="1.0.0", env="APP_VERSION")
+    debug: bool = Field(default=False, env="DEBUG")
+    environment: str = Field(default="production", env="ENVIRONMENT")
+
+    # Configuration de la base de données
+    database_url: str = Field(..., env="DATABASE_URL")
+    db_pool_size: int = Field(default=20, env="DB_POOL_SIZE")
+    db_max_overflow: int = Field(default=0, env="DB_MAX_OVERFLOW")
+    db_pool_pre_ping: bool = Field(default=True, env="DB_POOL_PRE_PING")
+    db_echo: bool = Field(default=False, env="DB_ECHO")
+
+    # Configuration de l'API
+    api_prefix: str = Field(default="/api/v1", env="API_PREFIX")
+    cors_origins: list = Field(default=["*"], env="CORS_ORIGINS")
+    cors_allow_credentials: bool = Field(default=True, env="CORS_ALLOW_CREDENTIALS")
+    cors_allow_methods: list = Field(default=["GET"], env="CORS_ALLOW_METHODS")
+    cors_allow_headers: list = Field(default=["*"], env="CORS_ALLOW_HEADERS")
+
+    # Configuration du logging
+    log_level: str = Field(default="INFO", env="LOG_LEVEL")
+    log_format: str = Field(
+        default="%(asctime)s - %(name)s - %(levelname)s - %(message)s", env="LOG_FORMAT"
+    )
+
+    # Configuration de sécurité
+    allowed_hosts: list = Field(default=["*"], env="ALLOWED_HOSTS")
+
+    # Configuration de cache (pour extensions futures)
+    redis_url: Optional[str] = Field(None, env="REDIS_URL")
+    cache_ttl: int = Field(default=300, env="CACHE_TTL")  # 5 minutes
+
+    # Configuration de monitoring
+    enable_metrics: bool = Field(default=False, env="ENABLE_METRICS")
+    metrics_port: int = Field(default=9090, env="METRICS_PORT")
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+        extra = "ignore"  # Ignore extra fields from .env
+
+
+# Instance globale des paramètres
+settings = Settings()
+
+
+def get_settings() -> Settings:
+    """Récupère l'instance des paramètres."""
+    return settings

src/project5/database.py

@@ -0,0 +1,339 @@
+"""
+Configuration et gestion de la base de données pour l'application de prédiction énergétique.
+
+Ce module configure la connectivité à la base de données avec support adaptatif pour
+multiples environnements : PostgreSQL pour la production standard, SQLite en mémoire
+pour le déploiement HuggingFace Spaces, et SQLite fichier pour les tests.
+
+Architecture de déploiement :
+    - Production normale : PostgreSQL avec pool de connexions optimisé
+    - HuggingFace Spaces : SQLite en mémoire partagée pour contourner les limitations
+    - Tests/Développement : SQLite fichier local pour isolation
+
+Fonctionnalités principales :
+    - Configuration automatique basée sur variables d'environnement
+    - Pool de connexions PostgreSQL avec reconnexion automatique
+    - SQLite en mémoire partagée thread-safe pour HuggingFace
+    - Initialisation automatique des données en production
+    - Session management avec pattern Dependency Injection
+    - Migration et création de tables automatique
+
+Gestion des environnements :
+    Le module détecte automatiquement l'environnement via DATABASE_URL et ENVIRONMENT :
+    - ENVIRONMENT="production" + SQLite -> Mode HuggingFace Spaces
+    - DATABASE_URL PostgreSQL -> Mode production standard
+    - Autres cas -> Mode développement/test
+
+Thread Safety :
+    - PostgreSQL : Thread-safe natif avec pool de connexions
+    - SQLite en mémoire : Connexion partagée avec check_same_thread=False
+    - Sessions SQLAlchemy : Thread-safe par design
+
+Performance :
+    - PostgreSQL : Pool configuré pour 20 connexions simultanées
+    - SQLite : Connexion unique partagée pour minimiser l'empreinte mémoire
+    - Pool pre-ping activé pour éviter les connexions fermées
+
+Variables d'environnement :
+    DATABASE_URL : URL de connexion PostgreSQL ou SQLite
+    ENVIRONMENT : "production" pour activer le mode HuggingFace Spaces
+
+Exemple d'usage :
+    # Dans une route FastAPI
+    @app.get("/buildings/")
+    def get_buildings(db: Session = Depends(get_db)):
+        return db.query(Building).all()
+
+    # Initialisation manuelle
+    from project5.database import create_tables
+    create_tables()
+
+Note :
+    Le design de ce module prend en compte les contraintes spécifiques de
+    HuggingFace Spaces qui ne permet pas l'écriture sur disque persistante.
+"""
+
+import os
+import sqlite3
+import sys
+
+from dotenv import load_dotenv
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+# Charger les variables d'environnement
+load_dotenv()
+
+# URL de connexion à la base de données PostgreSQL
+# Exemple : postgresql://user:password@localhost/dbname
+DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://user:password@localhost/dbname")
+ENVIRONMENT = os.getenv("ENVIRONMENT", "dev")
+
+# Connexion SQLite partagée pour la production
+_shared_sqlite_conn = None
+
+
+def get_shared_sqlite_connection():
+    """
+    Retourne la connexion SQLite partagée en mémoire pour HuggingFace Spaces.
+
+    Cette fonction implémente un pattern Singleton pour partager une unique
+    connexion SQLite en mémoire à travers toute l'application. Elle est
+    spécifiquement conçue pour le déploiement sur HuggingFace Spaces qui
+    ne permet pas l'écriture sur disque persistante.
+
+    Returns:
+        sqlite3.Connection: Connexion SQLite en mémoire partagée et thread-safe
+
+    Side Effects:
+        - Crée la connexion globale lors du premier appel
+        - Initialise automatiquement les données si ENVIRONMENT="production"
+        - Modifie la variable globale _shared_sqlite_conn
+
+    Thread Safety:
+        Connexion configurée avec check_same_thread=False pour permettre
+        l'utilisation depuis multiple threads FastAPI.
+
+    Performance:
+        - Base de données entièrement en RAM pour performances maximales
+        - Pas d'I/O disque, idéal pour HuggingFace Spaces
+        - Initialisation une seule fois au démarrage
+
+    Example:
+        >>> conn = get_shared_sqlite_connection()
+        >>> cursor = conn.cursor()
+        >>> cursor.execute("SELECT COUNT(*) FROM buildings")
+        >>> print(cursor.fetchone()[0])
+        9895
+
+    Note:
+        Cette fonction ne doit être utilisée qu'en mode production HuggingFace.
+        Pour les autres environnements, utiliser les sessions SQLAlchemy normales.
+
+    Raises:
+        Exception: Si l'initialisation des données de production échoue
+    """
+    global _shared_sqlite_conn
+    if _shared_sqlite_conn is None:
+        _shared_sqlite_conn = sqlite3.connect(":memory:", check_same_thread=False)
+        # Initialiser les données si en production
+        if ENVIRONMENT == "production":
+            _initialize_production_data()
+    return _shared_sqlite_conn
+
+
+def _initialize_production_data():
+    """
+    Initialise les données de production dans la base SQLite en mémoire.
+
+    Cette fonction privée charge automatiquement le dataset complet de
+    9895 bâtiments de Seattle dans la base de données en mémoire lors
+    du démarrage en mode production HuggingFace Spaces.
+
+    Architecture d'initialisation :
+        1. Modification dynamique du chemin Python pour accéder à init_db
+        2. Monkey-patching de get_db_connection pour utiliser la connexion partagée
+        3. Création des tables via create_sqlite_tables()
+        4. Insertion des données via init_sqlite_data()
+
+    Side Effects:
+        - Modifie sys.path temporairement
+        - Remplace la fonction get_db_connection dans le module init_db
+        - Crée toutes les tables nécessaires
+        - Insère 9895 enregistrements de bâtiments
+        - Affiche des messages de statut
+
+    Performance :
+        - Opération d'initialisation unique au démarrage
+        - Toutes les données chargées en RAM pour accès rapide
+        - Optimisé pour le déploiement HuggingFace Spaces
+
+    Error Handling :
+        - Capture toutes les exceptions et les re-lève après logging
+        - Empêche le démarrage de l'application en cas d'échec
+        - Messages d'erreur détaillés pour debugging
+
+    Example Output:
+        ✅ Base de données SQLite en mémoire initialisée pour la production
+
+    Raises:
+        Exception: Toute erreur durant l'initialisation est propagée
+            après avoir été loggée
+
+    Note :
+        Cette fonction ne doit être appelée que depuis get_shared_sqlite_connection()
+        et uniquement en mode production.
+    """
+    try:
+        # Import des fonctions d'initialisation
+        sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", ".."))
+        # Remplacer temporairement la fonction get_db_connection
+        import init_db
+        from init_db import create_sqlite_tables, init_sqlite_data
+
+        init_db.get_db_connection = get_shared_sqlite_connection
+
+        # Créer les tables et insérer les données
+        create_sqlite_tables()
+        init_sqlite_data()
+
+        print("✅ Base de données SQLite en mémoire initialisée pour la production")
+
+    except Exception as e:
+        print(f"❌ Erreur lors de l'initialisation des données de production: {e}")
+        raise
+
+
+# Créer le moteur de base de données avec configuration adaptative
+if DATABASE_URL.startswith("sqlite"):
+    if ENVIRONMENT == "production":
+        print(
+            "🐳 Utilisation de SQLite en mémoire partagée pour la production HuggingFace"
+        )
+        # Créer un moteur qui utilise la connexion partagée
+        engine = create_engine(
+            "sqlite:///:memory:",
+            echo=False,
+            connect_args={"check_same_thread": False},
+            creator=get_shared_sqlite_connection,
+        )
+    else:
+        print("⚠️ Utilisation de SQLite pour les tests uniquement.")
+        # Configuration pour SQLite (tests)
+        engine = create_engine(
+            DATABASE_URL, echo=False, connect_args={"check_same_thread": False}
+        )
+else:
+    # Configuration pour PostgreSQL (production normale)
+    engine = create_engine(
+        DATABASE_URL,
+        pool_size=20,
+        max_overflow=0,
+        pool_pre_ping=True,
+        echo=False,  # Mettre à True pour voir les requêtes SQL
+    )
+
+# Créer la session
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Base pour nos modèles
+Base = declarative_base()
+
+
+def get_db():
+    """
+    Générateur de sessions de base de données pour injection de dépendance FastAPI.
+
+    Cette fonction implémente le pattern Dependency Injection de FastAPI pour
+    fournir des sessions de base de données aux routes. Elle garantit la fermeture
+    automatique des sessions même en cas d'exception.
+
+    Yields:
+        sqlalchemy.orm.Session: Session de base de données configurée et prête
+
+    Architecture :
+        - Pattern Generator pour gestion automatique du cycle de vie
+        - Utilise SessionLocal configuré selon l'environnement
+        - Fermeture garantie via bloc finally
+        - Compatible avec toutes les configurations (PostgreSQL/SQLite)
+
+    Usage dans FastAPI :
+        @app.get("/buildings/{building_id}")
+        def get_building(building_id: int, db: Session = Depends(get_db)):
+            return db.query(Building).filter(Building.id == building_id).first()
+
+    Thread Safety :
+        Chaque appel crée une nouvelle session isolée, garantissant
+        la thread-safety dans un environnement multi-threadé.
+
+    Performance :
+        - Sessions créées à la demande (lazy loading)
+        - Réutilisation du pool de connexions configuré
+        - Pas de connexions persistantes inutiles
+
+    Error Handling :
+        Les exceptions dans les routes n'empêchent pas la fermeture
+        de la session grâce au bloc finally.
+
+    Example:
+        # Utilisation directe (non recommandé)
+        for db in get_db():
+            buildings = db.query(Building).all()
+            break
+
+        # Utilisation recommandée avec FastAPI
+        @app.get("/predict")
+        def predict(data: PredictionRequest, db: Session = Depends(get_db)):
+            # db est automatiquement fournie et fermée
+            return prediction_service.predict(data, db)
+
+    Note :
+        Cette fonction est conçue pour être utilisée exclusivement comme
+        dépendance FastAPI. Pour un usage direct, considérer SessionLocal().
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def create_tables():
+    """
+    Crée toutes les tables dans la base de données selon les modèles définis.
+
+    Cette fonction utilise SQLAlchemy pour créer automatiquement toutes les
+    tables nécessaires à l'application basées sur les métadonnées des modèles.
+    Elle est idempotente et peut être appelée multiple fois sans effet de bord.
+
+    Architecture :
+        - Utilise Base.metadata.create_all() pour création déclarative
+        - Compatible avec toutes les configurations de base de données
+        - Respecte les contraintes et index définis dans les modèles
+        - Opération idempotente (pas d'erreur si tables existent)
+
+    Tables créées :
+        - buildings : Table principale des bâtiments avec 17 attributs
+        - Autres tables selon les modèles définis dans project5.models
+
+    Side Effects :
+        - Crée les tables physiques dans la base de données
+        - Affiche un message de confirmation
+        - Met à jour le schéma de base de données
+
+    Usage :
+        # Lors du déploiement initial
+        from project5.database import create_tables
+        create_tables()
+
+        # Dans un script d'initialisation
+        if __name__ == "__main__":
+            create_tables()
+            print("Base de données initialisée")
+
+    Compatibilité :
+        - PostgreSQL : Utilise les types natifs et contraintes
+        - SQLite : Adaptation automatique des types
+        - Tous environnements : dev, test, production
+
+    Performance :
+        - Opération rapide sur bases vides
+        - Sur bases existantes : vérification de schéma uniquement
+        - Pas de perte de données sur tables existantes
+
+    Example Output :
+        Tables created successfully!
+
+    Error Handling :
+        Les erreurs SQLAlchemy sont propagées vers l'appelant
+        pour gestion appropriée selon le contexte.
+
+    Note :
+        Cette fonction doit être appelée après l'importation des modèles
+        pour garantir que toutes les métadonnées sont disponibles.
+    """
+    from project5.models.base import Base
+
+    Base.metadata.create_all(bind=engine)
+    print("Tables created successfully!")

src/project5/main.py

@@ -0,0 +1,605 @@
+"""
+Point d'entrée principal de l'API de prédiction énergétique des bâtiments de Seattle.
+
+Ce module configure et lance l'application FastAPI complète pour la prédiction
+de consommation énergétique des bâtiments. Il inclut la gestion du cycle de vie,
+la configuration des middlewares, la gestion d'erreurs centralisée, et l'intégration
+du modèle de machine learning.
+
+Architecture de l'application:
+    - FastAPI avec OpenAPI/Swagger automatique
+    - Middleware CORS pour les appels cross-origin
+    - Gestion centralisée des exceptions avec mapping HTTP
+    - Logging structuré des requêtes et réponses
+    - Chargement automatique du modèle ML au démarrage
+    - Configuration adaptative selon l'environnement
+
+Environnements supportés:
+    - Développement: Base PostgreSQL locale, logging verbose
+    - Production: Base SQLite en mémoire (HuggingFace Spaces)
+    - Test: Base SQLite locale pour les tests
+
+Fonctionnalités principales:
+    - API REST complète pour la gestion des bâtiments et prédictions
+    - Modèle ML RandomForestRegressor pour prédictions énergétiques
+    - Authentification bearer token en production
+    - Documentation interactive Swagger/ReDoc
+    - Monitoring avec health checks
+    - Gestion d'erreurs robuste avec logging
+
+Sécurité:
+    - Authentication bearer token en environnement production
+    - Validation des données avec Pydantic
+    - Gestion sécurisée des erreurs (pas d'exposition de détails techniques)
+    - Configuration CORS appropriée
+
+Performance:
+    - Pool de connexions PostgreSQL optimisé
+    - Cache du modèle ML en mémoire
+    - Logging asynchrone pour minimiser l'impact
+    - Middleware de timing des requêtes
+
+Routes principales:
+    - /: Informations sur le service
+    - /health: Health check pour monitoring
+    - /docs: Documentation Swagger interactive
+    - /redoc: Documentation ReDoc alternative
+    - /neighborhoods/*: Gestion des quartiers de Seattle
+    - /building-models/*: Gestion des modèles de bâtiments
+    - /predictions/*: Prédictions énergétiques ML
+
+Note:
+    Configuration adaptative pour déploiement sur HuggingFace Spaces
+    avec base SQLite en mémoire et données pré-initialisées.
+"""
+
+import logging
+import os
+import time
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.openapi.utils import get_openapi
+from fastapi.responses import JSONResponse
+from sqlalchemy.exc import SQLAlchemyError
+
+from project5.config import get_settings
+from project5.database import Base, engine
+from project5.schemas import ErrorResponse, ServiceInfo
+from project5.utils.exceptions import NotFoundError, ServiceError, ValidationError
+from project5.utils.ml_model import MLModel
+from project5.utils.model_registry import get_ml_model, set_ml_model
+
+# Configuration du logging
+settings = get_settings()
+logging.basicConfig(
+    level=getattr(logging, settings.log_level.upper()), format=settings.log_format
+)
+logger = logging.getLogger(__name__)
+
+ML_MODEL_PATH = os.getenv("ML_MODEL_PATH", "../model/model.pkl")
+
+ENVIRONMENT = os.getenv("ENVIRONMENT", "dev")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Gestionnaire du cycle de vie de l'application FastAPI.
+
+    Cette fonction gère les phases de démarrage et d'arrêt de l'application,
+    incluant l'initialisation de la base de données et le chargement du modèle ML.
+
+    Phases de démarrage:
+        1. Création des tables de base de données
+        2. Chargement du modèle ML depuis le fichier
+        3. Enregistrement du modèle dans le registre global
+        4. Validation que l'application est prête
+
+    Phases d'arrêt:
+        1. Nettoyage des ressources
+        2. Logging de l'arrêt
+
+    Args:
+        app (FastAPI): Instance de l'application FastAPI
+
+    Yields:
+        None: Contrôle rendu à l'application pendant son exécution
+
+    Raises:
+        RuntimeError: Si le modèle ML ne peut pas être chargé
+        Exception: Toute erreur durant l'initialisation
+
+    Environment Variables:
+        ML_MODEL_PATH: Chemin vers le fichier du modèle (défaut: "../model/model.pkl")
+
+    Note:
+        En cas d'échec de démarrage, l'application s'arrête immédiatement
+        pour éviter un état incohérent (fail-fast pattern).
+    """
+    # Startup
+    logger.info("🚀 Démarrage de l'application project5 API")
+
+    try:
+        # Créer les tables si nécessaire
+        Base.metadata.create_all(bind=engine)
+
+        """Gestionnaire du cycle de vie de l'application"""
+        # Startup
+        model = MLModel()
+        if not model.load_model(ML_MODEL_PATH):
+            raise RuntimeError("❌ Impossible de charger le modèle")
+        # Instance globale du modèle
+        set_ml_model(model)
+        logger.info(f"✅ Setting ML Model {get_ml_model()}")
+        logger.info("🎯 Application prête à recevoir des requêtes")
+
+    except Exception as e:
+        logger.error(f"❌ Erreur lors du démarrage: {e}")
+        raise
+
+    yield
+
+    # Shutdown
+    logger.info("🛑 Arrêt de l'application")
+
+
+# Création de l'application FastAPI
+app = FastAPI(
+    title=settings.app_name,
+    description="API REST pour la gestion énergétique des bâtiments",
+    version=settings.app_version,
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json",
+    contact={
+        "name": "François Hellebuyck",
+        "email": "formation@pm.me",
+    },
+    license_info={
+        "name": "",
+    },
+)
+
+
+def custom_openapi():
+    """
+    Génère un schéma OpenAPI personnalisé avec configuration de sécurité.
+
+    Cette fonction étend le schéma OpenAPI par défaut pour ajouter :
+    - Configuration des serveurs (développement et production)
+    - Schéma d'authentification Bearer Token
+    - Application automatique de la sécurité à tous les endpoints
+
+    Returns:
+        dict: Schéma OpenAPI complet avec extensions de sécurité
+
+    Configuration des serveurs:
+        - Serveur local: http://localhost:8000 (développement)
+        - Serveur production: https://FrancoisFormation-project5.hf.space
+
+    Authentification:
+        - Type: HTTP Bearer Token
+        - Appliquée automatiquement à tous les endpoints
+        - Affichée dans l'interface Swagger pour les tests
+
+    Caching:
+        Le schéma est généré une seule fois et mis en cache
+        pour optimiser les performances.
+
+    Note:
+        Cette configuration permet l'authentification en production
+        tout en gardant une interface de test claire.
+    """
+    if app.openapi_schema:
+        return app.openapi_schema
+
+    openapi_schema = get_openapi(
+        title=app.title,
+        version=app.version,
+        description=app.description,
+        routes=app.routes,
+    )
+
+    openapi_schema["servers"] = [
+        {"url": "http://localhost:8000", "description": "Serveur de développement"},
+        {
+            "url": "https://FrancoisFormation-project5.hf.space",
+            "description": "Serveur de production",
+        },
+    ]
+
+    openapi_schema["components"]["securitySchemes"] = {
+        "BearerAuth": {"type": "http", "scheme": "bearer"}
+    }
+
+    for path, path_item in openapi_schema["paths"].items():
+        for method, operation in path_item.items():
+            if isinstance(operation, dict):
+                operation["security"] = [{"BearerAuth": []}]
+
+    app.openapi_schema = openapi_schema
+    return app.openapi_schema
+
+
+app.openapi = custom_openapi
+
+# Configuration CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=settings.cors_allow_credentials,
+    allow_methods=settings.cors_allow_methods,
+    allow_headers=settings.cors_allow_headers,
+)
+
+# Inclusion des routers
+from project5.routers import (  # Importer les routers ici
+    building_energy_prediction_routes,
+    building_model_routes,
+    building_types_routes,
+    categories_routes,
+    neighborhoods_routes,
+    prediction_routes,
+    properties_routes,
+)
+
+app.include_router(neighborhoods_routes.router)
+app.include_router(building_types_routes.router)
+app.include_router(categories_routes.router)
+app.include_router(properties_routes.router)
+app.include_router(building_energy_prediction_routes.router)
+app.include_router(building_model_routes.router)
+app.include_router(prediction_routes.router)
+
+
+# Gestionnaires d'exceptions personnalisés
+@app.exception_handler(NotFoundError)
+async def neighborhood_not_found_handler(request: Request, exc: NotFoundError):
+    """
+    Gestionnaire d'exception pour les ressources non trouvées (404).
+
+    Transforme les NotFoundError en réponses HTTP 404 structurées
+    avec logging approprié et format de réponse standardisé.
+
+    Args:
+        request (Request): Requête FastAPI avec métadonnées (URL, méthode, etc.)
+        exc (NotFoundError): Exception personnalisée avec message et code d'erreur
+
+    Returns:
+        JSONResponse: Réponse HTTP 404 avec :
+            - detail: Message d'erreur descriptif
+            - error_code: Code d'erreur standardisé
+            - path: Chemin de l'endpoint qui a échoué
+
+    Logging:
+        Log niveau WARNING avec message et chemin pour traçabilité
+
+    Example response:
+        {
+            "detail": "Bâtiment avec l'ID 999 non trouvé",
+            "error_code": "NOT_FOUND",
+            "path": "/building-models/999"
+        }
+    """
+    logger.warning(f"Entité non trouvé: {exc.message} - Path: {request.url.path}")
+    return JSONResponse(
+        status_code=404,
+        content=ErrorResponse(
+            detail=exc.message, error_code=exc.error_code, path=str(request.url.path)
+        ).dict(),
+    )
+
+
+@app.exception_handler(ValidationError)
+async def validation_error_handler(request: Request, exc: ValidationError):
+    """
+    Gestionnaire d'exception pour les erreurs de validation métier (422).
+
+    Transforme les ValidationError en réponses HTTP 422 pour indiquer
+    que les données sont syntaxiquement correctes mais violent des
+    règles métier.
+
+    Args:
+        request (Request): Requête FastAPI avec contexte
+        exc (ValidationError): Exception de validation avec détails
+
+    Returns:
+        JSONResponse: Réponse HTTP 422 avec format standardisé
+
+    Usage:
+        Utilisé pour les validations métier qui ne peuvent pas être
+        exprimées dans les schémas Pydantic (règles complexes,
+        validations cross-champs, contraintes temporelles).
+
+    Distinction HTTP:
+        - 400: Erreur de format/syntaxe
+        - 422: Erreur de validation métier
+        - 404: Ressource non trouvée
+    """
+    logger.warning(f"Erreur de validation: {exc.message} - Path: {request.url.path}")
+    return JSONResponse(
+        status_code=422,
+        content=ErrorResponse(
+            detail=exc.message, error_code=exc.error_code, path=str(request.url.path)
+        ).dict(),
+    )
+
+
+@app.exception_handler(ServiceError)
+async def service_error_handler(request: Request, exc: ServiceError):
+    """
+    Gestionnaire d'exception pour les erreurs internes de service (500).
+
+    Transforme les ServiceError en réponses HTTP 500 avec masquage
+    des détails techniques pour la sécurité.
+
+    Args:
+        request (Request): Requête FastAPI avec contexte
+        exc (ServiceError): Exception de service avec détails internes
+
+    Returns:
+        JSONResponse: Réponse HTTP 500 avec message générique
+
+    Sécurité:
+        Le message détaillé est loggé mais pas exposé au client
+        pour éviter la fuite d'informations techniques.
+
+    Logging:
+        Log niveau ERROR avec stack trace complet pour debugging.
+
+    Monitoring:
+        Ces erreurs devraient déclencher des alertes de monitoring
+        car elles indiquent des problèmes techniques internes.
+    """
+    logger.error(f"Erreur de service: {exc.message} - Path: {request.url.path}")
+    return JSONResponse(
+        status_code=500,
+        content=ErrorResponse(
+            detail="Erreur interne du service",
+            error_code=exc.error_code,
+            path=str(request.url.path),
+        ).dict(),
+    )
+
+
+@app.exception_handler(SQLAlchemyError)
+async def sqlalchemy_error_handler(request: Request, exc: SQLAlchemyError):
+    """
+    Gestionnaire d'exception pour les erreurs de base de données (503).
+
+    Transforme les erreurs SQLAlchemy en réponses HTTP 503 pour indiquer
+    une indisponibilité temporaire du service de persistance.
+
+    Args:
+        request (Request): Requête FastAPI avec contexte
+        exc (SQLAlchemyError): Exception SQLAlchemy (connexion, transaction, etc.)
+
+    Returns:
+        JSONResponse: Réponse HTTP 503 (Service Unavailable)
+
+    Rationale HTTP 503:
+        Les erreurs de base de données sont souvent temporaires
+        (surcharge, maintenance, réseau) et peuvent être résolues
+        en retentant la requête plus tard.
+
+    Sécurité:
+        Détails techniques de la base masqués pour éviter l'exposition
+        d'informations sur la structure de données.
+
+    Monitoring:
+        Ces erreurs nécessitent une attention immédiate car elles
+        peuvent indiquer des problèmes d'infrastructure critiques.
+    """
+    logger.error(f"Erreur base de données: {str(exc)} - Path: {request.url.path}")
+    return JSONResponse(
+        status_code=503,
+        content=ErrorResponse(
+            detail="Service temporairement indisponible",
+            error_code="DATABASE_ERROR",
+            path=str(request.url.path),
+        ).dict(),
+    )
+
+
+@app.exception_handler(Exception)
+async def general_exception_handler(request: Request, exc: Exception):
+    """
+    Gestionnaire d'exception catch-all pour toutes les erreurs non capturées.
+
+    Ce gestionnaire sert de filet de sécurité pour capturer toutes les
+    exceptions non prévues et éviter les crashes de l'application.
+
+    Args:
+        request (Request): Requête FastAPI avec contexte complet
+        exc (Exception): Exception Python non capturée précédemment
+
+    Returns:
+        JSONResponse: Réponse HTTP 500 générique sécurisée
+
+    Logging:
+        Log niveau ERROR avec exc_info=True pour capturer la stack trace
+        complète, essentielle pour le debugging des erreurs inattendues.
+
+    Sécurité:
+        Aucun détail technique exposé au client pour éviter la fuite
+        d'informations potentiellement sensibles.
+
+    Monitoring:
+        Ces erreurs indiquent des bugs ou des cas limites non prévus
+        et nécessitent une investigation immédiate.
+
+    Note:
+        Ce gestionnaire est appelé en dernier recours après tous
+        les gestionnaires spécifiques.
+    """
+    logger.error(
+        f"Erreur non gérée: {str(exc)} - Path: {request.url.path}", exc_info=True
+    )
+    return JSONResponse(
+        status_code=500,
+        content=ErrorResponse(
+            detail="Erreur interne du serveur",
+            error_code="INTERNAL_ERROR",
+            path=str(request.url.path),
+        ).dict(),
+    )
+
+
+# Middleware de logging des requêtes
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    """
+    Middleware pour le logging structuré de toutes les requêtes HTTP.
+
+    Ce middleware capture et log toutes les requêtes entrantes et sortantes
+    avec timing et métriques pour le monitoring et le debugging.
+
+    Args:
+        request (Request): Requête HTTP entrante avec métadonnées
+        call_next: Fonction pour passer au middleware/route suivant
+
+    Returns:
+        Response: Réponse HTTP avec headers et timing ajoutés
+
+    Métriques capturées:
+        - Méthode HTTP (GET, POST, etc.)
+        - Chemin de l'endpoint
+        - Adresse IP du client (si disponible)
+        - Code de statut de réponse
+        - Temps de traitement en secondes
+
+    Format des logs:
+        - Entrée: ➡️  GET /neighborhoods - 192.168.1.100
+        - Sortie: ⬅️  GET /neighborhoods - Status: 200 - Time: 0.045s
+
+    Performance:
+        Impact minimal grâce au logging asynchrone et à la
+        mesure de temps optimisée.
+
+    Monitoring:
+        Ces logs sont essentiels pour l'analyse des performances,
+        le debugging des problèmes, et la détection d'anomalies.
+    """
+    start_time = time.time()
+
+    # Log de la requête entrante
+    logger.info(
+        f"➡️  {request.method} {request.url.path} - {request.client.host if request.client else 'unknown'}"
+    )
+
+    response = await call_next(request)
+
+    # Log de la réponse
+    process_time = time.time() - start_time
+    logger.info(
+        f"⬅️  {request.method} {request.url.path} - "
+        f"Status: {response.status_code} - "
+        f"Time: {process_time:.3f}s"
+    )
+
+    return response
+
+
+# Routes principales
+@app.get(
+    "/",
+    response_model=ServiceInfo,
+    tags=["Info"],
+    summary="Informations du service",
+    description="Informations générales sur l'API",
+)
+async def root():
+    """
+    Endpoint racine fournissant les informations du service.
+
+    Retourne les métadonnées essentielles sur l'API pour la découverte
+    automatique des services et la documentation dynamique.
+
+    Returns:
+        ServiceInfo: Informations structurées du service contenant :
+            - name: Nom de l'application depuis la configuration
+            - version: Version actuelle de l'API
+            - description: Description fonctionnelle du service
+            - endpoints: Points d'entrée principaux de documentation
+
+    Usage:
+        - Point d'entrée pour la découverte du service
+        - Validation que l'API est opérationnelle
+        - Navigation vers la documentation interactive
+
+    Example response:
+        {
+            "name": "Project5 API",
+            "version": "1.0.0",
+            "description": "API REST pour la gestion énergétique des bâtiments",
+            "endpoints": {
+                "docs": "/docs",
+                "redoc": "/redoc"
+            }
+        }
+
+    Note:
+        Endpoint public accessible sans authentification pour faciliter
+        la découverte et les vérifications de santé automatiques.
+    """
+    service_info = ServiceInfo(
+        name=settings.app_name,
+        version=settings.app_version,
+        description="API REST pour la gestion énergétique des bâtiments",
+        endpoints={
+            "docs": "/docs",
+            "redoc": "/redoc",
+        },
+    )
+
+    return service_info
+
+
+@app.get(
+    "/health",
+    tags=["Info"],
+    summary="Vérification de l'état de santé",
+    description="Endpoint de santé pour les vérifications de disponibilité",
+)
+async def health_check():
+    """
+    Endpoint de health check pour le monitoring et l'orchestration.
+
+    Fournit un point de contrôle rapide pour vérifier que l'API
+    est opérationnelle et prête à traiter les requêtes.
+
+    Returns:
+        dict: Statut de santé avec métadonnées d'environnement :
+            - status: "healthy" si le service fonctionne
+            - environment: Environnement actuel (dev/production)
+            - authentication_required: Booléen selon l'environnement
+
+    Usage:
+        - Monitoring automatique par les systèmes d'orchestration
+        - Health checks Kubernetes/Docker
+        - Load balancer health probes
+        - Surveillance continue des services
+
+    Performance:
+        Endpoint ultra-rapide sans opération coûteuse (pas de DB/ML)
+        pour des vérifications fréquentes sans impact.
+
+    Example response:
+        {
+            "status": "healthy",
+            "environment": "production",
+            "authentication_required": true
+        }
+
+    Note:
+        Endpoint public accessible sans authentification pour permettre
+        les vérifications de santé par l'infrastructure.
+    """
+    return {
+        "status": "healthy",
+        "environment": ENVIRONMENT,
+        "authentication_required": ENVIRONMENT == "production",
+    }

src/project5/models/README.md

@@ -0,0 +1,2 @@
+poetry add --group dev sqlacodegen
+poetry run sqlacodegen postgresql://project5_user:project5_password@localhost:5432/project5_db --outfile models.py

src/project5/models/__init__.py

@@ -0,0 +1,41 @@
+"""
+Package des modèles SQLAlchemy pour l'API de prédiction énergétique.
+
+Ce package contient tous les modèles de données utilisés par l'application
+pour la gestion des bâtiments et des prédictions énergétiques.
+
+Modèles disponibles :
+- Base : Classe de base DeclarativeBase pour tous les modèles
+- Neighborhood : Quartiers de Seattle pour la géolocalisation
+- BuildingType : Types de bâtiments (résidentiel, commercial, etc.)
+- Categorie : Catégories d'usage (bureaux, logement, éducation, etc.)
+- Property : Propriétés d'usage spécifiques (office, restaurant, etc.)
+- BuildingModels : Modèle principal des bâtiments avec toutes caractéristiques
+- BuildingEnergyPredictions : Prédictions énergétiques calculées par le ML
+
+Architecture relationnelle :
+- Les bâtiments (BuildingModels) sont liés aux quartiers, types, et propriétés
+- Les propriétés appartiennent à des catégories
+- Les prédictions (BuildingEnergyPredictions) sont liées aux bâtiments
+- Tous les modèles incluent des model_id pour l'encodage ML
+"""
+
+# Import du modèle Neighborhood depuis le fichier approprié
+from .base import Base
+from .building_energy_prediction import BuildingEnergyPredictions
+from .building_models import BuildingModels
+from .building_type import BuildingType
+from .categorie import Categorie
+from .neighborhood import Neighborhood
+from .property import Property
+
+# Exposer les modèles au niveau du package
+__all__ = [
+    "Base",
+    "Neighborhood",
+    "BuildingType",
+    "Categorie",
+    "Property",
+    "BuildingModels",
+    "BuildingEnergyPredictions",
+]

src/project5/models/base.py

@@ -0,0 +1,26 @@
+"""
+Base SQLAlchemy pour tous les modèles de données.
+
+Ce module définit la classe de base DeclarativeBase utilisée par tous
+les modèles SQLAlchemy de l'application de prédiction énergétique.
+"""
+
+from sqlalchemy.orm import DeclarativeBase, registry
+
+mapper_registry = registry()
+
+
+class Base(DeclarativeBase):
+    """
+    Classe de base DeclarativeBase pour tous les modèles SQLAlchemy.
+
+    Cette classe sert de base à tous les modèles de données de l'application.
+    Elle utilise le registre SQLAlchemy pour gérer les mappings entre
+    les classes Python et les tables de base de données.
+
+    Note:
+        Tous les modèles (Neighborhood, BuildingType, Property, etc.)
+        héritent de cette classe pour bénéficier de la fonctionnalité ORM.
+    """
+
+    registry = mapper_registry

src/project5/models/building_energy_prediction.py

@@ -0,0 +1,88 @@
+"""
+Modèle SQLAlchemy pour les prédictions énergétiques des bâtiments.
+
+Ce module définit le modèle de données pour stocker les prédictions de consommation
+énergétique calculées par le modèle de machine learning.
+"""
+
+import datetime
+import decimal
+from typing import Optional
+
+from sqlalchemy import (
+    Boolean,
+    DateTime,
+    ForeignKeyConstraint,
+    Index,
+    Integer,
+    Numeric,
+    PrimaryKeyConstraint,
+    UniqueConstraint,
+    text,
+)
+from sqlalchemy.orm import Mapped, mapped_column  # TODO: ,relationship
+
+from .base import Base
+
+
+class BuildingEnergyPredictions(Base):
+    """
+    Modèle représentant une prédiction de consommation énergétique.
+
+    Cette table stocke les résultats des prédictions énergétiques calculées
+    par le modèle de machine learning pour chaque bâtiment. Elle permet de
+    conserver l'historique des prédictions et de suivre leur évolution.
+
+    Attributes:
+        id (int): Identifiant unique de la prédiction (clé primaire)
+        building_id (int): Identifiant du bâtiment concerné (clé étrangère)
+        site_energy_use_wn_kbtu (Decimal, optional): Consommation énergétique prédite en kBTU
+            avec normalisation météorologique
+        predicted (bool, optional): Indique si la valeur est prédite (True) ou mesurée (False)
+        updated_at (datetime, optional): Date et heure de la prédiction
+
+    Note:
+        La consommation est exprimée en kBTU (thousand British Thermal Units)
+        avec normalisation météorologique pour compenser les variations climatiques.
+        Le champ 'predicted' permet de distinguer les prédictions ML des mesures réelles.
+    """
+
+    __tablename__ = "building_energy_predictions"
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["building_id"],
+            ["building_models.id"],
+            name="fk_building_energy_predictions",
+        ),
+        PrimaryKeyConstraint("id", name="building_energy_predictions_pkey"),
+        UniqueConstraint(
+            "building_id", name="building_energy_predictions_building_id_key"
+        ),
+        Index("idx_building_energy_predictions_building_id", "building_id"),
+        {"comment": "Table des prédictions de consommation énergétique des bâtiments"},
+    )
+
+    id: Mapped[int] = mapped_column(
+        Integer,
+        primary_key=True,
+        comment="Identifiant unique de la prédiction (clé primaire auto-incrémentée)",
+    )
+    building_id: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        comment="Identifiant du bâtiment concerné (clé étrangère vers buildings.id)",
+    )
+    site_energy_use_wn_kbtu: Mapped[Optional[decimal.Decimal]] = mapped_column(
+        Numeric(15, 2),
+        comment="Consommation énergétique du site en kBTU avec normalisation météorologique (15 chiffres, 2 décimales)",
+    )
+    predicted: Mapped[Optional[bool]] = mapped_column(
+        Boolean,
+        server_default=text("true"),
+        comment="Indique si la valeur est prédite (TRUE) ou mesurée (FALSE)",
+    )
+    updated_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime(True),
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de la prédiction avec fuseau horaire",
+    )

src/project5/models/building_models.py

@@ -0,0 +1,261 @@
+"""
+Modèle SQLAlchemy principal pour les bâtiments.
+
+Ce module définit le modèle de données central pour les bâtiments avec toutes
+leurs caractéristiques utilisées pour les prédictions énergétiques.
+"""
+
+import datetime
+import decimal
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import (
+    CheckConstraint,
+    DateTime,
+    ForeignKeyConstraint,
+    Index,
+    Integer,
+    Numeric,
+    PrimaryKeyConstraint,
+    String,
+    Text,
+    UniqueConstraint,
+    text,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from .base import Base
+
+# from project5.models import BuildingType, Neighborhood, Property
+# Import seulement pour le type checking
+if TYPE_CHECKING:
+    from .building_type import BuildingType
+    from .neighborhood import Neighborhood
+    from .property import Property
+
+
+class BuildingModels(Base):
+    """
+    Modèle principal représentant un bâtiment avec toutes ses caractéristiques.
+
+    Cette table centrale contient toutes les informations d'un bâtiment nécessaires
+    pour les prédictions énergétiques : localisation, caractéristiques physiques,
+    types d'énergie utilisés, et références vers les tables de classification.
+
+    Attributes:
+        id (int): Identifiant unique du bâtiment (clé primaire)
+        ose_building_id (int): Identifiant OSE (Office of Sustainability & Environment)
+        address (str): Adresse complète du bâtiment
+        city (str, optional): Ville (généralement Seattle)
+        state (str, optional): État (généralement WA)
+        zip_code (str, optional): Code postal
+        tax_parcel_identification_number (str, optional): Numéro de parcelle fiscale
+        council_district_code (str, optional): Code du district municipal
+        latitude (Decimal, optional): Latitude GPS (-90 à 90)
+        longitude (Decimal, optional): Longitude GPS (-180 à 180)
+        year_built (int, optional): Année de construction
+        number_of_buildings (int, optional): Nombre de bâtiments sur la propriété
+        number_of_floors (int, optional): Nombre d'étages
+        property_gfa_total (Decimal, optional): Surface brute totale en pieds carrés
+        property_gfa_parking (Decimal, optional): Surface de parking en pieds carrés
+        second_largest_property_use_type_gfa (Decimal, optional): Surface du 2e usage
+        third_largest_property_use_type_gfa (Decimal, optional): Surface du 3e usage
+        multiusage (bool, optional): Indique si le bâtiment a plusieurs usages
+        steam (bool, optional): Utilise la vapeur comme source d'énergie
+        electricity (bool, optional): Utilise l'électricité
+        natural_gas (bool, optional): Utilise le gaz naturel
+        neighborhood_id (int, optional): Identifiant du quartier (clé étrangère)
+        building_type_id (int, optional): Identifiant du type de bâtiment (clé étrangère)
+        largest_property_use_type_id (int, optional): Usage principal (clé étrangère)
+        primary_property_type_id (int, optional): Type principal (clé étrangère)
+        second_largest_property_use_type_id (int, optional): Usage secondaire (clé étrangère)
+        third_largest_property_use_type_id (int, optional): Usage tertiaire (clé étrangère)
+        created_at (datetime): Date de création
+        updated_at (datetime): Date de modification
+
+    Relations:
+        neighborhood: Quartier associé
+        building_type: Type de bâtiment associé
+        largest_property_use_type: Usage principal
+        primary_property_type: Type principal
+        second_largest_property_use_type: Usage secondaire
+        third_largest_property_use_type: Usage tertiaire
+
+    Note:
+        Ce modèle est au centre du système de prédiction énergétique.
+        Toutes les caractéristiques sont utilisées par le modèle ML pour
+        calculer la consommation énergétique prédite.
+    """
+
+    __tablename__ = "building_models"
+    __table_args__ = (
+        CheckConstraint(
+            "latitude IS NULL AND longitude IS NULL OR latitude >= '-90'::integer::numeric AND latitude <= 90::numeric AND longitude >= '-180'::integer::numeric AND longitude <= 180::numeric",
+            name="valid_coordinates",
+        ),
+        ForeignKeyConstraint(
+            ["building_type_id"], ["building_type.id"], name="fk_building_type"
+        ),
+        ForeignKeyConstraint(
+            ["largest_property_use_type_id"],
+            ["property.id"],
+            name="fk_largest_property_use_type_id",
+        ),
+        ForeignKeyConstraint(
+            ["neighborhood_id"], ["neighborhood.id"], name="fk_neighborhood"
+        ),
+        ForeignKeyConstraint(
+            ["primary_property_type_id"],
+            ["property.id"],
+            name="fk_primary_property_type",
+        ),
+        ForeignKeyConstraint(
+            ["second_largest_property_use_type_id"],
+            ["property.id"],
+            name="fk_second_property_type",
+        ),
+        ForeignKeyConstraint(
+            ["third_largest_property_use_type_id"],
+            ["property.id"],
+            name="fk_third_property_type",
+        ),
+        PrimaryKeyConstraint("id", name="building_models_pkey"),
+        UniqueConstraint("ose_building_id", name="building_models_ose_building_id_key"),
+        Index("idx_building_models_building_type_id", "building_type_id"),
+        Index("idx_building_models_neighborhood_id", "neighborhood_id"),
+        Index(
+            "idx_building_models_primary_property_type_id", "primary_property_type_id"
+        ),
+        Index(
+            "idx_building_models_second_property_use_type_id",
+            "second_largest_property_use_type_id",
+        ),
+        Index(
+            "idx_building_models_third_property_use_type_id",
+            "third_largest_property_use_type_id",
+        ),
+        Index("idx_largest_property_use_type_id", "largest_property_use_type_id"),
+        {
+            "comment": "Table contenant les données des modèles de bâtiments avec "
+            "informations énergétiques et structurelles"
+        },
+    )
+
+    id: Mapped[int] = mapped_column(
+        Integer,
+        primary_key=True,
+        comment="Identifiant du bâtiment concerné (clé étrangère vers buildings.id)",
+    )
+    ose_building_id: Mapped[str] = mapped_column(
+        String(50),
+        nullable=False,
+        comment="Identifiant unique du bâtiment dans le système OSE",
+    )
+    address: Mapped[Optional[str]] = mapped_column(Text, comment="Adresse du bâtiment")
+    city: Mapped[Optional[str]] = mapped_column(
+        String(100),
+        server_default=text("'Seattle'::character varying"),
+        comment="Ville",
+    )
+    state: Mapped[Optional[str]] = mapped_column(
+        String(10), server_default=text("'WA'::character varying"), comment="État"
+    )
+    zip_code: Mapped[Optional[str]] = mapped_column(String(20), comment="Code postal")
+    tax_parcel_identification_number: Mapped[Optional[str]] = mapped_column(
+        String(100), comment="Numéro d'identification fiscale de la parcelle"
+    )
+    council_district_code: Mapped[Optional[str]] = mapped_column(String(20))
+    latitude: Mapped[Optional[decimal.Decimal]] = mapped_column(
+        Numeric(10, 8), comment="Latitude géographique"
+    )
+    longitude: Mapped[Optional[decimal.Decimal]] = mapped_column(
+        Numeric(11, 8), comment="Longitude géographique"
+    )
+    year_built: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Année de construction du bâtiment"
+    )
+    number_of_buildings: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Nombre de bâtiments"
+    )
+    number_of_floors: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Nombre d'étages"
+    )
+    property_gfa_total: Mapped[Optional[decimal.Decimal]] = mapped_column(
+        Numeric(12, 2), comment="Surface brute totale (GFA) en pieds carrés"
+    )
+    property_gfa_parking: Mapped[Optional[decimal.Decimal]] = mapped_column(
+        Numeric(12, 2), comment="Surface brute de parking en pieds carrés"
+    )
+    second_largest_property_use_type_gfa: Mapped[Optional[decimal.Decimal]] = (
+        mapped_column(
+            Numeric(12, 2), comment="Surface GFA du deuxième type d'usage principal"
+        )
+    )
+    third_largest_property_use_type_gfa: Mapped[Optional[decimal.Decimal]] = (
+        mapped_column(
+            Numeric(12, 2), comment="Surface GFA du troisième type d'usage principal"
+        )
+    )
+    multiusage: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Indicateur si le bâtiment a plusieurs usages"
+    )
+    steam: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Indicateur d'utilisation de vapeur"
+    )
+    electricity: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Indicateur d'utilisation d'électricité"
+    )
+    natural_gas: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Indicateur d'utilisation de gaz naturel"
+    )
+    neighborhood_id: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Identifiant du quartier"
+    )
+    building_type_id: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="Identifiant du type de bâtiment"
+    )
+    largest_property_use_type_id: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="ID du type d'usage principal le plus important"
+    )
+    primary_property_type_id: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="ID du type de propriété principal"
+    )
+    second_largest_property_use_type_id: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="ID du deuxième type d'usage principal"
+    )
+    third_largest_property_use_type_id: Mapped[Optional[int]] = mapped_column(
+        Integer, comment="ID du troisième type d'usage principal"
+    )
+    created_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime, server_default=text("CURRENT_TIMESTAMP")
+    )
+    updated_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime, server_default=text("CURRENT_TIMESTAMP")
+    )
+
+    building_type: Mapped[Optional["BuildingType"]] = relationship(
+        "BuildingType", back_populates="building_models"
+    )
+    largest_property_use_type: Mapped[Optional["Property"]] = relationship(
+        "Property",
+        foreign_keys=[largest_property_use_type_id],
+        back_populates="building_models",
+    )
+    neighborhood: Mapped[Optional["Neighborhood"]] = relationship(
+        "Neighborhood", back_populates="building_models"
+    )
+    primary_property_type: Mapped[Optional["Property"]] = relationship(
+        "Property",
+        foreign_keys=[primary_property_type_id],
+        back_populates="building_models_",
+    )
+    second_largest_property_use_type: Mapped[Optional["Property"]] = relationship(
+        "Property",
+        foreign_keys=[second_largest_property_use_type_id],
+        back_populates="building_models1",
+    )
+    third_largest_property_use_type: Mapped[Optional["Property"]] = relationship(
+        "Property",
+        foreign_keys=[third_largest_property_use_type_id],
+        back_populates="building_models2",
+    )

src/project5/models/building_type.py

@@ -0,0 +1,95 @@
+"""
+Modèle SQLAlchemy pour les types de bâtiments.
+
+Ce module définit le modèle de données pour les types de bâtiments utilisés
+dans la classification des constructions pour les prédictions énergétiques.
+"""
+
+import datetime
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import (
+    DateTime,
+    Integer,
+    PrimaryKeyConstraint,
+    String,
+    Text,
+    UniqueConstraint,
+    text,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+if TYPE_CHECKING:
+    from .building_models import BuildingModels
+
+from .base import Base
+
+
+class BuildingType(Base):
+    """
+    Modèle représentant un type de bâtiment.
+
+    Les types de bâtiments sont utilisés pour catégoriser les constructions
+    selon leur structure et usage général (résidentiel, commercial, industriel, etc.).
+    Ils sont essentiels pour les prédictions énergétiques car ils déterminent
+    les caractéristiques de consommation typiques.
+
+    Attributes:
+        id (int): Identifiant unique du type de bâtiment (clé primaire)
+        model_id (int): Identifiant utilisé par le modèle ML pour l'encodage
+        building_type_name (str): Nom du type (CAMPUS, NONRESIDENTIAL, etc.)
+        description (str, optional): Description détaillée du type
+        created_at (datetime): Date de création de l'enregistrement
+        updated_at (datetime): Date de dernière modification
+        building_models (list[BuildingModels]): Bâtiments de ce type
+
+    Note:
+        Le model_id est utilisé par le modèle de machine learning pour encoder
+        numériquement le type de bâtiment lors des prédictions énergétiques.
+    """
+
+    __tablename__ = "building_type"
+    __table_args__ = (
+        PrimaryKeyConstraint("id", name="building_type_pkey"),
+        UniqueConstraint(
+            "building_type_name", name="building_type_building_type_name_key"
+        ),
+        UniqueConstraint("model_id", name="building_type_model_id_key"),
+        {
+            "comment": "Table de référence des types de bâtiments pour la classification "
+            "des constructions"
+        },
+    )
+
+    id: Mapped[int] = mapped_column(
+        Integer,
+        primary_key=True,
+        comment="Identifiant unique du type de bâtiment (clé primaire auto-incrémentée)",
+    )
+    model_id: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        comment="Identifiant au modèle associé (clé unique, obligatoire)",
+    )
+    building_type_name: Mapped[str] = mapped_column(
+        String(100),
+        nullable=False,
+        comment="Nom du type de bâtiment (unique, obligatoire, max 100 caractères)",
+    )
+    description: Mapped[Optional[str]] = mapped_column(
+        Text, comment="Description détaillée du type de bâtiment (optionnel)"
+    )
+    created_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime,
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de création de l'enregistrement",
+    )
+    updated_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime,
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de maj de l'enregistrement",
+    )
+
+    building_models: Mapped[list["BuildingModels"]] = relationship(
+        "BuildingModels", back_populates="building_type"
+    )

src/project5/models/categorie.py

@@ -0,0 +1,84 @@
+"""
+Modèle SQLAlchemy pour les catégories de propriétés.
+
+Ce module définit le modèle de données pour les catégories d'usage des bâtiments
+utilisées dans la classification pour les prédictions énergétiques.
+"""
+
+import datetime
+from typing import Optional
+
+from sqlalchemy import (
+    DateTime,
+    Integer,
+    PrimaryKeyConstraint,
+    String,
+    Text,
+    UniqueConstraint,
+    text,
+)
+from sqlalchemy.orm import Mapped, mapped_column  # TODO:, relationship
+
+from .base import Base
+
+
+class Categorie(Base):
+    """
+    Modèle représentant une catégorie d'usage de propriété.
+
+    Les catégories regroupent les différents usages des bâtiments par domaine
+    d'activité (résidentiel, commercial, bureaux, éducation, santé, etc.).
+    Elles servent à classifier les propriétés pour les prédictions énergétiques.
+
+    Attributes:
+        id (int): Identifiant unique de la catégorie (clé primaire)
+        category_code (str): Code court de la catégorie (OFFICE, RESIDENTIAL, etc.)
+        category_name (str): Nom complet en français (Bureaux, Résidentiel, etc.)
+        description (str, optional): Description détaillée de la catégorie
+        created_at (datetime): Date de création de l'enregistrement
+        updated_at (datetime): Date de dernière modification
+
+    Note:
+        Les catégories sont liées aux propriétés (Property) qui sont plus
+        granulaires et utilisées directement par le modèle ML.
+    """
+
+    __tablename__ = "categories"
+    __table_args__ = (
+        PrimaryKeyConstraint("id", name="categories_pkey"),
+        UniqueConstraint("category_code", name="categories_category_code_key"),
+        {"comment": "Table de référence des catégories de bâtiments"},
+    )
+
+    id: Mapped[int] = mapped_column(
+        Integer,
+        primary_key=True,
+        comment="Identifiant unique de la catégorie (clé primaire auto-incrémentée)",
+    )
+    category_code: Mapped[str] = mapped_column(
+        String(50),
+        nullable=False,
+        comment="Code unique de la catégorie (identifiant court, max 50 caractères)",
+    )
+    category_name: Mapped[str] = mapped_column(
+        String(100),
+        nullable=False,
+        comment="Nom complet de la catégorie (obligatoire, max 100 caractères)",
+    )
+    description: Mapped[Optional[str]] = mapped_column(
+        Text, comment="Description détaillée de la catégorie (optionnel)"
+    )
+    created_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime,
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de création de l'enregistrement",
+    )
+    updated_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime,
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de maj de l'enregistrement",
+    )
+
+    # TODO: property: Mapped[list["Property"]] = relationship(
+    #     "Property", back_populates="category"
+    # )

src/project5/models/neighborhood.py

@@ -0,0 +1,90 @@
+"""
+Modèle SQLAlchemy pour les quartiers de Seattle.
+
+Ce module définit le modèle de données pour les quartiers (neighborhoods) utilisés
+dans la classification géographique des bâtiments pour les prédictions énergétiques.
+"""
+
+import datetime
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import (
+    DateTime,
+    Integer,
+    PrimaryKeyConstraint,
+    String,
+    UniqueConstraint,
+    text,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+if TYPE_CHECKING:
+    from .building_models import BuildingModels
+
+from .base import Base
+
+
+class Neighborhood(Base):
+    """
+    Modèle représentant un quartier de Seattle.
+
+    Les quartiers sont utilisés pour la géolocalisation et la classification
+    géographique des bâtiments. Ils influencent les prédictions énergétiques
+    car différents quartiers ont des caractéristiques climatiques et urbaines
+    distinctes.
+
+    Attributes:
+        id (int): Identifiant unique du quartier (clé primaire)
+        neighborhood_name (str): Nom du quartier (BALLARD, DOWNTOWN, etc.)
+        model_id (int): Identifiant utilisé par le modèle ML pour l'encodage
+        created_at (datetime): Date de création de l'enregistrement
+        updated_at (datetime): Date de dernière modification
+        building_models (list[BuildingModels]): Bâtiments associés à ce quartier
+
+    Note:
+        Le model_id est utilisé par le modèle de machine learning pour encoder
+        numériquement le quartier lors des prédictions énergétiques.
+    """
+
+    __tablename__ = "neighborhood"
+    __table_args__ = (
+        PrimaryKeyConstraint("id", name="neighborhood_pkey"),
+        UniqueConstraint("model_id", name="neighborhood_model_id_key"),
+        UniqueConstraint(
+            "neighborhood_name", name="neighborhood_neighborhood_name_key"
+        ),
+        {
+            "comment": "Table des quartiers/arrondissements pour la classification "
+            "géographique des bâtiments"
+        },
+    )
+
+    id: Mapped[int] = mapped_column(
+        Integer,
+        primary_key=True,
+        comment="Identifiant unique du quartier (clé primaire auto-incrémentée)",
+    )
+    neighborhood_name: Mapped[str] = mapped_column(
+        String(50),
+        nullable=False,
+        comment="Nom du quartier (unique, obligatoire, max 50 caractères)",
+    )
+    model_id: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        comment="Identifiant au modèle associé (clé unique, obligatoire)",
+    )
+    created_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime,
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de création de l'enregistrement",
+    )
+    updated_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime,
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de maj de l'enregistrement",
+    )
+
+    building_models: Mapped[list["BuildingModels"]] = relationship(
+        "BuildingModels", back_populates="neighborhood"
+    )

src/project5/models/property.py

@@ -0,0 +1,119 @@
+"""
+Modèle SQLAlchemy pour les propriétés d'usage des bâtiments.
+
+Ce module définit le modèle de données pour les propriétés d'usage spécifiques
+des bâtiments, utilisées pour une classification fine dans les prédictions énergétiques.
+"""
+
+import datetime
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import (
+    DateTime,
+    ForeignKeyConstraint,
+    Index,
+    Integer,
+    PrimaryKeyConstraint,
+    String,
+    UniqueConstraint,
+    text,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+if TYPE_CHECKING:
+    from .building_models import BuildingModels
+
+from .base import Base
+
+
+class Property(Base):
+    """
+    Modèle représentant une propriété d'usage spécifique d'un bâtiment.
+
+    Les propriétés sont plus granulaires que les catégories et permettent
+    une classification fine des usages (OFFICE, RETAIL STORE, RESTAURANT, etc.).
+    Elles sont directement utilisées par le modèle ML pour les prédictions
+    énergétiques car différents usages ont des profils de consommation distincts.
+
+    Attributes:
+        id (int): Identifiant unique de la propriété (clé primaire)
+        model_id (int): Identifiant utilisé par le modèle ML pour l'encodage
+        property_name (str): Nom de la propriété (OFFICE, RESTAURANT, etc.)
+        category_id (int): Identifiant de la catégorie parent (clé étrangère)
+        created_at (datetime): Date de création de l'enregistrement
+        updated_at (datetime): Date de dernière modification
+        building_models (list[BuildingModels]): Bâtiments avec cette propriété principale
+        building_models_ (list[BuildingModels]): Bâtiments avec cette propriété primaire
+        building_models1 (list[BuildingModels]): Bâtiments avec cette propriété secondaire
+        building_models2 (list[BuildingModels]): Bâtiments avec cette propriété tertiaire
+
+    Note:
+        Le model_id est utilisé directement par le modèle de machine learning
+        pour encoder numériquement l'usage lors des prédictions énergétiques.
+        Les relations multiples permettent de gérer les bâtiments multi-usages.
+    """
+
+    __tablename__ = "property"
+    __table_args__ = (
+        ForeignKeyConstraint(
+            ["category_id"], ["categories.id"], name="fk_property_category"
+        ),
+        PrimaryKeyConstraint("id", name="property_pkey"),
+        UniqueConstraint("model_id", name="property_model_id_key"),
+        UniqueConstraint("property_name", name="property_property_name_key"),
+        Index("idx_property_category", "category_id"),
+        {"comment": "Table des propriétés/bâtiments avec leur catégorie associée"},
+    )
+
+    id: Mapped[int] = mapped_column(
+        Integer,
+        primary_key=True,
+        comment="Identifiant unique de la propriété (clé primaire auto-incrémentée)",
+    )
+    model_id: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        comment="Identifiant au modèle associé (clé unique, obligatoire)",
+    )
+    property_name: Mapped[str] = mapped_column(
+        String(150),
+        nullable=False,
+        comment="Nom de la propriété (unique, obligatoire, max 150 caractères)",
+    )
+    category_id: Mapped[int] = mapped_column(
+        Integer,
+        nullable=False,
+        comment="Identifiant de la catégorie associée (clé étrangère vers categories.id)",
+    )
+    created_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime,
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de création de l'enregistrement",
+    )
+    updated_at: Mapped[Optional[datetime.datetime]] = mapped_column(
+        DateTime,
+        server_default=text("CURRENT_TIMESTAMP"),
+        comment="Date et heure de maj de l'enregistrement",
+    )
+
+    # category: Mapped['Categories'] = relationship('Categories', back_populates='property')
+    building_models: Mapped[list["BuildingModels"]] = relationship(
+        "BuildingModels",
+        foreign_keys="[BuildingModels.largest_property_use_type_id]",
+        back_populates="largest_property_use_type",
+    )
+    building_models_: Mapped[list["BuildingModels"]] = relationship(
+        "BuildingModels",
+        foreign_keys="[BuildingModels.primary_property_type_id]",
+        back_populates="primary_property_type",
+    )
+    building_models1: Mapped[list["BuildingModels"]] = relationship(
+        "BuildingModels",
+        foreign_keys="[BuildingModels.second_largest_property_use_type_id]",
+        back_populates="second_largest_property_use_type",
+    )
+    building_models2: Mapped[list["BuildingModels"]] = relationship(
+        "BuildingModels",
+        foreign_keys="[BuildingModels.third_largest_property_use_type_id]",
+        back_populates="third_largest_property_use_type",
+    )

src/project5/routers/building_energy_prediction_routes.py

@@ -0,0 +1,334 @@
+"""
+Routes API pour la gestion des prédictions énergétiques des bâtiments.
+
+Ce module contient les endpoints FastAPI pour :
+- Récupération de la liste des prédictions énergétiques avec pagination
+- Récupération d'une prédiction spécifique par ID
+- Gestion des erreurs et logging approprié
+
+Endpoints disponibles :
+- GET /api/v1/predictions/ : Liste paginée des prédictions
+- GET /api/v1/predictions/{id} : Prédiction spécifique par ID
+- POST /api/v1/predictions/building/{building_id} : Effectuer une prédiction pour un bâtiment et la sauvegarder
+
+Auteur: François Hellebuyck
+Projet: Building Energy Prediction API - OpenClassrooms Projet 5
+"""
+
+import logging
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
+from sqlalchemy.orm import Session
+
+from project5.database import get_db
+from project5.schemas.building_energy_prediction import (
+    BuildingEnergyPredictionsList,
+    BuildingEnergyPredictionsResponse,
+)
+from project5.schemas.building_model import PredictionResponse
+from project5.services.building_ensergy_prediction_service import (
+    BuildingEnergyPredictionService,
+)
+from project5.services.building_model_service import (
+    BuildingModelsService,
+    PredictionService,
+)
+from project5.utils.exceptions import NotFoundError
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v1/predictions", tags=["predictions"])
+
+
+@router.get(
+    "/",
+    response_model=List[BuildingEnergyPredictionsList],
+    summary="Récupérer toutes les prédictions énergétiques des bâtiments",
+    description="""
+    Retourne la liste paginée de toutes les prédictions énergétiques des bâtiments.
+
+    Cette endpoint permet de récupérer l'ensemble des prédictions de consommation
+    énergétique calculées par le modèle de machine learning. Les résultats incluent
+    les données du bâtiment associé et la valeur prédite.
+
+    Paramètres de pagination :
+    - skip : nombre d'enregistrements à ignorer (par défaut 0)
+    - limit : nombre maximum d'enregistrements à retourner (par défaut 100, max 1000)
+    """,
+    responses={
+        200: {
+            "description": "Liste des prédictions récupérée avec succès",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "id": 1,
+                            "building_id": 123,
+                            "site_energy_use_kbtu": 45678.9,
+                            "predicted": True,
+                            "updated_at": "2025-09-17T10:30:00Z",
+                        }
+                    ]
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_predictions(
+    skip: int = Query(0, ge=0, description="Nombre d'éléments à ignorer (pagination)"),
+    limit: int = Query(
+        100, ge=1, le=1000, description="Nombre maximum d'éléments à retourner"
+    ),
+    db: Session = Depends(get_db),
+):
+    """
+    Récupère la liste paginée des prédictions énergétiques des bâtiments.
+
+    Args:
+        skip (int): Nombre d'enregistrements à ignorer pour la pagination
+        limit (int): Nombre maximum d'enregistrements à retourner
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        JSONResponse: Liste des prédictions énergétiques au format JSON
+
+    Raises:
+        HTTPException: Erreur 500 si problème lors de la récupération des données
+
+    Example:
+        GET /api/v1/predictions/?skip=0&limit=50
+    """
+    try:
+        predictions = BuildingEnergyPredictionService.get_all(
+            db=db, skip=skip, limit=limit
+        )
+        return JSONResponse(jsonable_encoder(predictions))
+    except Exception as e:
+        logger.error(
+            f"Erreur lors de la récupération des predictions énergétiques des bâtiments: {e}"
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération des predictions énergétiques des bâtiments",
+        )
+
+
+@router.get(
+    "/{id}",
+    response_model=BuildingEnergyPredictionsResponse,
+    summary="Récupérer une prédiction énergétique par ID",
+    description="""
+    Retourne les détails d'une prédiction énergétique spécifique.
+
+    Récupère une prédiction énergétique complète avec toutes les informations
+    associées au bâtiment et aux calculs de consommation énergétique.
+
+    L'ID doit correspondre à une prédiction existante dans la base de données.
+    """,
+    responses={
+        200: {
+            "description": "Prédiction trouvée et retournée avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "id": 1,
+                        "building_id": 123,
+                        "site_energy_use_kbtu": 45678.9,
+                        "predicted": True,
+                        "updated_at": "2025-09-17T10:30:00Z",
+                        "building": {
+                            "id": 123,
+                            "address": "123 Main St",
+                            "neighborhood": "Downtown",
+                            "building_type": "Office",
+                        },
+                    }
+                }
+            },
+        },
+        404: {
+            "description": "Prédiction non trouvée",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "Prédiction avec l'ID 999 non trouvée"}
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_prediction(id: int, db: Session = Depends(get_db)):
+    """
+    Récupère une prédiction énergétique spécifique par son ID.
+
+    Args:
+        id (int): Identifiant unique de la prédiction à récupérer
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        BuildingEnergyPredictionsResponse: Prédiction énergétique avec détails complets
+
+    Raises:
+        HTTPException:
+            - 404 si la prédiction n'existe pas
+            - 500 si erreur lors de la récupération
+
+    Example:
+        GET /api/v1/predictions/123
+    """
+    try:
+        pred = BuildingEnergyPredictionService.get_by_id(db=db, prediction_id=id)
+        return pred
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération de la prediction: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération de la prediction",
+        )
+
+
+@router.post(
+    "/building/{building_id}",
+    response_model=PredictionResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Effectuer une prédiction pour un bâtiment spécifique",
+    description="""
+    Effectue une prédiction énergétique pour un bâtiment spécifique et sauvegarde automatiquement le résultat.
+
+    Cette endpoint :
+    1. Récupère les données du bâtiment spécifié
+    2. Effectue une prédiction énergétique avec le modèle ML
+    3. Sauvegarde automatiquement le résultat dans building_energy_predictions avec predicted=True
+    4. Retourne la prédiction avec intervalle de confiance
+
+    Le bâtiment doit exister et avoir toutes les données nécessaires pour les prédictions ML.
+    """,
+    responses={
+        201: {
+            "description": "Prédiction effectuée et sauvegardée avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "prediction": 65432.10,
+                        "prediction_log": 11.09,
+                        "model_version": "v1.0",
+                        "confidence_interval_log": {"lower": 10.85, "upper": 11.33},
+                    }
+                }
+            },
+        },
+        404: {
+            "description": "Bâtiment non trouvé",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "Bâtiment avec l'ID 999 non trouvé"}
+                }
+            },
+        },
+        422: {
+            "description": "Données du bâtiment insuffisantes pour la prédiction",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "detail": "Le bâtiment n'a pas toutes les données nécessaires pour les prédictions ML"
+                    }
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+async def predict_for_building(building_id: int, db: Session = Depends(get_db)):
+    """
+    Effectue une prédiction énergétique pour un bâtiment spécifique et la sauvegarde.
+
+    Args:
+        building_id (int): Identifiant unique du bâtiment
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        PredictionResponse: Prédiction avec consommation énergétique et intervalle de confiance
+
+    Raises:
+        HTTPException:
+            - 404 si le bâtiment n'existe pas
+            - 422 si les données du bâtiment sont insuffisantes
+            - 500 si erreur lors de la prédiction ou sauvegarde
+
+    Example:
+        POST /api/v1/predictions/building/123
+
+    Note:
+        La prédiction est automatiquement sauvegardée dans la table
+        building_energy_predictions avec le flag predicted=True
+    """
+    try:
+        # Récupérer les données du bâtiment pour la prédiction
+        building_data = BuildingModelsService.get_model_data_by_id(
+            db=db, building_id=building_id
+        )
+
+        # Convertir en BuildingFeatures pour la prédiction
+        from project5.schemas.building_model import convert_query_result_to_schema
+
+        model_schema = convert_query_result_to_schema(building_data)
+
+        # Créer l'objet BuildingFeatures
+        from project5.schemas.building_model import BuildingFeatures
+
+        features = BuildingFeatures(
+            year_built=model_schema.year_built,
+            number_of_buildings=model_schema.number_of_buildings,
+            number_of_floors=model_schema.number_of_floors,
+            property_gfa_total=float(model_schema.property_gfa_total),
+            property_gfa_parking=float(model_schema.property_gfa_parking),
+            second_largest_property_use_type_gfa=float(
+                model_schema.second_largest_property_use_type_gfa
+            ),
+            third_largest_property_use_type_gfa=float(
+                model_schema.third_largest_property_use_type_gfa
+            ),
+            multiusage=int(model_schema.multiusage),
+            steam=int(model_schema.steam),
+            electricity=int(model_schema.electricity),
+            natural_gas=int(model_schema.natural_gas),
+            neighborhood_id=model_schema.neighborhood_id,
+            building_type_id=model_schema.building_type_id,
+            largest_property_use_type_id=model_schema.largest_property_use_type_id,
+            primary_property_type_id=model_schema.primary_property_type_id,
+            second_largest_property_use_type_id=model_schema.second_largest_property_use_type_id,
+            third_largest_property_use_type_id=model_schema.third_largest_property_use_type_id,
+        )
+
+        # Effectuer la prédiction avec sauvegarde automatique
+        service = PredictionService()
+        result = await service.predict(features, building_id=building_id, db=db)
+
+        logger.info(
+            f"Prédiction effectuée et sauvegardée pour le bâtiment {building_id}: {result['prediction']} kBTU"
+        )
+
+        return PredictionResponse(**result)
+
+    except NotFoundError as e:
+        # Bâtiment non trouvé - retourner 404
+        logger.warning(f"Bâtiment {building_id} non trouvé: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Bâtiment avec l'ID {building_id} non trouvé",
+        )
+    except HTTPException:
+        # Propager les erreurs HTTP (404, etc.)
+        raise
+    except Exception as e:
+        logger.error(
+            f"Erreur lors de la prédiction pour le bâtiment {building_id}: {e}"
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Erreur lors de la prédiction: {str(e)}",
+        )

src/project5/routers/building_model_routes.py

@@ -0,0 +1,438 @@
+"""
+Routes API pour la gestion des modèles de bâtiments.
+
+Ce module contient les endpoints FastAPI pour :
+- Récupération de la liste des bâtiments avec pagination
+- Récupération d'un bâtiment spécifique par ID
+- Récupération des données formatées pour le modèle ML
+- Gestion des erreurs et logging approprié
+
+Endpoints disponibles :
+- GET /api/v1/buildings/ : Liste paginée des bâtiments
+- GET /api/v1/buildings/{id} : Bâtiment spécifique par ID
+- GET /api/v1/buildings/model/{id} : Données formatées pour le modèle ML
+- POST /api/v1/buildings/ : Créer un nouveau bâtiment
+
+Auteur: François Hellebuyck
+Projet: Building Energy Prediction API - OpenClassrooms Projet 5
+"""
+
+import logging
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
+from sqlalchemy.orm import Session
+
+from project5.database import get_db
+from project5.models.building_models import BuildingModels
+from project5.schemas.building_model import (
+    BuildingModelsCreate,
+    BuildingModelsList,
+    BuildingModelsResponse,
+    ModelViewSchema,
+    convert_query_result_to_schema,
+)
+from project5.services.building_model_service import BuildingModelsService
+from project5.utils.exceptions import ValidationError
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v1/buildings", tags=["buildings"])
+
+
+@router.get(
+    "/",
+    response_model=List[BuildingModelsList],
+    summary="Récupérer tous les bâtiments",
+    description="""
+    Retourne la liste paginée de tous les bâtiments enregistrés dans le système.
+
+    Cette endpoint permet de récupérer l'ensemble des bâtiments avec leurs
+    informations de base comme l'adresse, le quartier, le type de bâtiment,
+    et les caractéristiques principales utilisées pour les prédictions énergétiques.
+
+    Paramètres de pagination :
+    - skip : nombre d'enregistrements à ignorer (par défaut 0)
+    - limit : nombre maximum d'enregistrements à retourner (par défaut 100, max 1000)
+    """,
+    responses={
+        200: {
+            "description": "Liste des bâtiments récupérée avec succès",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "id": 1,
+                            "ose_building_id": 12345,
+                            "address": "123 Main St",
+                            "city": "Seattle",
+                            "neighborhood": "Downtown",
+                            "building_type": "Office",
+                            "year_built": 1995,
+                            "property_gfa_total": 50000.0,
+                        }
+                    ]
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_building_types(
+    skip: int = Query(0, ge=0, description="Nombre d'éléments à ignorer (pagination)"),
+    limit: int = Query(
+        100, ge=1, le=1000, description="Nombre maximum d'éléments à retourner"
+    ),
+    db: Session = Depends(get_db),
+):
+    """
+    Récupère la liste paginée des bâtiments.
+
+    Args:
+        skip (int): Nombre d'enregistrements à ignorer pour la pagination
+        limit (int): Nombre maximum d'enregistrements à retourner
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        JSONResponse: Liste des bâtiments au format JSON
+
+    Raises:
+        HTTPException: Erreur 500 si problème lors de la récupération des données
+
+    Example:
+        GET /api/v1/buildings/?skip=0&limit=50
+    """
+    try:
+        buildings = BuildingModelsService.get_all(db=db, skip=skip, limit=limit)
+        return JSONResponse(jsonable_encoder(buildings))
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des bâtiments: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération des bâtiments",
+        )
+
+
+@router.get(
+    "/{id}",
+    response_model=BuildingModelsResponse,
+    summary="Récupérer un bâtiment par ID",
+    description="""
+    Retourne les détails complets d'un bâtiment spécifique.
+
+    Récupère toutes les informations détaillées d'un bâtiment incluant :
+    - Informations générales (adresse, ville, quartier)
+    - Caractéristiques techniques (année de construction, nombre d'étages)
+    - Données énergétiques (types d'énergie utilisés)
+    - Relations avec les types et catégories de propriétés
+
+    L'ID doit correspondre à un bâtiment existant dans la base de données.
+    """,
+    responses={
+        200: {
+            "description": "Bâtiment trouvé et retourné avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "id": 1,
+                        "ose_building_id": 12345,
+                        "address": "123 Main St",
+                        "city": "Seattle",
+                        "state": "WA",
+                        "zip_code": "98101",
+                        "neighborhood": "Downtown",
+                        "building_type": "Office",
+                        "year_built": 1995,
+                        "number_of_buildings": 1,
+                        "number_of_floors": 15,
+                        "property_gfa_total": 50000.0,
+                        "multiusage": False,
+                        "steam": True,
+                        "electricity": True,
+                        "natural_gas": True,
+                    }
+                }
+            },
+        },
+        404: {
+            "description": "Bâtiment non trouvé",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "Bâtiment avec l'ID 999 non trouvé"}
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_building(id: int, db: Session = Depends(get_db)):
+    """
+    Récupère un bâtiment spécifique par son ID.
+
+    Args:
+        id (int): Identifiant unique du bâtiment à récupérer
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        BuildingModelsResponse: Bâtiment avec détails complets
+
+    Raises:
+        HTTPException:
+            - 404 si le bâtiment n'existe pas
+            - 500 si erreur lors de la récupération
+
+    Example:
+        GET /api/v1/buildings/123
+    """
+    try:
+        building = BuildingModelsService.get_by_id(db=db, building_id=id)
+        return building
+    except Exception as e:
+        logger.error(f"Erreur lors du bâtiment: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération du bâtiment",
+        )
+
+
+@router.get(
+    "/model/{id}",
+    response_model=ModelViewSchema,
+    summary="Récupérer les données formatées pour le modèle ML",
+    description="""
+    Retourne les données d'un bâtiment formatées spécifiquement pour le modèle de machine learning.
+
+    Cette endpoint transforme les données brutes du bâtiment en format approprié
+    pour effectuer des prédictions énergétiques avec le modèle ML. Les données
+    sont pré-traitées et encodées selon les exigences du modèle :
+
+    - Variables catégorielles encodées numériquement
+    - Variables continues normalisées si nécessaire
+    - Format de données compatible avec scikit-learn
+    - Gestion des valeurs manquantes
+
+    L'ID doit correspondre à un bâtiment existant dans la base de données.
+    """,
+    responses={
+        200: {
+            "description": "Données du modèle récupérées avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "building_id": 123,
+                        "neighborhood_encoded": 3,
+                        "building_type_encoded": 1,
+                        "largest_property_use_type_encoded": 18,
+                        "primary_property_type_encoded": 18,
+                        "year_built": 1995,
+                        "number_of_buildings": 1,
+                        "number_of_floors": 15,
+                        "property_gfa_total": 50000.0,
+                        "steam": 1,
+                        "electricity": 1,
+                        "natural_gas": 1,
+                    }
+                }
+            },
+        },
+        404: {
+            "description": "Bâtiment non trouvé",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "Bâtiment avec l'ID 999 non trouvé"}
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_model_data_by_id(id: int, db: Session = Depends(get_db)):
+    """
+    Récupère les données d'un bâtiment formatées pour le modèle ML.
+
+    Args:
+        id (int): Identifiant unique du bâtiment
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        JSONResponse: Données formatées pour le modèle ML au format JSON
+
+    Raises:
+        HTTPException:
+            - 404 si le bâtiment n'existe pas
+            - 500 si erreur lors de la récupération ou du formatage
+
+    Example:
+        GET /api/v1/buildings/model/123
+
+    Note:
+        Cette endpoint est principalement utilisée par l'endpoint de prédiction
+        pour préparer les données avant d'appeler le modèle ML.
+    """
+    try:
+        building = BuildingModelsService.get_model_data_by_id(db=db, building_id=id)
+        return JSONResponse(jsonable_encoder(convert_query_result_to_schema(building)))
+    except Exception as e:
+        logger.error(f"Erreur lors du bâtiment: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération du bâtiment",
+        )
+
+
+@router.post(
+    "/",
+    response_model=BuildingModelsResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Créer un nouveau bâtiment",
+    description="""
+    Ajoute un nouveau bâtiment dans le système.
+
+    Cette endpoint permet de créer un nouveau bâtiment avec ses caractéristiques
+    complètes. Les données sont validées avant l'insertion en base de données.
+
+    Champs obligatoires pour les prédictions ML (17 features) :
+    - ose_building_id : Identifiant unique du bâtiment OSE
+    - year_built : Année de construction
+    - number_of_buildings : Nombre de bâtiments
+    - number_of_floors : Nombre d'étages
+    - property_gfa_total : Surface totale GFA
+    - property_gfa_parking : Surface parking GFA
+    - second_largest_property_use_type_gfa : Surface 2e type d'usage
+    - third_largest_property_use_type_gfa : Surface 3e type d'usage
+    - multiusage : Indicateur multi-usage (0 ou 1)
+    - steam : Indicateur vapeur (0 ou 1)
+    - electricity : Indicateur électricité (0 ou 1)
+    - natural_gas : Indicateur gaz naturel (0 ou 1)
+    - neighborhood_id : ID du quartier
+    - building_type_id : ID du type de bâtiment
+    - largest_property_use_type_id : ID du plus grand type d'usage
+    - primary_property_type_id : ID du type de propriété principal
+    - second_largest_property_use_type_id : ID du 2e type d'usage
+    - third_largest_property_use_type_id : ID du 3e type d'usage
+
+    Validation automatique :
+    - Format et valeurs des champs
+    - Contraintes métier (années, surfaces positives)
+    - Unicité de l'identifiant OSE
+    """,
+    responses={
+        201: {
+            "description": "Bâtiment créé avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "id": 1001,
+                        "ose_building_id": "NEW12345",
+                        "address": "456 New Street",
+                        "city": "Seattle",
+                        "state": "WA",
+                        "year_built": 2020,
+                        "number_of_buildings": 1,
+                        "number_of_floors": 5,
+                        "property_gfa_total": 25000.0,
+                        "property_gfa_parking": 2000.0,
+                        "second_largest_property_use_type_gfa": 0.0,
+                        "third_largest_property_use_type_gfa": 0.0,
+                        "multiusage": 0,
+                        "steam": 0,
+                        "electricity": 1,
+                        "natural_gas": 1,
+                        "neighborhood_id": 1,
+                        "building_type_id": 1,
+                        "largest_property_use_type_id": 18,
+                        "primary_property_type_id": 18,
+                        "second_largest_property_use_type_id": 1,
+                        "third_largest_property_use_type_id": 1,
+                        "created_at": "2025-09-21T12:00:00",
+                        "updated_at": "2025-09-21T12:00:00",
+                    }
+                }
+            },
+        },
+        400: {
+            "description": "Données invalides ou manquantes",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "L'année de construction est obligatoire"}
+                }
+            },
+        },
+        422: {
+            "description": "Erreur de validation des données",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "La surface totale GFA est obligatoire"}
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def create_building(building_data: BuildingModelsCreate, db: Session = Depends(get_db)):
+    """
+    Crée un nouveau bâtiment dans le système.
+
+    Args:
+        building_data (BuildingModelsCreate): Données du bâtiment à créer
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        BuildingModelsResponse: Bâtiment créé avec son ID généré et timestamps
+
+    Raises:
+        HTTPException:
+            - 400 si les données obligatoires sont manquantes
+            - 422 si erreur de validation des données
+            - 500 si erreur lors de la création
+
+    Example:
+        POST /api/v1/buildings/
+        {
+            "ose_building_id": "NEW12345",
+            "address": "456 New Street",
+            "city": "Seattle",
+            "year_built": 2020,
+            "number_of_buildings": 1,
+            "number_of_floors": 5,
+            "property_gfa_total": 25000.0,
+            "property_gfa_parking": 2000.0,
+            "second_largest_property_use_type_gfa": 0.0,
+            "third_largest_property_use_type_gfa": 0.0,
+            "multiusage": 0,
+            "steam": 0,
+            "electricity": 1,
+            "natural_gas": 1,
+            "neighborhood_id": 1,
+            "building_type_id": 1,
+            "largest_property_use_type_id": 18,
+            "primary_property_type_id": 18,
+            "second_largest_property_use_type_id": 1,
+            "third_largest_property_use_type_id": 1
+        }
+    """
+    try:
+        # Convertir le schéma Pydantic en modèle SQLAlchemy
+        building_model = BuildingModels(**building_data.model_dump(exclude_unset=True))
+
+        # Appeler le service pour créer le bâtiment
+        created_building = BuildingModelsService.set_new_building(
+            db=db, building_model=building_model
+        )
+
+        return created_building
+
+    except ValidationError as e:
+        logger.error(f"Erreur de validation lors de la création du bâtiment: {e}")
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except ValueError as e:
+        logger.error(f"Erreur de validation lors de la création du bâtiment: {e}")
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except Exception as e:
+        logger.error(f"Erreur lors de la création du bâtiment: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la création du bâtiment",
+        )

src/project5/routers/building_types_routes.py

@@ -0,0 +1,205 @@
+"""
+Routes API pour la gestion des types de bâtiments.
+
+Ce module contient les endpoints FastAPI pour :
+- Récupération de la liste des types de bâtiments avec pagination
+- Récupération d'un type de bâtiment spécifique par ID
+- Gestion des erreurs et logging approprié
+
+Les types de bâtiments sont utilisés pour catégoriser les bâtiments selon leur
+usage principal (résidentiel, commercial, industriel, etc.) et sont essentiels
+pour les prédictions énergétiques du modèle ML.
+
+Endpoints disponibles :
+- GET /api/v1/building-types/ : Liste paginée des types de bâtiments
+- GET /api/v1/building-types/{id} : Type de bâtiment spécifique par ID
+
+Auteur: François Hellebuyck
+Projet: Building Energy Prediction API - OpenClassrooms Projet 5
+"""
+
+import logging
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.orm import Session
+
+from project5.database import get_db
+from project5.schemas.building_type import BuildingTypeList, BuildingTypeResponse
+from project5.services.building_type_service import BuildingTypeService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v1/building-types", tags=["building-types"])
+
+
+@router.get(
+    "/",
+    response_model=List[BuildingTypeList],
+    summary="Récupérer tous les types de bâtiments",
+    description="""
+    Retourne la liste paginée de tous les types de bâtiments disponibles dans le système.
+
+    Cette endpoint permet de récupérer l'ensemble des catégories de bâtiments
+    utilisées pour la classification et les prédictions énergétiques. Chaque type
+    de bâtiment correspond à un usage spécifique (résidentiel, commercial,
+    industriel, etc.) avec ses caractéristiques énergétiques propres.
+
+    Types de bâtiments disponibles :
+    - Campus building complex
+    - Non-residential building
+    - Seattle Public Schools District K-12
+    - Multifamily (Low-Rise, Mid-Rise, High-Rise)
+    - Et autres catégories spécialisées
+
+    Paramètres de pagination :
+    - skip : nombre d'enregistrements à ignorer (par défaut 0)
+    - limit : nombre maximum d'enregistrements à retourner (par défaut 100, max 1000)
+    """,
+    responses={
+        200: {
+            "description": "Liste des types de bâtiments récupérée avec succès",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "id": 1,
+                            "model_id": 0,
+                            "building_type_name": "CAMPUS",
+                            "description": "Campus building complex",
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                        {
+                            "id": 2,
+                            "model_id": 1,
+                            "building_type_name": "NONRESIDENTIAL",
+                            "description": "Non-residential building",
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                    ]
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_building_types(
+    skip: int = Query(0, ge=0, description="Nombre d'éléments à ignorer (pagination)"),
+    limit: int = Query(
+        100, ge=1, le=1000, description="Nombre maximum d'éléments à retourner"
+    ),
+    db: Session = Depends(get_db),
+):
+    """
+    Récupère la liste paginée des types de bâtiments.
+
+    Args:
+        skip (int): Nombre d'enregistrements à ignorer pour la pagination
+        limit (int): Nombre maximum d'enregistrements à retourner
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        List[BuildingTypeList]: Liste des types de bâtiments
+
+    Raises:
+        HTTPException: Erreur 500 si problème lors de la récupération des données
+
+    Example:
+        GET /api/v1/building-types/?skip=0&limit=20
+
+    Note:
+        Les types de bâtiments sont référencés par leur model_id dans le modèle ML
+        pour effectuer les prédictions énergétiques.
+    """
+    try:
+        buildingTypes = BuildingTypeService.get_all(db=db, skip=skip, limit=limit)
+        return buildingTypes
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des des types de bâtiment: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération des types de bâtiment",
+        )
+
+
+@router.get(
+    "/{building_type_id}",
+    response_model=BuildingTypeResponse,
+    summary="Récupérer un type de bâtiment par ID",
+    description="""
+    Retourne les détails complets d'un type de bâtiment spécifique.
+
+    Récupère toutes les informations d'un type de bâtiment incluant :
+    - Identifiant unique dans la base de données
+    - Identifiant utilisé par le modèle ML (model_id)
+    - Nom du type de bâtiment
+    - Description détaillée
+    - Horodatages de création et modification
+
+    Le type de bâtiment est un élément clé pour la classification et les
+    prédictions énergétiques, car il détermine les caractéristiques de
+    consommation énergétique typiques.
+
+    L'ID doit correspondre à un type de bâtiment existant dans la base de données.
+    """,
+    responses={
+        200: {
+            "description": "Type de bâtiment trouvé et retourné avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "id": 3,
+                        "model_id": 1,
+                        "building_type_name": "NONRESIDENTIAL",
+                        "description": "Non-residential building",
+                        "created_at": "2025-09-09T09:56:21Z",
+                        "updated_at": "2025-09-09T09:56:21Z",
+                    }
+                }
+            },
+        },
+        404: {
+            "description": "Type de bâtiment non trouvé",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "Type de bâtiment avec l'ID 999 non trouvé"}
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_building_type(building_type_id: int, db: Session = Depends(get_db)):
+    """
+    Récupère un type de bâtiment spécifique par son ID.
+
+    Args:
+        building_type_id (int): Identifiant unique du type de bâtiment à récupérer
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        BuildingTypeResponse: Type de bâtiment avec détails complets
+
+    Raises:
+        HTTPException:
+            - 404 si le type de bâtiment n'existe pas
+            - 500 si erreur lors de la récupération
+
+    Example:
+        GET /api/v1/building-types/3
+
+    Note:
+        Le model_id retourné est utilisé par le modèle ML pour encoder
+        le type de bâtiment lors des prédictions énergétiques.
+    """
+    try:
+        bt = BuildingTypeService.get_by_id(db=db, id=building_type_id)
+        return bt
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération du type de bâtiment: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération du type de bâtiment",
+        )

src/project5/routers/categories_routes.py

@@ -0,0 +1,221 @@
+"""
+Routes API pour la gestion des catégories de propriétés.
+
+Ce module contient les endpoints FastAPI pour :
+- Récupération de la liste des catégories de propriétés avec pagination
+- Récupération d'une catégorie spécifique par ID
+- Gestion des erreurs et logging approprié
+
+Les catégories de propriétés regroupent les différents usages des bâtiments
+(résidentiel, commercial, bureaux, éducation, santé, etc.) et servent à
+classifier les propriétés pour les prédictions énergétiques du modèle ML.
+
+Catégories principales disponibles :
+- RESIDENTIAL : Logements et habitations
+- OFFICE : Espaces de bureaux et administratifs
+- EDUCATION : Établissements d'enseignement
+- HEALTHCARE : Hôpitaux et établissements de soins
+- RETAIL : Magasins et commerces
+- INDUSTRIAL : Usines et installations industrielles
+- Et autres catégories spécialisées
+
+Endpoints disponibles :
+- GET /api/v1/categories/ : Liste paginée des catégories
+- GET /api/v1/categories/{id} : Catégorie spécifique par ID
+
+Auteur: François Hellebuyck
+Projet: Building Energy Prediction API - OpenClassrooms Projet 5
+"""
+
+import logging
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.orm import Session
+
+from project5.database import get_db
+from project5.schemas.categorie import CategoryList, CategoryResponse
+from project5.services.categorie_service import CategorieService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v1/categories", tags=["categories"])
+
+
+@router.get(
+    "/",
+    response_model=List[CategoryList],
+    summary="Récupérer toutes les catégories de propriétés",
+    description="""
+    Retourne la liste paginée de toutes les catégories de propriétés disponibles dans le système.
+
+    Cette endpoint permet de récupérer l'ensemble des catégories d'usage des bâtiments
+    utilisées pour la classification et les prédictions énergétiques. Chaque catégorie
+    regroupe des propriétés ayant des caractéristiques énergétiques similaires.
+
+    Catégories disponibles dans le système :
+    - RESIDENTIAL : Logements et habitations
+    - OFFICE : Espaces de bureaux et administratifs
+    - EDUCATION : Établissements d'enseignement et de formation
+    - HEALTHCARE : Hôpitaux, cliniques et établissements de soins médicaux
+    - RETAIL : Magasins et commerces de détail
+    - RESTAURANT : Restaurants et services alimentaires
+    - INDUSTRIAL : Usines et installations industrielles
+    - ENTERTAINMENT : Théâtres, cinémas et espaces de divertissement
+    - LODGING : Hôtels et logements temporaires
+    - PARKING : Structures et espaces de stationnement
+    - PUBLIC : Services gouvernementaux et publics
+    - RELIGIOUS : Églises et lieux de culte
+    - Et autres catégories spécialisées
+
+    Paramètres de pagination :
+    - skip : nombre d'enregistrements à ignorer (par défaut 0)
+    - limit : nombre maximum d'enregistrements à retourner (par défaut 100, max 1000)
+    """,
+    responses={
+        200: {
+            "description": "Liste des catégories récupérée avec succès",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "id": 11,
+                            "category_code": "OFFICE",
+                            "category_name": "Bureaux",
+                            "description": "Espaces de bureaux et administratifs",
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                        {
+                            "id": 16,
+                            "category_code": "RESIDENTIAL",
+                            "category_name": "Résidentiel",
+                            "description": "Logements et habitations",
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                    ]
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_categories(
+    skip: int = Query(0, ge=0, description="Nombre d'éléments à ignorer (pagination)"),
+    limit: int = Query(
+        100, ge=1, le=1000, description="Nombre maximum d'éléments à retourner"
+    ),
+    db: Session = Depends(get_db),
+):
+    """
+    Récupère la liste paginée des catégories de propriétés.
+
+    Args:
+        skip (int): Nombre d'enregistrements à ignorer pour la pagination
+        limit (int): Nombre maximum d'enregistrements à retourner
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        List[CategoryList]: Liste des catégories de propriétés
+
+    Raises:
+        HTTPException: Erreur 500 si problème lors de la récupération des données
+
+    Example:
+        GET /api/v1/categories/?skip=0&limit=20
+
+    Note:
+        Les catégories sont utilisées pour regrouper les propriétés par usage
+        et déterminer les caractéristiques énergétiques typiques lors des prédictions.
+    """
+    try:
+        categories = CategorieService.get_all(db=db, skip=skip, limit=limit)
+        return categories
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des categories: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération des categories",
+        )
+
+
+@router.get(
+    "/{categorie_id}",
+    response_model=CategoryResponse,
+    summary="Récupérer une catégorie par ID",
+    description="""
+    Retourne les détails complets d'une catégorie de propriété spécifique.
+
+    Récupère toutes les informations d'une catégorie incluant :
+    - Identifiant unique dans la base de données
+    - Code de la catégorie (nom court en anglais)
+    - Nom complet de la catégorie (en français)
+    - Description détaillée de l'usage
+    - Horodatages de création et modification
+
+    Les catégories servent à classifier les propriétés selon leur usage principal
+    et sont essentielles pour déterminer les profils de consommation énergétique
+    lors des prédictions du modèle ML.
+
+    L'ID doit correspondre à une catégorie existante dans la base de données.
+    """,
+    responses={
+        200: {
+            "description": "Catégorie trouvée et retournée avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "id": 11,
+                        "category_code": "OFFICE",
+                        "category_name": "Bureaux",
+                        "description": "Espaces de bureaux et administratifs",
+                        "created_at": "2025-09-09T09:56:21Z",
+                        "updated_at": "2025-09-09T09:56:21Z",
+                    }
+                }
+            },
+        },
+        404: {
+            "description": "Catégorie non trouvée",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "Catégorie avec l'ID 999 non trouvée"}
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_categorie(categorie_id: int, db: Session = Depends(get_db)):
+    """
+    Récupère une catégorie spécifique par son ID.
+
+    Args:
+        categorie_id (int): Identifiant unique de la catégorie à récupérer
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        CategoryResponse: Catégorie avec détails complets
+
+    Raises:
+        HTTPException:
+            - 404 si la catégorie n'existe pas
+            - 500 si erreur lors de la récupération
+
+    Example:
+        GET /api/v1/categories/11
+
+    Note:
+        Les catégories sont liées aux propriétés et influencent directement
+        les prédictions énergétiques basées sur l'usage du bâtiment.
+    """
+    try:
+        categorie = CategorieService.get_by_id(db=db, categorie_id=categorie_id)
+        return categorie
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération de la category: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération de la category",
+        )

src/project5/routers/neighborhoods_routes.py

@@ -0,0 +1,328 @@
+"""
+Routes API pour la gestion des quartiers de Seattle.
+
+Ce module contient les endpoints FastAPI pour :
+- Récupération de la liste des quartiers avec pagination
+- Récupération d'un quartier spécifique par ID
+- Recherche de quartiers par nom
+- Gestion des erreurs et logging approprié
+
+Les quartiers (neighborhoods) représentent les divisions géographiques de Seattle
+et sont un facteur important pour les prédictions énergétiques car ils influencent
+les caractéristiques de consommation selon la localisation, le climat local, et
+le type d'urbanisation.
+
+Quartiers disponibles dans le système :
+- BALLARD, CENTRAL, DELRIDGE, DOWNTOWN
+- EAST, GREATER DUWAMISH, LAKE UNION
+- MAGNOLIA / QUEEN ANNE, NORTH, NORTHEAST
+- NORTHWEST, SOUTHEAST, SOUTHWEST, WEST
+- UNKNOWN (pour les données non géolocalisées)
+
+Endpoints disponibles :
+- GET /api/v1/neighborhoods/ : Liste paginée des quartiers
+- GET /api/v1/neighborhoods/{id} : Quartier spécifique par ID
+- GET /api/v1/neighborhoods/search/ : Recherche par nom
+
+Auteur: François Hellebuyck
+Projet: Building Energy Prediction API - OpenClassrooms Projet 5
+"""
+
+import logging
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.orm import Session
+
+from project5.database import get_db
+from project5.models import Neighborhood as NeighborhoodModel
+from project5.schemas import Neighborhood
+from project5.services.neighborhood_service import NeighborhoodService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(
+    prefix="/api/v1/neighborhoods",
+    tags=["neighborhoods"],
+    responses={404: {"description": "Quartier non trouvé"}},
+)
+
+
+@router.get(
+    "/",
+    response_model=List[Neighborhood],
+    summary="Récupérer tous les quartiers de Seattle",
+    description="""
+    Retourne la liste paginée de tous les quartiers de Seattle disponibles dans le système.
+
+    Cette endpoint permet de récupérer l'ensemble des quartiers (neighborhoods) de Seattle
+    utilisés pour la géolocalisation et les prédictions énergétiques. Chaque quartier
+    représente une zone géographique avec ses caractéristiques climatiques et urbaines
+    propres qui influencent la consommation énergétique des bâtiments.
+
+    Quartiers de Seattle disponibles :
+    - BALLARD : Quartier nord-ouest, résidentiel et commercial
+    - CENTRAL : Zone centrale de Seattle
+    - DELRIDGE : Quartier sud-ouest, principalement résidentiel
+    - DOWNTOWN : Centre-ville, zone commerciale et de bureaux
+    - EAST : Quartiers est de Seattle
+    - GREATER DUWAMISH : Zone industrielle sud
+    - LAKE UNION : Zone autour du lac Union, mixte
+    - MAGNOLIA / QUEEN ANNE : Quartiers résidentiels aisés
+    - NORTH, NORTHEAST : Zones résidentielles nord
+    - NORTHWEST, SOUTHEAST, SOUTHWEST, WEST : Autres zones géographiques
+    - UNKNOWN : Pour les bâtiments sans géolocalisation précise
+
+    Paramètres de pagination :
+    - skip : nombre d'enregistrements à ignorer (par défaut 0)
+    - limit : nombre maximum d'enregistrements à retourner (par défaut 100, max 1000)
+    """,
+    responses={
+        200: {
+            "description": "Liste des quartiers récupérée avec succès",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "id": 5,
+                            "neighborhood_name": "DOWNTOWN",
+                            "model_id": 3,
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                        {
+                            "id": 2,
+                            "neighborhood_name": "BALLARD",
+                            "model_id": 0,
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                    ]
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_neighborhoods(
+    skip: int = Query(0, ge=0, description="Nombre d'éléments à ignorer (pagination)"),
+    limit: int = Query(
+        100, ge=1, le=1000, description="Nombre maximum d'éléments à retourner"
+    ),
+    db: Session = Depends(get_db),
+):
+    """
+    Récupère la liste paginée des quartiers de Seattle.
+
+    Args:
+        skip (int): Nombre d'enregistrements à ignorer pour la pagination
+        limit (int): Nombre maximum d'enregistrements à retourner
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        List[Neighborhood]: Liste des quartiers de Seattle
+
+    Raises:
+        HTTPException: Erreur 500 si problème lors de la récupération des données
+
+    Example:
+        GET /api/v1/neighborhoods/?skip=0&limit=20
+
+    Note:
+        Les quartiers sont référencés par leur model_id dans le modèle ML
+        pour tenir compte de la localisation géographique dans les prédictions.
+    """
+    try:
+        neighborhoods = NeighborhoodService.get_all(db=db, skip=skip, limit=limit)
+        return neighborhoods
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des quartiers: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération des quartiers",
+        )
+
+
+@router.get(
+    "/{neighborhood_id}",
+    response_model=Neighborhood,
+    summary="Récupérer un quartier par ID",
+    description="""
+    Retourne les détails complets d'un quartier de Seattle spécifique.
+
+    Récupère toutes les informations d'un quartier incluant :
+    - Identifiant unique dans la base de données
+    - Nom du quartier (neighborhood_name)
+    - Identifiant utilisé par le modèle ML (model_id)
+    - Horodatages de création et modification
+
+    Les quartiers sont des facteurs géographiques importants pour les prédictions
+    énergétiques car ils déterminent :
+    - Les conditions climatiques locales
+    - Le type d'urbanisation (résidentiel, commercial, industriel)
+    - Les réglementations énergétiques locales
+    - Les habitudes de consommation régionales
+
+    L'ID doit correspondre à un quartier existant dans la base de données.
+    """,
+    responses={
+        200: {
+            "description": "Quartier trouvé et retourné avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "id": 5,
+                        "neighborhood_name": "DOWNTOWN",
+                        "model_id": 3,
+                        "created_at": "2025-09-09T09:56:21Z",
+                        "updated_at": "2025-09-09T09:56:21Z",
+                    }
+                }
+            },
+        },
+        404: {
+            "description": "Quartier non trouvé",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "Quartier avec l'ID 999 non trouvé"}
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_neighborhood(neighborhood_id: int, db: Session = Depends(get_db)):
+    """
+    Récupère un quartier spécifique par son ID.
+
+    Args:
+        neighborhood_id (int): Identifiant unique du quartier à récupérer
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        Neighborhood: Quartier avec détails complets
+
+    Raises:
+        HTTPException:
+            - 404 si le quartier n'existe pas
+            - 500 si erreur lors de la récupération
+
+    Example:
+        GET /api/v1/neighborhoods/5
+
+    Note:
+        Le model_id retourné est utilisé par le modèle ML pour encoder
+        la localisation géographique lors des prédictions énergétiques.
+    """
+    try:
+        neighborhood = NeighborhoodService.get_by_id(
+            db=db, neighborhood_id=neighborhood_id
+        )
+        return neighborhood
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération du quartier: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération du quartier",
+        )
+
+
+@router.get(
+    "/search/",
+    response_model=List[Neighborhood],
+    summary="Rechercher des quartiers par nom",
+    description="""
+    Recherche des quartiers de Seattle par nom avec correspondance partielle.
+
+    Cette endpoint permet de rechercher des quartiers en utilisant une correspondance
+    partielle (insensible à la casse) sur le nom du quartier. Utile pour :
+    - Auto-complétion dans les interfaces utilisateur
+    - Recherche floue de quartiers
+    - Filtrage rapide de la liste des quartiers
+
+    La recherche s'effectue sur le champ neighborhood_name avec une correspondance
+    partielle utilisant l'opérateur SQL ILIKE (insensible à la casse).
+
+    Exemples de recherche :
+    - "down" trouvera "DOWNTOWN"
+    - "north" trouvera "NORTH", "NORTHEAST", "NORTHWEST"
+    - "queen" trouvera "MAGNOLIA / QUEEN ANNE"
+
+    Les résultats sont triés par ordre alphabétique du nom de quartier.
+    """,
+    responses={
+        200: {
+            "description": "Quartiers trouvés avec succès",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "id": 10,
+                            "neighborhood_name": "NORTH",
+                            "model_id": 8,
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                        {
+                            "id": 11,
+                            "neighborhood_name": "NORTHEAST",
+                            "model_id": 9,
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                    ]
+                }
+            },
+        },
+        422: {
+            "description": "Paramètres de recherche invalides",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "detail": "Le terme de recherche doit contenir au moins 1 caractère"
+                    }
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def search_neighborhoods(
+    q: str = Query(
+        ..., min_length=1, description="Terme de recherche (insensible à la casse)"
+    ),
+    limit: int = Query(50, ge=1, le=100, description="Nombre maximum de résultats"),
+    db: Session = Depends(get_db),
+):
+    """
+    Recherche des quartiers par nom avec correspondance partielle.
+
+    Args:
+        q (str): Terme de recherche à chercher dans les noms de quartiers
+        limit (int): Nombre maximum de résultats à retourner (par défaut 50, max 100)
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        List[Neighborhood]: Liste des quartiers correspondant à la recherche
+
+    Raises:
+        HTTPException:
+            - 422 si les paramètres de recherche sont invalides
+            - 500 si erreur lors de la recherche
+
+    Example:
+        GET /api/v1/neighborhoods/search/?q=north&limit=10
+
+    Note:
+        La recherche utilise ILIKE pour une correspondance insensible à la casse
+        et retourne les résultats triés par ordre alphabétique.
+    """
+    neighborhoods = (
+        db.query(NeighborhoodModel)
+        .filter(NeighborhoodModel.neighborhood_name.ilike(f"%{q.upper()}%"))
+        .order_by(NeighborhoodModel.neighborhood_name)
+        .limit(limit)
+        .all()
+    )
+
+    return neighborhoods

src/project5/routers/prediction_routes.py

@@ -0,0 +1,251 @@
+"""
+Routes API pour les prédictions énergétiques des bâtiments.
+
+Ce module contient les endpoints FastAPI pour :
+- Prédiction de consommation énergétique basée sur les caractéristiques du bâtiment
+- Récupération d'informations sur le modèle de machine learning
+- Gestion des erreurs et logging approprié
+
+Le modèle de prédiction utilise un RandomForestRegressor entraîné sur les données
+énergétiques de Seattle pour prédire la consommation en kBTU/an. Les caractéristiques
+principales incluent :
+- Localisation (quartier)
+- Type de bâtiment et usage principal
+- Caractéristiques physiques (surface, étages, année de construction)
+- Types d'énergie utilisés (électricité, gaz naturel, vapeur)
+
+Endpoints disponibles :
+- POST /api/v1/predict : Prédiction énergétique pour un bâtiment
+- GET /api/v1/model/info : Informations sur le modèle ML
+
+Auteur: François Hellebuyck
+Projet: Building Energy Prediction API - OpenClassrooms Projet 5
+"""
+
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from project5.schemas.building_model import BuildingFeatures, PredictionResponse
+from project5.services.building_model_service import PredictionService
+
+logger = logging.getLogger(__name__)
+
+# Instance globale du service (peut être injectée via des dépendances)
+prediction_service = PredictionService()
+
+
+def get_prediction_service() -> PredictionService:
+    """
+    Injection de dépendance pour le service de prédiction.
+
+    Returns:
+        PredictionService: Instance du service de prédiction configuré
+
+    Note:
+        Cette fonction permet l'injection de dépendance FastAPI pour le service
+        de prédiction, facilitant les tests et la modularité.
+    """
+    return prediction_service
+
+
+router = APIRouter(prefix="/api/v1", tags=["predictions"])
+
+
+@router.post(
+    "/predict",
+    response_model=PredictionResponse,
+    summary="Prédire la consommation énergétique d'un bâtiment",
+    description="""
+    Effectue une prédiction de consommation énergétique basée sur les caractéristiques du bâtiment.
+
+    Cette endpoint utilise un modèle de machine learning (RandomForestRegressor) entraîné
+    sur les données énergétiques de Seattle pour prédire la consommation annuelle en kBTU.
+
+    Caractéristiques requises pour la prédiction :
+    - **neighborhood_encoded** : Quartier encodé numériquement (0-13, -1 pour UNKNOWN)
+    - **building_type_encoded** : Type de bâtiment encodé (0-7, -1 pour UNKNOWN)
+    - **largest_property_use_type_encoded** : Usage principal encodé (0-27, -1 pour UNKNOWN)
+    - **primary_property_type_encoded** : Type de propriété principal encodé
+    - **year_built** : Année de construction du bâtiment
+    - **number_of_buildings** : Nombre de bâtiments sur la propriété
+    - **number_of_floors** : Nombre d'étages
+    - **property_gfa_total** : Surface totale brute en pieds carrés
+    - **steam** : Utilisation de vapeur (0/1)
+    - **electricity** : Utilisation d'électricité (0/1)
+    - **natural_gas** : Utilisation de gaz naturel (0/1)
+
+    Le modèle retourne une prédiction de consommation énergétique avec un intervalle
+    de confiance basé sur la variance des arbres de la forêt aléatoire.
+    """,
+    responses={
+        200: {
+            "description": "Prédiction effectuée avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "predicted_energy_use": 45678.9,
+                        "confidence_interval": {"lower": 42000.5, "upper": 49357.3},
+                        "model_version": "1.0",
+                        "features_used": [
+                            "neighborhood_encoded",
+                            "building_type_encoded",
+                            "year_built",
+                            "property_gfa_total",
+                        ],
+                    }
+                }
+            },
+        },
+        422: {
+            "description": "Données d'entrée invalides",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "detail": [
+                            {
+                                "loc": ["body", "year_built"],
+                                "msg": "ensure this value is greater than 1800",
+                                "type": "value_error.number.not_gt",
+                            }
+                        ]
+                    }
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur lors de la prédiction"},
+    },
+)
+async def predict_building_value(
+    features: BuildingFeatures,
+    service: PredictionService = Depends(get_prediction_service),
+):
+    """
+    Effectue une prédiction de consommation énergétique basée sur les caractéristiques du bâtiment.
+
+    Args:
+        features (BuildingFeatures): Caractéristiques encodées du bâtiment pour la prédiction
+        service (PredictionService): Service de prédiction injecté par FastAPI
+
+    Returns:
+        PredictionResponse: Prédiction avec consommation énergétique et intervalle de confiance
+
+    Raises:
+        HTTPException:
+            - 422 si les données d'entrée sont invalides
+            - 500 si erreur lors de la prédiction ML
+
+    Example:
+        POST /api/v1/predict
+        {
+            "neighborhood_encoded": 3,
+            "building_type_encoded": 1,
+            "largest_property_use_type_encoded": 18,
+            "primary_property_type_encoded": 18,
+            "year_built": 1995,
+            "number_of_buildings": 1,
+            "number_of_floors": 15,
+            "property_gfa_total": 50000.0,
+            "steam": 1,
+            "electricity": 1,
+            "natural_gas": 1
+        }
+
+    Note:
+        Les valeurs encodées doivent correspondre aux encodages utilisés lors
+        de l'entraînement du modèle. Utilisez l'endpoint /buildings/model/{id}
+        pour obtenir les données pré-encodées d'un bâtiment existant.
+    """
+    try:
+        result = await service.predict(features)
+        return PredictionResponse(**result)
+
+    except Exception as e:
+        logger.error(f"Erreur dans la prédiction: {e}")
+        raise HTTPException(
+            status_code=500, detail=f"Erreur lors de la prédiction: {str(e)}"
+        )
+
+
+@router.get(
+    "/model/info",
+    summary="Informations sur le modèle de machine learning",
+    description="""
+    Retourne des informations détaillées sur le modèle de prédiction énergétique.
+
+    Cette endpoint fournit des métadonnées essentielles sur le modèle ML utilisé :
+    - Version du modèle déployé
+    - Type d'algorithme (RandomForestRegressor)
+    - Nombre de caractéristiques utilisées
+    - Importance des caractéristiques (feature importance)
+
+    L'importance des caractéristiques indique quelles variables ont le plus
+    d'influence sur les prédictions :
+    - Valeurs plus élevées = plus d'importance
+    - Somme totale des importances = 1.0
+    - Utile pour comprendre quels facteurs influencent le plus la consommation
+
+    Ces informations sont utiles pour :
+    - Validation du modèle en production
+    - Debugging des prédictions
+    - Analyse de l'importance des variables
+    - Monitoring de la performance du modèle
+    """,
+    responses={
+        200: {
+            "description": "Informations du modèle récupérées avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "model_version": "1.0",
+                        "model_type": "RandomForestRegressor",
+                        "feature_count": 11,
+                        "feature_importance": {
+                            "property_gfa_total": 0.45,
+                            "year_built": 0.18,
+                            "neighborhood_encoded": 0.12,
+                            "building_type_encoded": 0.08,
+                            "number_of_floors": 0.07,
+                            "largest_property_use_type_encoded": 0.05,
+                            "electricity": 0.02,
+                            "natural_gas": 0.02,
+                            "steam": 0.01,
+                        },
+                    }
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+async def get_model_info(service: PredictionService = Depends(get_prediction_service)):
+    """
+    Retourne des informations détaillées sur le modèle de machine learning.
+
+    Args:
+        service (PredictionService): Service de prédiction injecté par FastAPI
+
+    Returns:
+        dict: Informations sur le modèle incluant version, type, et importance des caractéristiques
+
+    Raises:
+        HTTPException: Erreur 500 si problème lors de la récupération des informations
+
+    Example:
+        GET /api/v1/model/info
+
+    Note:
+        L'importance des caractéristiques est calculée par le RandomForestRegressor
+        et indique la contribution relative de chaque variable aux prédictions.
+    """
+    try:
+        feature_importance = service.get_feature_importance()
+        return {
+            "model_version": service.model_version,
+            "model_type": "RandomForestRegressor",
+            "feature_count": len(service.feature_names),
+            "feature_importance": feature_importance,
+        }
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des infos du modèle: {e}")
+        raise HTTPException(status_code=500, detail=f"Erreur: {str(e)}")

src/project5/routers/properties_routes.py

@@ -0,0 +1,246 @@
+"""
+Routes API pour la gestion des propriétés d'usage des bâtiments.
+
+Ce module contient les endpoints FastAPI pour :
+- Récupération de la liste des propriétés d'usage avec pagination
+- Récupération d'une propriété spécifique par ID
+- Gestion des erreurs et logging approprié
+
+Les propriétés d'usage représentent les utilisations spécifiques des bâtiments
+et sont plus granulaires que les catégories. Elles permettent une classification
+fine pour les prédictions énergétiques du modèle ML.
+
+Propriétés principales disponibles :
+- OFFICE : Bureaux
+- RETAIL STORE : Magasin de détail
+- RESTAURANT : Restaurant
+- K-12 SCHOOL : École primaire/secondaire
+- COLLEGE/UNIVERSITY : Enseignement supérieur
+- HOSPITAL : Hôpital
+- HOTEL : Hôtel
+- MULTIFAMILY HOUSING : Logement collectif
+- WAREHOUSE : Entrepôt
+- DATA CENTER : Centre de données
+- Et autres usages spécialisés
+
+Chaque propriété est liée à une catégorie parent et possède un model_id
+utilisé par le modèle ML pour l'encodage numérique.
+
+Endpoints disponibles :
+- GET /api/v1/properties/ : Liste paginée des propriétés
+- GET /api/v1/properties/{id} : Propriété spécifique par ID
+
+Auteur: François Hellebuyck
+Projet: Building Energy Prediction API - OpenClassrooms Projet 5
+"""
+
+import logging
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.orm import Session
+
+from project5.database import get_db
+from project5.schemas.property import PropertyList, PropertyResponse
+from project5.services.property_service import PropertyService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v1/properties", tags=["properties"])
+
+
+@router.get(
+    "/",
+    response_model=List[PropertyList],
+    summary="Récupérer toutes les propriétés d'usage",
+    description="""
+    Retourne la liste paginée de toutes les propriétés d'usage des bâtiments disponibles dans le système.
+
+    Cette endpoint permet de récupérer l'ensemble des types d'usage spécifiques des
+    bâtiments utilisés pour une classification fine lors des prédictions énergétiques.
+    Les propriétés sont plus granulaires que les catégories et permettent de distinguer
+    des usages précis ayant des profils énergétiques différents.
+
+    Propriétés d'usage disponibles dans le système :
+    - **OFFICE** : Bureaux et espaces administratifs
+    - **RETAIL STORE** : Magasins et commerces de détail
+    - **RESTAURANT** : Restaurants et services de restauration
+    - **K-12 SCHOOL** : Écoles primaires et secondaires
+    - **COLLEGE/UNIVERSITY** : Établissements d'enseignement supérieur
+    - **HOSPITAL** : Hôpitaux et centres médicaux
+    - **HOTEL** : Hôtels et hébergements
+    - **MULTIFAMILY HOUSING** : Logements collectifs et appartements
+    - **WAREHOUSE** : Entrepôts et stockage
+    - **DATA CENTER** : Centres de données et serveurs
+    - **BANK BRANCH** : Agences bancaires
+    - **COURTHOUSE** : Tribunaux et bâtiments judiciaires
+    - **LIBRARY** : Bibliothèques
+    - **MEDICAL OFFICE** : Cabinets médicaux
+    - **PARKING** : Structures de stationnement
+    - Et autres usages spécialisés
+
+    Chaque propriété appartient à une catégorie parent et possède un model_id
+    unique utilisé par le modèle ML pour l'encodage numérique lors des prédictions.
+
+    Paramètres de pagination :
+    - skip : nombre d'enregistrements à ignorer (par défaut 0)
+    - limit : nombre maximum d'enregistrements à retourner (par défaut 100, max 1000)
+    """,
+    responses={
+        200: {
+            "description": "Liste des propriétés récupérée avec succès",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "id": 20,
+                            "model_id": 18,
+                            "property_name": "OFFICE",
+                            "category_id": 11,
+                            "category_name": "Bureaux",
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                        {
+                            "id": 24,
+                            "model_id": 22,
+                            "property_name": "RETAIL STORE",
+                            "category_id": 18,
+                            "category_name": "Commerce de détail",
+                            "created_at": "2025-09-09T09:56:21Z",
+                            "updated_at": "2025-09-09T09:56:21Z",
+                        },
+                    ]
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_properties(
+    skip: int = Query(0, ge=0, description="Nombre d'éléments à ignorer (pagination)"),
+    limit: int = Query(
+        100, ge=1, le=1000, description="Nombre maximum d'éléments à retourner"
+    ),
+    db: Session = Depends(get_db),
+):
+    """
+    Récupère la liste paginée des propriétés d'usage des bâtiments.
+
+    Args:
+        skip (int): Nombre d'enregistrements à ignorer pour la pagination
+        limit (int): Nombre maximum d'enregistrements à retourner
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        List[PropertyList]: Liste des propriétés d'usage avec informations de catégorie
+
+    Raises:
+        HTTPException: Erreur 500 si problème lors de la récupération des données
+
+    Example:
+        GET /api/v1/properties/?skip=0&limit=30
+
+    Note:
+        Les propriétés sont référencées par leur model_id dans le modèle ML
+        pour effectuer une classification fine des usages lors des prédictions.
+        Chaque propriété hérite des caractéristiques de sa catégorie parent.
+    """
+    try:
+        categories = PropertyService.get_all(db=db, skip=skip, limit=limit)
+        return categories
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des properties: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération des properties",
+        )
+
+
+@router.get(
+    "/{id}",
+    response_model=PropertyResponse,
+    summary="Récupérer une propriété d'usage par ID",
+    description="""
+    Retourne les détails complets d'une propriété d'usage spécifique.
+
+    Récupère toutes les informations d'une propriété d'usage incluant :
+    - Identifiant unique dans la base de données
+    - Identifiant utilisé par le modèle ML (model_id)
+    - Nom de la propriété d'usage
+    - Relation avec la catégorie parent (category_id et nom)
+    - Horodatages de création et modification
+
+    Les propriétés d'usage permettent une classification fine des bâtiments
+    selon leur utilisation spécifique, au-delà des catégories générales.
+    Elles sont essentielles pour les prédictions énergétiques car différents
+    usages ont des profils de consommation très différents :
+
+    - **OFFICE** vs **DATA CENTER** : consommation informatique différente
+    - **RESTAURANT** vs **RETAIL STORE** : besoins énergétiques distincts
+    - **HOSPITAL** vs **MEDICAL OFFICE** : intensité énergétique variable
+    - **K-12 SCHOOL** vs **COLLEGE/UNIVERSITY** : profils d'occupation différents
+
+    L'ID doit correspondre à une propriété existante dans la base de données.
+    """,
+    responses={
+        200: {
+            "description": "Propriété trouvée et retournée avec succès",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "id": 20,
+                        "model_id": 18,
+                        "property_name": "OFFICE",
+                        "category_id": 11,
+                        "category_name": "Bureaux",
+                        "created_at": "2025-09-09T09:56:21Z",
+                        "updated_at": "2025-09-09T09:56:21Z",
+                    }
+                }
+            },
+        },
+        404: {
+            "description": "Propriété non trouvée",
+            "content": {
+                "application/json": {
+                    "example": {"detail": "Propriété avec l'ID 999 non trouvée"}
+                }
+            },
+        },
+        500: {"description": "Erreur interne du serveur"},
+    },
+)
+def get_property(id: int, db: Session = Depends(get_db)):
+    """
+    Récupère une propriété d'usage spécifique par son ID.
+
+    Args:
+        id (int): Identifiant unique de la propriété à récupérer
+        db (Session): Session de base de données injectée par FastAPI
+
+    Returns:
+        PropertyResponse: Propriété d'usage avec détails complets et catégorie parent
+
+    Raises:
+        HTTPException:
+            - 404 si la propriété n'existe pas
+            - 500 si erreur lors de la récupération
+
+    Example:
+        GET /api/v1/properties/20
+
+    Note:
+        Le model_id retourné est utilisé par le modèle ML pour encoder
+        l'usage spécifique lors des prédictions énergétiques. Cette granularité
+        permet des prédictions plus précises que les catégories générales.
+    """
+    try:
+        property = PropertyService.get_by_id(db=db, property_id=id)
+        return property
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération de la propriété: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Erreur lors de la récupération de la propriété",
+        )

src/project5/schemas/__init__.py

@@ -0,0 +1,45 @@
+"""
+Package des schémas Pydantic pour l'API de prédiction énergétique.
+
+Ce package contient tous les schémas de validation et sérialisation des données
+utilisés par l'API FastAPI pour la gestion des bâtiments et prédictions énergétiques.
+
+Schémas disponibles :
+- Neighborhood : Schémas pour les quartiers de Seattle
+- NeighborhoodExists : Validation d'existence de quartier
+- PaginatedNeighborhoods : Réponses paginées de quartiers
+- HealthCheck : Schéma de vérification de l'état de l'API
+- ServiceInfo : Informations sur le service API
+- ErrorResponse : Schéma de réponse d'erreur standardisé
+
+Architecture des schémas :
+- Validation des données d'entrée avec Pydantic Field contraints
+- Sérialisation automatique depuis les modèles SQLAlchemy
+- Support de la pagination pour les listes d'éléments
+- Gestion des erreurs avec messages structurés
+- Configuration de JSON encoders pour les types spéciaux (Decimal, datetime)
+
+Note :
+Ces schémas assurent la validation côté API et la documentation automatique
+OpenAPI/Swagger. Ils définissent les contrats d'interface entre clients et serveur.
+"""
+
+# Import du schema Neighborhood depuis le fichier approprié
+from .neighborhood import (
+    ErrorResponse,
+    HealthCheck,
+    Neighborhood,
+    NeighborhoodExists,
+    PaginatedNeighborhoods,
+    ServiceInfo,
+)
+
+# Exposer les schemas au niveau du package
+__all__ = [
+    "Neighborhood",
+    "NeighborhoodExists",
+    "PaginatedNeighborhoods",
+    "HealthCheck",
+    "ServiceInfo",
+    "ErrorResponse",
+]

src/project5/schemas/building_energy_prediction.py

@@ -0,0 +1,253 @@
+"""
+Schémas Pydantic pour les prédictions énergétiques des bâtiments.
+
+Ce module définit tous les schémas de validation et sérialisation pour les données
+de prédictions énergétiques calculées par le modèle de machine learning.
+
+Classes disponibles :
+- BuildingEnergyPredictionsBase : Schéma de base avec les champs communs
+- BuildingEnergyPredictionsCreate : Schéma pour la création de nouvelles prédictions
+- BuildingEnergyPredictionsUpdate : Schéma pour la mise à jour de prédictions
+- BuildingEnergyPredictionsResponse : Schéma de réponse avec ID et métadonnées
+- BuildingEnergyPredictionsList : Schéma pour les réponses paginées
+- BuildingEnergyPredictionsStats : Schéma pour les statistiques agrégées
+
+Fonctionnalités :
+- Validation automatique des types et contraintes (valeurs positives, etc.)
+- Sérialisation automatique depuis les modèles SQLAlchemy
+- Encodage JSON personnalisé pour Decimal et datetime
+- Support de la pagination avec métadonnées (total, pages, etc.)
+- Calculs statistiques (moyennes, min/max, compteurs)
+
+Note :
+Les prédictions énergétiques sont exprimées en kBTU (thousand British Thermal Units)
+avec normalisation météorologique pour compenser les variations climatiques.
+"""
+
+from datetime import datetime
+from decimal import Decimal
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BuildingEnergyPredictionsBase(BaseModel):
+    """
+    Schéma de base pour les prédictions énergétiques des bâtiments.
+
+    Cette classe définit les champs communs utilisés par tous les schémas
+    de prédictions énergétiques (création, mise à jour, réponse).
+
+    Attributes:
+        building_id (int): Identifiant du bâtiment concerné (obligatoire, > 0)
+        site_energy_use_wn_kbtu (Decimal, optional): Consommation énergétique
+            en kBTU avec normalisation météorologique (>= 0)
+        predicted (bool, optional): Indique si la valeur est prédite (True)
+            ou mesurée (False). Par défaut True.
+        updated_at (datetime, optional): Date et heure de la prédiction
+            avec fuseau horaire
+
+    Note:
+        La normalisation météorologique ajuste les données de consommation
+        pour compenser les variations climatiques saisonnières.
+    """
+
+    building_id: int = Field(
+        ...,
+        description="Identifiant du bâtiment concerné (clé étrangère vers buildings.id)",
+        gt=0,
+    )
+    site_energy_use_wn_kbtu: Optional[Decimal] = Field(
+        None,
+        description="Consommation énergétique du site en kBTU avec normalisation météorologique",
+        ge=0,
+    )
+    predicted: Optional[bool] = Field(
+        True, description="Indique si la valeur est prédite (TRUE) ou mesurée (FALSE)"
+    )
+    updated_at: Optional[datetime] = Field(
+        None, description="Date et heure de la prédiction avec fuseau horaire"
+    )
+
+
+class BuildingEnergyPredictionsCreate(BuildingEnergyPredictionsBase):
+    """
+    Schéma pour la création d'une nouvelle prédiction énergétique.
+
+    Hérite de BuildingEnergyPredictionsBase et utilise tous ses champs
+    sans modification. Ce schéma est utilisé lors des requêtes POST
+    pour créer de nouvelles prédictions dans la base de données.
+
+    Usage:
+        - Endpoint POST /building-energy-predictions/
+        - Validation automatique des contraintes de la classe de base
+        - Génération automatique de l'ID lors de l'insertion en base
+
+    Example:
+        {
+            "building_id": 12345,
+            "site_energy_use_wn_kbtu": 2500.75,
+            "predicted": true,
+            "updated_at": "2024-01-15T10:30:00Z"
+        }
+    """
+
+    pass
+
+
+class BuildingEnergyPredictionsUpdate(BaseModel):
+    """
+    Schéma pour la mise à jour partielle d'une prédiction énergétique.
+
+    Tous les champs sont optionnels pour permettre les mises à jour partielles.
+    Seuls les champs fournis seront mis à jour dans la base de données.
+
+    Attributes:
+        site_energy_use_wn_kbtu (Decimal, optional): Nouvelle consommation
+            énergétique en kBTU (>= 0)
+        predicted (bool, optional): Nouveau statut prédiction/mesure
+        updated_at (datetime, optional): Nouvelle date de prédiction
+
+    Usage:
+        - Endpoint PATCH /building-energy-predictions/{id}
+        - Permet la mise à jour de champs individuels
+        - building_id non modifiable (contrainte métier)
+
+    Note:
+        L'ID du bâtiment (building_id) n'est pas modifiable pour préserver
+        l'intégrité référentielle des données.
+    """
+
+    site_energy_use_wn_kbtu: Optional[Decimal] = Field(
+        None,
+        description="Consommation énergétique du site en kBTU avec normalisation météorologique",
+        ge=0,
+    )
+    predicted: Optional[bool] = Field(
+        None, description="Indique si la valeur est prédite (TRUE) ou mesurée (FALSE)"
+    )
+    updated_at: Optional[datetime] = Field(
+        None, description="Date et heure de la prédiction avec fuseau horaire"
+    )
+
+
+class BuildingEnergyPredictionsResponse(BuildingEnergyPredictionsBase):
+    """
+    Schéma de réponse pour une prédiction énergétique individuelle.
+
+    Hérite de BuildingEnergyPredictionsBase et ajoute l'ID généré
+    automatiquement par la base de données. Inclut la configuration
+    de sérialisation pour la conversion depuis les modèles SQLAlchemy.
+
+    Attributes:
+        id (int): Identifiant unique de la prédiction (clé primaire)
+        + tous les champs de BuildingEnergyPredictionsBase
+
+    Configuration:
+        - from_attributes=True : Conversion automatique depuis SQLAlchemy
+        - str_strip_whitespace=True : Nettoyage automatique des chaînes
+        - validate_assignment=True : Validation lors des assignations
+        - json_encoders : Encodage personnalisé Decimal->float, datetime->ISO
+
+    Usage:
+        - Réponses des endpoints GET /building-energy-predictions/
+        - Sérialisation automatique des objets BuildingEnergyPredictions
+    """
+
+    id: int = Field(
+        ...,
+        description="Identifiant unique de la prédiction (clé primaire auto-incrémentée)",
+    )
+
+    model_config = ConfigDict(
+        from_attributes=True,
+        # Permet la conversion automatique depuis les objets SQLAlchemy
+        str_strip_whitespace=True,
+        # Validation des types
+        validate_assignment=True,
+        # Configuration pour les décimales
+        json_encoders={
+            Decimal: lambda v: float(v) if v is not None else None,
+            datetime: lambda v: v.isoformat() if v is not None else None,
+        },
+    )
+
+
+class BuildingEnergyPredictionsList(BaseModel):
+    """
+    Schéma pour une liste paginée de prédictions énergétiques.
+
+    Structure de réponse standardisée pour les endpoints retournant
+    plusieurs prédictions avec support de la pagination.
+
+    Attributes:
+        items (list[BuildingEnergyPredictionsResponse]): Liste des prédictions
+        total (int): Nombre total d'éléments dans la base (toutes pages)
+        page (int): Numéro de la page actuelle (commence à 1)
+        size (int): Nombre d'éléments par page (1-100)
+        pages (int): Nombre total de pages calculé
+
+    Usage:
+        - Endpoint GET /building-energy-predictions/ avec paramètres de pagination
+        - Calcul automatique du nombre de pages : ceil(total / size)
+        - Navigation facilitée avec métadonnées de pagination
+
+    Example de réponse:
+        {
+            "items": [...],
+            "total": 1500,
+            "page": 2,
+            "size": 50,
+            "pages": 30
+        }
+    """
+
+    items: list[BuildingEnergyPredictionsResponse]
+    total: int = Field(..., description="Nombre total d'éléments")
+    page: int = Field(..., description="Page actuelle", ge=1)
+    size: int = Field(..., description="Taille de la page", ge=1, le=100)
+    pages: int = Field(..., description="Nombre total de pages")
+
+
+class BuildingEnergyPredictionsStats(BaseModel):
+    """
+    Schéma pour les statistiques agrégées des prédictions énergétiques.
+
+    Fournit une vue d'ensemble des données de prédictions avec des
+    métriques statistiques calculées côté base de données.
+
+    Attributes:
+        total_predictions (int): Nombre total de prédictions en base
+        predicted_count (int): Nombre de valeurs prédites (ML)
+        measured_count (int): Nombre de valeurs mesurées (réelles)
+        avg_energy_consumption (Decimal, optional): Consommation moyenne en kBTU
+        min_energy_consumption (Decimal, optional): Consommation minimale en kBTU
+        max_energy_consumption (Decimal, optional): Consommation maximale en kBTU
+        latest_updated_at (datetime, optional): Date de la prédiction
+            la plus récente
+
+    Usage:
+        - Endpoint GET /building-energy-predictions/stats
+        - Tableaux de bord et reporting
+        - Monitoring de la qualité des prédictions
+
+    Note:
+        Les statistiques sont calculées en temps réel via des requêtes
+        d'agrégation SQL pour garantir la fraîcheur des données.
+    """
+
+    total_predictions: int = Field(..., description="Nombre total de prédictions")
+    predicted_count: int = Field(..., description="Nombre de valeurs prédites")
+    measured_count: int = Field(..., description="Nombre de valeurs mesurées")
+    avg_energy_consumption: Optional[Decimal] = Field(
+        None, description="Consommation énergétique moyenne en kBTU"
+    )
+    min_energy_consumption: Optional[Decimal] = Field(
+        None, description="Consommation énergétique minimale en kBTU"
+    )
+    max_energy_consumption: Optional[Decimal] = Field(
+        None, description="Consommation énergétique maximale en kBTU"
+    )
+    latest_updated_at: Optional[datetime] = Field(
+        None, description="Date de la prédiction la plus récente"
+    )