Introduce WebSocket-based notification service with targeted delivery and subscription support.

.dockerignore

@@ -0,0 +1,83 @@
+**
+
+!/.dockerignore
+!/.env.sample
+!/Dockerfile
+!/README.md
+!/pyproject.toml
+!/poetry.lock
+!/main.py
+
+!/core
+!/core/**
+
+!/*.ini
+!/*.cfg
+!/*.yaml
+!/*.yml
+
+.git
+.gitignore
+.gitattributes
+.gitmodules
+.idea
+.vscode
+*.swp
+*.swo
+*~
+.DS_Store
+Thumbs.db
+
+.env
+.venv
+venv/
+env/
+python_env/
+
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache
+.coverage
+.coverage.*
+*.log
+logs/
+
+build/
+dist/
+*.egg-info/
+*.egg
+*.whl
+site/
+
+tests/
+test/
+docs/
+doc/
+*.rst
+*.txt
+
+*.key
+*.pem
+*.cert
+*.crt
+*.secret
+credentials.*
+secrets.*
+docker-compose*.yml
+
+*.db
+*.sqlite
+*.dump
+*.bak
+*.large
+*.zip
+*.tar
+*.gz
+*.bz2
+
+.tox
+mypy_cache
+.history
+.ipynb_checkpoints

.gitignore

@@ -0,0 +1,2 @@
+.idea
+.venv

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

Dockerfile

@@ -0,0 +1,81 @@
+FROM python:3.13.0a3-slim-bookworm AS builder
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=on \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PIP_ROOT_USER_ACTION=ignore \
+    POETRY_VERSION=1.8.2 \
+    POETRY_HOME="/opt/poetry" \
+    POETRY_NO_INTERACTION=1
+
+RUN apt-get update -qq && \
+    apt-get install -y --no-install-recommends \
+        curl \
+        build-essential \
+        pkg-config \
+        libssl-dev \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl -sSL https://install.python-poetry.org | python3 - && \
+    chmod +x /opt/poetry/bin/poetry
+
+WORKDIR /app
+
+COPY pyproject.toml poetry.lock ./
+
+RUN /opt/poetry/bin/poetry install --only main --no-root --no-interaction --no-ansi -v
+
+FROM python:3.13.0a3-slim-bookworm AS runtime
+
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PATH="/venv/bin:$PATH" \
+    PYTHONPATH="/app" \
+    UWSGI_HTTP=:8000 \
+    UWSGI_MASTER=1 \
+    UWSGI_HTTP_AUTO_CHUNKED=1 \
+    UWSGI_HTTP_KEEPALIVE=1 \
+    UWSGI_LAZY_APPS=1 \
+    UWSGI_WSGI_ENV_BEHAVIOR=holy
+
+RUN apt-get update -qq && \
+    apt-get install -y --no-install-recommends \
+        libssl3 \
+        ca-certificates \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* \
+    && groupadd -r appgroup --gid=1000 \
+    && useradd -r -g appgroup --uid=1000 --create-home --shell=/bin/false appuser
+
+RUN python -m venv /venv
+
+COPY --from=builder --chown=appuser:appgroup /root/.cache /home/appuser/.cache
+COPY --from=builder --chown=appuser:appgroup /app /app
+COPY --from=builder --chown=appuser:appgroup /venv /venv
+
+USER appuser:appgroup
+WORKDIR /app
+
+COPY --chown=appuser:appgroup . .
+
+RUN echo "[uwsgi]\n\
+module = main:app\n\
+callable = app\n\
+chdir = /app\n\
+processes = 2\n\
+threads = 2\n\
+enable-threads = true\n\
+lazy-apps = true\n\
+master = true\n\
+http-auto-chunked = true\n\
+http-keepalive = true\n\
+vacuum = true\n\
+die-on-term = true\n\
+need-app = true" > uwsgi.ini
+
+EXPOSE 7860
+
+ENTRYPOINT ["python", "-m", "uvicorn"]
+CMD ["main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,96 @@
 ---
 title: NotificationChannel
-emoji: 🦀
-colorFrom: gray
-colorTo: gray
+emoji: 🔔
+colorFrom: indigo
+colorTo: blue
 sdk: docker
-pinned: false
+pinned: true
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# 🔔 NotificationChannel
+
+**Service de notifications en temps réel professionnel**
+
+*Notification push • WebSockets • Diffusion ciblée • Historique*
+
+## ✨ Fonctionnalités
+
+- 🚀 **Connexions WebSocket** - Gestion optimisée des connexions persistantes
+- 🎯 **Notifications ciblées** - Envoi par utilisateur, rôle ou diffusion globale
+- 📊 **Historique intelligent** - Conservation des dernières notifications
+- 🔐 **Sécurité renforcée** - Gestion de session et validation
+- 📈 **Monitoring intégré** - Statistiques temps réel des connexions
+
+## 🏗️ Architecture
+
+```mermaid
+graph TD
+    A[Client] -->|WebSocket| B(API Gateway)
+    B --> C{NotificationChannel}
+    C --> D[(Historique)]
+    C --> E[Utilisateur]
+    C --> F[Rôle]
+    C --> G[Broadcast]
+```
+
+## 🚀 Déploiement
+
+```bash
+# Construction de l'image
+docker build -t notification-channel .
+
+# Lancement du service
+docker run -d -p 7860:7860 --name notif-service notification-channel
+```
+
+**Accès rapide :**
+
+- Interface : http://0.0.0.0:7860
+- Documentation API : http://0.0.0.0:7860/api-docs
+
+## ⚙️ Configuration
+
+| Variable           | Défaut  | Description                          |
+|--------------------|---------|--------------------------------------|
+| `APP_HOST`         | 0.0.0.0 | Adresse d'écoute du service          |
+| `APP_PORT`         | 7860    | Port d'écoute du service             |
+| `MAX_HISTORY_SIZE` | 1000    | Taille max de l'historique           |
+| `NOTIF_TTL`        | 3600    | Durée de vie des notifications (sec) |
+
+## 🔄 Workflow CI/CD
+
+```mermaid
+graph LR
+    A[Code] --> B[Tests]
+    B --> C[Build Docker]
+    C --> D[Scan Sécurité]
+    D --> E[Staging]
+    E --> F[Validation]
+    F --> G[Production]
+```
+
+## 📋 API Endpoints
+
+### WebSocket
+
+- `ws://localhost:8000/ws/{user_id}` - Connexion utilisateur
+- `ws://localhost:8000/ws/broadcast` - Diffusion globale
+
+### REST API
+
+- `POST /notify/user/{user_id}` - Notification individuelle
+- `POST /notify/role/{role}` - Notification par rôle
+- `POST /notify/broadcast` - Diffusion générale
+- `GET /history/{user_id}` - Historique utilisateur
+
+## 🛠️ Développement
+
+```bash
+# Installation des dépendances
+pip install -r requirements.txt
+
+# Lancement en mode dev
+uvicorn main:app --reload --host 0.0.0.0 --port 7860
+```

config.yml

@@ -0,0 +1,12 @@
+APP_NAME: NotificationChannel
+APP_ENV: local
+APP_PRODUCTION: False
+APP_PORT: 7860
+APP_HOST: 0.0.0.0
+
+MAX_HISTORY_SIZE: 1000
+
+WS_HOST: 0.0.0.0
+WS_PORT: 8765
+WS_SSL: false
+WS_CORS_ORIGINS: '*'

core/logger/core_logger.py

@@ -0,0 +1,96 @@
+import os
+import sys
+from enum import Enum
+from logging import Formatter, LogRecord, getLogger, StreamHandler, FileHandler
+from pathlib import Path
+
+from colorama import Fore, Style
+
+
+class LoggerTarget(Enum):
+    CONSOLE = "console"
+    FILE = "file"
+    BOTH = "both"
+
+
+class ColorFormatter(Formatter):
+    COLORS_LEVEL = {
+        "DEBUG": Fore.CYAN,
+        "INFO": Fore.GREEN,
+        "WARNING": Fore.YELLOW,
+        "ERROR": Fore.RED,
+        "CRITICAL": Fore.MAGENTA + Style.BRIGHT,
+    }
+
+    def format(self, record: LogRecord):
+        original_levelname = record.levelname
+        color = self.COLORS_LEVEL.get(original_levelname, "")
+        record.levelname = f"{color}{original_levelname}{Style.RESET_ALL}"
+        formatted = super().format(record)
+        return formatted
+
+
+class CoreLogger:
+    def __init__(
+        self,
+        name: str = "app",
+        level: str = "INFO",
+        fmt: str = None,
+        datefmt: str = None,
+        log_to_console: bool = True,
+        log_to_file: bool = False,
+    ):
+        self.logger = getLogger(name)
+        self.logger.setLevel(level)
+        self.log_to_console = log_to_console
+        self.log_to_file = log_to_file
+        self.logger.propagate = False
+
+        self.fmt = fmt or "%(asctime)s | %(levelname)-8s | %(message)s"
+        self.datefmt = datefmt or "%Y-%m-%d %H:%M:%S"
+
+        self.logger_file_path = Path(__file__).resolve().parents[2]
+        self.logger_file_path = self.logger_file_path / "logs" / "app.log"
+
+        formatter = Formatter(self.fmt, self.datefmt)
+
+        color_formatter = ColorFormatter(self.fmt, self.datefmt)
+
+        if self.log_to_console:
+            console_handler = StreamHandler(sys.stdout)
+            console_handler.setFormatter(color_formatter)
+            self.logger.addHandler(console_handler)
+
+        if self.log_to_file:
+            log_file_path = Path(self.logger_file_path).resolve()
+            log_file_path.parent.mkdir(parents=True, exist_ok=True)
+            fh = FileHandler(log_file_path, encoding="utf-8")
+            fh.setFormatter(formatter)
+            self.logger.addHandler(fh)
+
+    def debug(self, message: str):
+        self.logger.debug(message)
+
+    def info(self, message: str):
+        self.logger.info(message)
+
+    def warning(self, message: str):
+        self.logger.warning(message)
+
+    def error(self, message: str):
+        self.logger.error(message)
+
+    def clear_log(self, target: LoggerTarget = LoggerTarget.BOTH):
+        if target in (LoggerTarget.CONSOLE, LoggerTarget.BOTH) and self.log_to_console:
+            os.system("cls" if sys.platform.startswith("win") else "clear")
+
+        if target in (LoggerTarget.FILE, LoggerTarget.BOTH) and self.log_to_file:
+            log_file_path = Path(self.logger_file_path).resolve()
+            if log_file_path.exists():
+                with log_file_path.open("w", encoding="utf-8") as f:
+                    f.truncate(0)
+
+
+if __name__ == "__main__":
+    logger = CoreLogger(log_to_console=True, log_to_file=True)
+    logger.info("test")

core/manager/websocket_manager.py

@@ -0,0 +1,180 @@
+from collections import deque
+from datetime import datetime
+from typing import Dict, List, Any, Deque
+
+from fastapi import WebSocket
+
+from core.settings.settings import Settings
+from core.types.datamodels import ClientInfo, Subscription, Notification
+
+
+class WebSocketManager:
+    def __init__(self):
+        self.settings = Settings()
+        self.logger = self.settings.logger
+
+        self.active_connections: Dict[str, WebSocket] = {}
+        self.client_info: Dict[str, ClientInfo] = {}
+        self.subscriptions: Dict[str, List[Subscription]] = {}
+        self.notification_history: Deque[Notification] = deque(
+            maxlen=self.settings.get("MAX_NOTIFICATION_HISTORY", 1000)
+        )
+
+    async def connect(self, websocket: WebSocket, client: ClientInfo) -> str:
+        """Établit une nouvelle connexion WebSocket"""
+        await websocket.accept()
+        session_id = client.session_id
+
+        self.active_connections[session_id] = websocket
+        self.client_info[session_id] = client
+        self.subscriptions[session_id] = []
+
+        self.logger.info(f"Nouvelle connexion: {session_id}")
+
+        await self._send(
+            websocket,
+            {
+                "type": "connection_established",
+                "session_id": session_id,
+                "message": "Connexion au service de notifications établie",
+                "timestamp": datetime.utcnow().isoformat(),
+            },
+        )
+
+        return session_id
+
+    def disconnect(self, session_id: str) -> None:
+        """Ferme une connexion et nettoie les ressources"""
+        if session_id in self.active_connections:
+            del self.active_connections[session_id]
+            del self.client_info[session_id]
+            del self.subscriptions[session_id]
+            self.logger.info(f"Connexion fermée: {session_id}")
+
+    async def send_personal_message(
+        self, session_id: str, payload: Dict[str, Any]
+    ) -> None:
+        """Envoie un message à un client spécifique"""
+        if ws := self.active_connections.get(session_id):
+            try:
+                await self._send(ws, payload)
+            except RuntimeError as e:
+                self.logger.error(f"Erreur d'envoi à {session_id}: {e}")
+                self.disconnect(session_id)
+
+    async def broadcast_notification(self, notification: Notification) -> None:
+        """Diffuse une notification aux clients abonnés"""
+        if notification.is_expired:
+            return
+
+        self._add_to_history(notification)
+        payload = self._format_notification(notification)
+
+        for session_id, subscriptions in self.subscriptions.items():
+            if not (client := self.client_info.get(session_id)):
+                continue
+
+            if self._should_receive(subscriptions, notification, client):
+                await self.send_personal_message(session_id, payload)
+
+    async def send_to_user(self, user_id: str, notification: Notification) -> None:
+        """Envoie une notification à un utilisateur spécifique"""
+        if notification.is_expired:
+            return
+
+        self._add_to_history(notification)
+        payload = self._format_notification(notification)
+
+        for session_id, client in self.client_info.items():
+            if client.user_id == user_id:
+                await self.send_personal_message(session_id, payload)
+
+    async def send_to_role(self, role: str, notification: Notification) -> None:
+        """Envoie une notification à un rôle spécifique"""
+        if notification.is_expired:
+            return
+
+        self._add_to_history(notification)
+        payload = self._format_notification(notification)
+
+        for session_id, client in self.client_info.items():
+            if role in client.user_roles:
+                await self.send_personal_message(session_id, payload)
+
+    def add_subscription(self, session_id: str, subscription: Subscription) -> bool:
+        """Ajoute un nouvel abonnement pour un client"""
+        if not (sub_list := self.subscriptions.get(session_id)):
+            return False
+
+        for existing in sub_list:
+            if existing.id == subscription.id:
+                return False
+
+        sub_list.append(subscription)
+        return True
+
+    def update_subscription(self, session_id: str, subscription: Subscription) -> bool:
+        """Met à jour un abonnement existant"""
+        if not (sub_list := self.subscriptions.get(session_id)):
+            return False
+
+        for i, existing in enumerate(sub_list):
+            if existing.id == subscription.id:
+                sub_list[i] = subscription
+                return True
+        return False
+
+    def remove_subscription(self, session_id: str, subscription_id: str) -> bool:
+        """Supprime un abonnement"""
+        if not (sub_list := self.subscriptions.get(session_id)):
+            return False
+
+        initial_count = len(sub_list)
+        self.subscriptions[session_id] = [
+            sub for sub in sub_list if sub.id != subscription_id
+        ]
+        return len(self.subscriptions[session_id]) < initial_count
+
+    def get_subscriptions(self, session_id: str) -> List[Subscription]:
+        """Récupère les abonnements d'un client"""
+        return self.subscriptions.get(session_id, [])[:]
+
+    def get_notification_history(self, limit: int = 100) -> List[Notification]:
+        """Récupère l'historique des notifications"""
+        return [n for n in list(self.notification_history)[-limit:] if not n.is_expired]
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Retourne les statistiques du service"""
+        return {
+            "active_connections": len(self.active_connections),
+            "total_subscriptions": sum(len(s) for s in self.subscriptions.values()),
+            "total_notifications": len(self.notification_history),
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+
+    # Méthodes internes
+    async def _send(self, websocket: WebSocket, payload: Dict[str, Any]) -> None:
+        """Mécanisme d'envoi générique"""
+        await websocket.send_json(payload)
+
+    def _add_to_history(self, notification: Notification) -> None:
+        """Ajoute une notification à l'historique"""
+        if not notification.is_expired:
+            self.notification_history.append(notification)
+
+    @staticmethod
+    def _should_receive(
+        subscriptions: List[Subscription],
+        notification: Notification,
+        client: ClientInfo,
+    ) -> bool:
+        """Vérifie si un client doit recevoir une notification"""
+        return any(
+            sub.matches(notification, client.user_id, client.user_roles)
+            for sub in subscriptions
+        )
+
+    @staticmethod
+    def _format_notification(notification: Notification) -> Dict[str, Any]:
+        """Formate une notification pour l'envoi"""
+        return {"type": "notification", **notification.model_dump(exclude_unset=True)}

core/settings/settings.py

@@ -0,0 +1,169 @@
+import os
+import stat
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+from core.logger.core_logger import CoreLogger
+
+
+class Settings:
+    __slots__ = (
+        "_config",
+        "_file_path",
+        "_logger",
+        "_max_size_file",
+        "_env_vars_to_load",
+    )
+
+    def __init__(self):
+        self._config: Dict[str, Any] = {}
+        self._file_path: Optional[Path] = None
+        self._logger: CoreLogger = CoreLogger(name="settings")
+        self._max_size_file: int = 5 * 1024 * 1024
+
+        self._env_vars_to_load = [
+            "ANTHROPIC_KEY",
+            "ANTHROPIC_VERSION",
+            "OPENAI_API_KEY",
+        ]
+
+        self.load_configuration_file(Path(__file__).resolve().parents[2] / "config.yml")
+
+    @property
+    def all_settings(self) -> Dict[str, Any]:
+        return self._config.copy()
+
+    @property
+    def logger(self):
+        return self._logger
+
+    def _load_env_variable(self) -> None:
+        for key in self._env_vars_to_load:
+            if key in os.environ:
+                self._config[key] = os.environ.get(key)
+
+    def check_file_permission(self, file_path: Optional[Path]) -> bool:
+        if file_path:
+            path = Path(file_path)
+            if not path.exists():
+                self._logger.error(f"🛑 Le fichier de configuration est introuvable.")
+                return False
+
+            if not path.is_file():
+                self._logger.error(f"Le fichier de configuration n'est pas un fichier.")
+                return False
+
+            if path.suffix.lower() not in (".yaml", ".yml"):
+                self._logger.error(
+                    f"🛑 Le fichier de configuration n'est pas un fichier yaml."
+                )
+                return False
+
+            mode = path.stat().st_mode
+
+            modified = False
+
+            if mode & (stat.S_IWOTH | stat.S_IROTH):
+                self._logger.warning(
+                    "⚠️ Permissions incorrectes pour 'others', correction automatique en lecture seule."
+                )
+                mode = mode & ~(stat.S_IWOTH | stat.S_IROTH)
+                modified = True
+
+            if mode & stat.S_IWGRP:
+                self._logger.warning(
+                    "⚠️ Permissions incorrectes pour 'group', correction automatique en lecture seule."
+                )
+                mode = mode & ~stat.S_IWGRP
+                modified = True
+
+            if modified:
+                try:
+                    os.chmod(path, mode)
+                    self._logger.info(f"🔧 Permissions corrigées automatiquement.")
+                except Exception as e:
+                    self._logger.error(f"🛑 Échec de la correction des permissions : {e}")
+                    return False
+
+            return True
+        
+        return False
+
+    def load_configuration_file(self, file_path: str | Path) -> None:
+        path = Path(file_path).resolve()
+        self._file_path = path
+
+        try:
+            permission = self.check_file_permission(path)
+
+            if permission:
+                size = path.stat().st_size
+                if size > self._max_size_file:
+                    self._logger.error(
+                        "🛑 Le fichier de configuration ne doit pas dépasser la taille maximal"
+                    )
+
+                with open(path, "r", encoding="utf-8") as file:
+                    self._config = yaml.safe_load(file) or {}
+
+                    if not self._config:
+                        self._logger.error(
+                            "🛑 La configuration doit être un dictionnaire."
+                        )
+
+                    self._logger.info(
+                        "✅ Chargement de la configuration terminée avec succès."
+                    )
+
+        except PermissionError as exc:
+            self._logger.error(
+                f"🛑 Impossible de lire le fichier de configuration : {exc}"
+            )
+            if "e" in locals() and exc:
+                self._config = {}
+            raise
+        except Exception as e:
+            self._logger.error(
+                f"🛑 Erreur lors de la lecture du fichier de configuration : {e}"
+            )
+            if "e" in locals() and e:
+                self._config = {}
+            raise
+        finally:
+            self._logger.clear_log()
+
+    def settings_is_initialized(self) -> bool:
+        return bool(self._config)
+
+    def reload(self) -> None:
+        if not self._file_path:
+            self._logger.error("🛑 Aucun fichier de configuration trouvée.")
+            return
+
+        self.load_configuration_file(self._file_path)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._config.get(key, default)
+
+    def __getattr__(self, item: str) -> Any:
+        if item in self._config:
+            return self._config[item]
+        else:
+            self._logger.error(
+                f"Le paramètre {item} n'existe pas dans la configuration."
+            )
+            return None
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        if key in self.__slots__:
+            super().__setattr__(key, value)
+        else:
+            self._logger.error("Impossible de modifier les configurations.")
+
+
+if __name__ == "__main__":
+    settings = Settings()
+    if settings.settings_is_initialized():
+        settings.logger.info(f"{settings.all_settings}")

core/types/datamodels.py

@@ -0,0 +1,85 @@
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+from uuid import uuid4
+
+from pydantic import BaseModel, Field
+
+
+class SubscriptionRequest(BaseModel):
+    type: str  # 'user', 'role', 'global'
+    target: str
+    notification_types: List[str] = Field(default_factory=list)
+
+
+class NotificationRequest(BaseModel):
+    type: str
+    title: str
+    message: str
+    data: Dict[str, Any] = Field(default_factory=dict)
+    expires_at: Optional[datetime] = None
+    priority: str = Field(default="normal")
+
+
+class BroadcastRequest(BaseModel):
+    notification: NotificationRequest
+    target_type: str  # 'user', 'role', 'global'
+    target_value: str  # user_id, role_name, or 'all'
+
+
+class Notification(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid4()))
+    type: str
+    title: str
+    message: str
+    data: Dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime = Field(default_factory=datetime.now)
+    expires_at: Optional[datetime] = None
+    priority: str = Field(default="normal")  # 'low', 'normal', 'high', 'urgent'
+
+    @property
+    def is_expired(self) -> bool:
+        if self.expires_at is None:
+            return False
+        return datetime.now() > self.expires_at
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "type": self.type,
+            "title": self.title,
+            "message": self.message,
+            "data": self.data,
+            "created_at": self.created_at.isoformat(),
+            "expires_at": self.expires_at.isoformat() if self.expires_at else None,
+            "priority": self.priority,
+        }
+
+
+class Subscription(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid4()))
+    type: str  # 'user', 'role', 'global'
+    target: str  # user_id, role_name, or 'all'
+    notification_types: List[str] = Field(default_factory=list)
+    created_at: datetime = Field(default_factory=datetime.now)
+
+    def matches(
+        self, notification: "Notification", user_id: str, user_roles: List[str]
+    ) -> bool:
+        if self.notification_types and notification.type not in self.notification_types:
+            return False
+
+        if self.type == "user" and self.target == user_id:
+            return True
+        elif self.type == "role" and self.target in user_roles:
+            return True
+        elif self.type == "global" and self.target == "all":
+            return True
+
+        return False
+
+
+class ClientInfo(BaseModel):
+    session_id: str
+    user_id: str
+    user_roles: List[str] = Field(default_factory=list)
+    connected_at: datetime = Field(default_factory=datetime.now)

core/utils/utils.py

@@ -0,0 +1,5 @@
+from datetime import datetime, timezone
+
+
+def current_utc_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()

main.py

@@ -0,0 +1,311 @@
+from contextlib import asynccontextmanager
+from uuid import uuid4
+
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Depends
+from fastapi.responses import HTMLResponse
+
+from core.manager.websocket_manager import WebSocketManager
+from core.types.datamodels import (
+    ClientInfo,
+    SubscriptionRequest,
+    Subscription,
+    NotificationRequest,
+    Notification,
+    BroadcastRequest,
+)
+from core.utils.utils import current_utc_iso
+
+manager = WebSocketManager()
+
+logger = manager.logger
+
+
+async def validate_session(session_id: str) -> str:
+    if session_id not in manager.active_connections:
+        raise HTTPException(
+            status_code=404, detail="Session introuvable ou déjà fermée"
+        )
+    return session_id
+
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI):
+    """Gère les événements de démarrage et d'arrêt de l'application"""
+
+    logger.info("Démarrage du service de notifications WebSocket")
+
+    yield
+
+    logger.info("Arrêt du service de notifications WebSocket")
+
+
+app = FastAPI(
+    title=manager.settings.APP_NAME,
+    description="Service de notifications en temps réel avec support WebSocket",
+    version="1.0.0",
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+
+@app.websocket("/ws/{user_id}")
+async def websocket_endpoint(websocket: WebSocket, user_id: str):
+    """Endpoint pour les connexions WebSocket"""
+    session_id = None
+
+    try:
+        client_info = ClientInfo(
+            session_id=str(uuid4()),
+            user_id=user_id,
+            user_roles=(
+                websocket.query_params.get("roles", "").split(",")
+                if websocket.query_params.get("roles")
+                else []
+            ),
+        )
+
+        session_id = await manager.connect(websocket, client_info)
+
+        while True:
+            data = await websocket.receive_json()
+
+            await manager.send_personal_message(
+                session_id,
+                {
+                    "type": "message_ack",
+                    "message": f"Message reçu: {data}",
+                    "timestamp": current_utc_iso(),
+                },
+            )
+
+    except WebSocketDisconnect:
+        manager.disconnect(session_id)
+        logger.info(f"Connexion WebSocket fermée: {session_id}")
+    except Exception as e:
+        logger.error(f"Erreur WebSocket: {e}")
+        manager.disconnect(session_id)
+
+
+# Endpoints REST
+@app.get("/", response_class=HTMLResponse)
+async def get_test_page():
+    """Page de test pour les connexions WebSocket"""
+    return """
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>WebSocket Notification Test</title>
+            <style>
+                body { font-family: Arial, sans-serif; padding: 20px; }
+                .container { max-width: 800px; margin: 0 auto; }
+                .messages { height: 300px; overflow-y: auto; border: 1px solid #ccc; padding: 10px; margin: 10px 0; }
+                .message { margin: 5px 0; padding: 5px; border-radius: 3px; }
+                .notification { background-color: #e7f3ff; }
+                .system { background-color: #f0f0f0; }
+                input, button { margin: 5px; padding: 5px; }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <h1>WebSocket Notification Test</h1>
+                <div>
+                    <input type="text" id="userId" placeholder="User ID" value="user123">
+                    <input type="text" id="roles" placeholder="Roles (comma-separated)" value="admin,user">
+                    <button onclick="connect()">Connect</button>
+                    <button onclick="disconnect()">Disconnect</button>
+                </div>
+                <div id="messages" class="messages"></div>
+                <div>
+                    <input type="text" id="messageInput" placeholder="Type a message...">
+                    <button onclick="sendMessage()">Send</button>
+                </div>
+            </div>
+
+            <script>
+                let ws = null;
+
+                function connect() {
+                    const userId = document.getElementById('userId').value;
+                    const roles = document.getElementById('roles').value;
+                    const url = `ws://localhost:8000/ws/${userId}?roles=${roles}`;
+
+                    ws = new WebSocket(url);
+
+                    ws.onmessage = function(event) {
+                        const data = JSON.parse(event.data);
+                        addMessage(data, 'notification');
+                    };
+
+                    ws.onopen = function() {
+                        addMessage({message: 'Connected to WebSocket'}, 'system');
+                    };
+
+                    ws.onclose = function() {
+                        addMessage({message: 'Disconnected from WebSocket'}, 'system');
+                    };
+                }
+
+                function disconnect() {
+                    if (ws) {
+                        ws.close();
+                        ws = null;
+                    }
+                }
+
+                function sendMessage() {
+                    if (ws && ws.readyState === WebSocket.OPEN) {
+                        const message = document.getElementById('messageInput').value;
+                        ws.send(JSON.stringify({message: message}));
+                        document.getElementById('messageInput').value = '';
+                    }
+                }
+
+                function addMessage(data, type) {
+                    const messages = document.getElementById('messages');
+                    const messageDiv = document.createElement('div');
+                    messageDiv.className = `message ${type}`;
+                    messageDiv.innerHTML = `<strong>${data.type || 'message'}:</strong> ${data.message || JSON.stringify(data)}`;
+                    messages.appendChild(messageDiv);
+                    messages.scrollTop = messages.scrollHeight;
+                }
+
+                // Auto-connect on page load
+                connect();
+            </script>
+        </body>
+        </html>
+        """
+
+
+@app.post("/subscriptions/{session_id}")
+async def add_subscription(
+    session_id: str = Depends(validate_session),
+    subscription_request: SubscriptionRequest = None,
+):
+    """Ajoute un nouvel abonnement pour une session"""
+    subscription = Subscription(**subscription_request.model_dump())
+
+    if not manager.add_subscription(session_id, subscription):
+        raise HTTPException(status_code=400, detail="Échec de l'ajout de l'abonnement")
+
+    return {
+        "message": "Abonnement ajouté avec succès",
+        "subscription_id": subscription.id,
+    }
+
+
+@app.delete("/subscriptions/{session_id}/{subscription_id}")
+async def remove_subscription(
+    subscription_id: str,
+    session_id: str = Depends(validate_session),
+):
+    """Supprime un abonnement existant"""
+    if not manager.remove_subscription(session_id, subscription_id):
+        raise HTTPException(status_code=404, detail="Abonnement introuvable")
+
+    return {"message": "Abonnement supprimé avec succès"}
+
+
+@app.get("/subscriptions/{session_id}")
+async def get_subscriptions(session_id: str = Depends(validate_session)):
+    """Récupère les abonnements d'une session"""
+    return manager.get_subscriptions(session_id)
+
+
+@app.post("/notifications/user/{user_id}")
+async def send_user_notification(
+    user_id: str, notification_request: NotificationRequest
+):
+    """Envoie une notification à un utilisateur spécifique"""
+    notification = Notification(**notification_request.model_dump())
+    await manager.send_to_user(user_id, notification)
+
+    return {
+        "message": f"Notification envoyée à l'utilisateur {user_id}",
+        "notification_id": notification.id,
+    }
+
+
+@app.post("/notifications/role/{role}")
+async def send_role_notification(role: str, notification_request: NotificationRequest):
+    """Envoie une notification à un rôle spécifique"""
+    notification = Notification(**notification_request.model_dump())
+    await manager.send_to_role(role, notification)
+
+    return {
+        "message": f"Notification envoyée au rôle {role}",
+        "notification_id": notification.id,
+    }
+
+
+@app.post("/notifications/broadcast")
+async def broadcast_notification(notification_request: NotificationRequest):
+    """Diffuse une notification à tous les clients connectés"""
+    notification = Notification(**notification_request.model_dump())
+    await manager.broadcast_notification(notification)
+
+    return {
+        "message": "Notification diffusée",
+        "notification_id": notification.id,
+    }
+
+
+@app.post("/notifications/send")
+async def send_targeted_notification(request: BroadcastRequest):
+    """Envoie une notification ciblée"""
+    notification = Notification(**request.notification.model_dump())
+
+    if request.target_type == "user":
+        await manager.send_to_user(request.target_value, notification)
+    elif request.target_type == "role":
+        await manager.send_to_role(request.target_value, notification)
+    elif request.target_type == "global":
+        await manager.broadcast_notification(notification)
+    else:
+        raise HTTPException(status_code=400, detail="Type de cible invalide")
+
+    return {
+        "message": f"Notification envoyée à {request.target_type}: {request.target_value}",
+        "notification_id": notification.id,
+    }
+
+
+@app.get("/notifications/history")
+async def get_notification_history(limit: int = 100):
+    """Récupère l'historique des notifications"""
+    return manager.get_notification_history(limit)
+
+
+@app.get("/stats")
+async def get_service_stats():
+    """Récupère les statistiques du service"""
+    return manager.get_stats()
+
+
+@app.get("/clients")
+async def get_connected_clients():
+    """Récupère la liste des clients connectés"""
+    clients = [
+        {
+            "session_id": session_id,
+            "user_id": info.user_id,
+            "user_roles": info.user_roles,
+            "connected_at": info.connected_at.isoformat(),
+            "subscriptions": len(manager.subscriptions.get(session_id, [])),
+        }
+        for session_id, info in manager.client_info.items()
+    ]
+    return {"clients": clients}
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "main:app",
+        host=manager.settings.APP_HOST,
+        port=manager.settings.APP_PORT,
+        reload=True,
+        log_level="info",
+        server_header=False,
+    )

requirements.txt

@@ -0,0 +1,4 @@
+colorama
+PyYAML
+pydantic
+fastapi