forge-mvc-stats 1.0.0b7__tar.gz

forge_mvc_stats-1.0.0b7/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: forge-mvc-stats
+Version: 1.0.0b7
+Summary: Forge stats — événements génériques, schéma SQL, tracking et consultation.
+Author: Roger Cauchon
+License-Expression: LicenseRef-Forge-Proprietary
+Project-URL: Homepage, https://github.com/caucrogeGit/Forge
+Project-URL: Repository, https://github.com/caucrogeGit/Forge
+Project-URL: Documentation, https://caucrogegit.github.io/Forge/
+Keywords: python,mvc,forge,stats,statistiques
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: forge-mvc<2,>=1.0.0b5
+
+# forge-mvc-stats
+
+Module stats pour Forge — événements génériques, schéma SQL, tracking et consultation.
+
+Extrait du core Forge depuis la version 2.8.0 (ADR-004).
+
+## Installation
+
+```bash
+pip install forge-mvc-stats
+# ou en mode developpement
+pip install -e packages/forge-mvc-stats/
+```
+
+## Usage
+
+```python
+from forge_mvc_stats import make_event, track_event
+
+# Créer un événement
+event = make_event(
+    "page_view",
+    label="Vue de page",
+    category="traffic",
+    metadata={"path": "/contact"},
+)
+
+# Enregistrer dans la base (db.execute est fourni par l'application)
+track_event(db.execute, event)
+
+# Raccourci direct par nom
+track_event(db.execute, "contact_click", label="Clic contact")
+```
+
+## Consultation
+
+```python
+from forge_mvc_stats import list_stats_events
+
+# Lister les 50 derniers événements (fetch_all est fourni par l'application)
+events = list_stats_events(my_fetch_all)
+
+# Filtrer par nom ou catégorie
+page_views = list_stats_events(my_fetch_all, name="page_view")
+traffic    = list_stats_events(my_fetch_all, category="traffic", limit=100)
+```
+
+## Schéma SQL
+
+```python
+from forge_mvc_stats import get_stats_events_schema_sql, STATS_EVENTS_TABLE
+
+print(STATS_EVENTS_TABLE)           # "forge_stats_events"
+sql = get_stats_events_schema_sql() # CREATE TABLE IF NOT EXISTS forge_stats_events (...)
+```
+
+## Cas d'usage
+
+- Comptage de visites de pages
+- Suivi de clics sur des liens ou boutons
+- Mesure de soumissions de formulaires
+- Traçage d'événements métier applicatifs
+
+## API publique
+
+- `StatsEvent` — dataclass d'événement (name, label, category, metadata)
+- `StatsEventError` — exception de validation
+- `make_event(name, label, category, metadata)` — crée et valide un événement
+- `validate_event(event)` — valide un événement existant
+- `normalize_event_name(value)` — normalise en snake_case
+- `validate_event_name(value)` — valide un nom normalisé
+- `STATS_EVENTS_TABLE` — nom de la table SQL (`forge_stats_events`)
+- `STATS_EVENTS_COLUMNS` — tuple des colonnes
+- `get_stats_events_schema_sql()` — SQL `CREATE TABLE IF NOT EXISTS`
+- `track_event(execute, event_or_name, ...)` — enregistre un événement en base
+- `get_track_event_sql()` — SQL `INSERT` paramétré
+- `prepare_track_event_values(event)` — tuple de paramètres prêts pour `execute`
+- `list_stats_events(fetch_all, name, category, limit)` — liste des événements normalisés
+- `get_stats_events_admin_sql(name, category, limit)` — SQL `SELECT` filtré
+- `prepare_stats_events_admin_params(name, category, limit)` — paramètres du SELECT
+- `normalize_stats_event_row(row)` — normalise une ligne brute (metadata JSON → dict)
+- `StatsAdminError` — exception de consultation

forge_mvc_stats-1.0.0b7/README.md

@@ -0,0 +1,82 @@
+# forge-mvc-stats
+
+Module stats pour Forge — événements génériques, schéma SQL, tracking et consultation.
+
+Extrait du core Forge depuis la version 2.8.0 (ADR-004).
+
+## Installation
+
+```bash
+pip install forge-mvc-stats
+# ou en mode developpement
+pip install -e packages/forge-mvc-stats/
+```
+
+## Usage
+
+```python
+from forge_mvc_stats import make_event, track_event
+
+# Créer un événement
+event = make_event(
+    "page_view",
+    label="Vue de page",
+    category="traffic",
+    metadata={"path": "/contact"},
+)
+
+# Enregistrer dans la base (db.execute est fourni par l'application)
+track_event(db.execute, event)
+
+# Raccourci direct par nom
+track_event(db.execute, "contact_click", label="Clic contact")
+```
+
+## Consultation
+
+```python
+from forge_mvc_stats import list_stats_events
+
+# Lister les 50 derniers événements (fetch_all est fourni par l'application)
+events = list_stats_events(my_fetch_all)
+
+# Filtrer par nom ou catégorie
+page_views = list_stats_events(my_fetch_all, name="page_view")
+traffic    = list_stats_events(my_fetch_all, category="traffic", limit=100)
+```
+
+## Schéma SQL
+
+```python
+from forge_mvc_stats import get_stats_events_schema_sql, STATS_EVENTS_TABLE
+
+print(STATS_EVENTS_TABLE)           # "forge_stats_events"
+sql = get_stats_events_schema_sql() # CREATE TABLE IF NOT EXISTS forge_stats_events (...)
+```
+
+## Cas d'usage
+
+- Comptage de visites de pages
+- Suivi de clics sur des liens ou boutons
+- Mesure de soumissions de formulaires
+- Traçage d'événements métier applicatifs
+
+## API publique
+
+- `StatsEvent` — dataclass d'événement (name, label, category, metadata)
+- `StatsEventError` — exception de validation
+- `make_event(name, label, category, metadata)` — crée et valide un événement
+- `validate_event(event)` — valide un événement existant
+- `normalize_event_name(value)` — normalise en snake_case
+- `validate_event_name(value)` — valide un nom normalisé
+- `STATS_EVENTS_TABLE` — nom de la table SQL (`forge_stats_events`)
+- `STATS_EVENTS_COLUMNS` — tuple des colonnes
+- `get_stats_events_schema_sql()` — SQL `CREATE TABLE IF NOT EXISTS`
+- `track_event(execute, event_or_name, ...)` — enregistre un événement en base
+- `get_track_event_sql()` — SQL `INSERT` paramétré
+- `prepare_track_event_values(event)` — tuple de paramètres prêts pour `execute`
+- `list_stats_events(fetch_all, name, category, limit)` — liste des événements normalisés
+- `get_stats_events_admin_sql(name, category, limit)` — SQL `SELECT` filtré
+- `prepare_stats_events_admin_params(name, category, limit)` — paramètres du SELECT
+- `normalize_stats_event_row(row)` — normalise une ligne brute (metadata JSON → dict)
+- `StatsAdminError` — exception de consultation

forge_mvc_stats-1.0.0b7/forge_mvc_stats/__init__.py

@@ -0,0 +1,51 @@
+"""Forge stats — événements génériques, schéma SQL, tracking et consultation."""
+
+from __future__ import annotations
+
+from forge_mvc_stats.admin import (
+    StatsAdminError,
+    get_stats_events_admin_sql,
+    list_stats_events,
+    normalize_stats_event_row,
+    prepare_stats_events_admin_params,
+)
+from forge_mvc_stats.events import (
+    StatsEvent,
+    StatsEventError,
+    make_event,
+    normalize_event_name,
+    validate_event,
+    validate_event_name,
+)
+from forge_mvc_stats.schema import (
+    STATS_EVENTS_COLUMNS,
+    STATS_EVENTS_TABLE,
+    get_stats_events_schema_sql,
+)
+from forge_mvc_stats.tracking import (
+    get_track_event_sql,
+    prepare_track_event_values,
+    track_event,
+)
+
+__version__ = "1.0.0b7"
+
+__all__ = [
+    "StatsEvent",
+    "StatsEventError",
+    "normalize_event_name",
+    "validate_event_name",
+    "make_event",
+    "validate_event",
+    "STATS_EVENTS_TABLE",
+    "STATS_EVENTS_COLUMNS",
+    "get_stats_events_schema_sql",
+    "get_track_event_sql",
+    "prepare_track_event_values",
+    "track_event",
+    "StatsAdminError",
+    "get_stats_events_admin_sql",
+    "prepare_stats_events_admin_params",
+    "normalize_stats_event_row",
+    "list_stats_events",
+]

forge_mvc_stats-1.0.0b7/forge_mvc_stats/admin.py

@@ -0,0 +1,139 @@
+"""API de consultation admin simple des événements statistiques Forge."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable, Iterable
+
+from .events import StatsEventError, validate_event_name
+from .schema import STATS_EVENTS_TABLE
+
+_DEFAULT_LIMIT = 50
+_MAX_LIMIT = 500
+_REQUIRED_COLUMNS = ("id", "name", "label", "category", "metadata", "created_at")
+
+
+class StatsAdminError(ValueError):
+    pass
+
+
+def _validate_limit(limit: int) -> int:
+    if not isinstance(limit, int) or isinstance(limit, bool):
+        raise StatsAdminError(
+            f"limit doit être un entier, reçu : {type(limit).__name__}."
+        )
+    if limit < 1:
+        raise StatsAdminError(f"limit doit être ≥ 1, reçu : {limit}.")
+    return min(limit, _MAX_LIMIT)
+
+
+def get_stats_events_admin_sql(
+    name: str | None = None,
+    category: str | None = None,
+    limit: int = _DEFAULT_LIMIT,
+) -> str:
+    """Return the SELECT SQL for listing stats events with optional filters."""
+    parts = [
+        f"SELECT id, name, label, category, metadata, created_at"
+        f" FROM {STATS_EVENTS_TABLE}"
+        f" WHERE 1 = 1",
+    ]
+    if name is not None:
+        parts.append(" AND name = ?")
+    if category is not None:
+        parts.append(" AND category = ?")
+    parts.append(" ORDER BY created_at DESC, id DESC")
+    parts.append(" LIMIT ?")
+    return "".join(parts)
+
+
+def prepare_stats_events_admin_params(
+    name: str | None = None,
+    category: str | None = None,
+    limit: int = _DEFAULT_LIMIT,
+) -> tuple:
+    """Return the SQL parameter tuple for a stats events query."""
+    if name is not None:
+        try:
+            name = validate_event_name(name)
+        except StatsEventError as exc:
+            raise StatsAdminError(str(exc)) from exc
+    if category is not None:
+        if not isinstance(category, str) or not category.strip():
+            raise StatsAdminError(
+                "category doit être une chaîne non vide."
+            )
+        category = category.strip()
+    effective_limit = _validate_limit(limit)
+    params: list[Any] = []
+    if name is not None:
+        params.append(name)
+    if category is not None:
+        params.append(category)
+    params.append(effective_limit)
+    return tuple(params)
+
+
+def normalize_stats_event_row(row: dict[str, Any]) -> dict[str, Any]:
+    """Normalize a raw DB row into a clean stats event dict.
+
+    metadata is deserialized from JSON string to dict.
+    Missing required columns or invalid JSON raises StatsAdminError.
+    """
+    if not isinstance(row, dict):
+        raise StatsAdminError(
+            f"Une ligne dict est attendue, reçu : {type(row).__name__}."
+        )
+    missing = [col for col in _REQUIRED_COLUMNS if col not in row]
+    if missing:
+        raise StatsAdminError(
+            f"Colonnes manquantes dans la ligne : {', '.join(missing)}."
+        )
+    raw_metadata = row["metadata"]
+    if raw_metadata is None or raw_metadata == "":
+        metadata: dict[str, Any] = {}
+    elif isinstance(raw_metadata, dict):
+        metadata = raw_metadata
+    elif isinstance(raw_metadata, str):
+        try:
+            parsed = json.loads(raw_metadata)
+        except json.JSONDecodeError as exc:
+            raise StatsAdminError(
+                f"metadata JSON invalide : {exc}"
+            ) from exc
+        if not isinstance(parsed, dict):
+            raise StatsAdminError(
+                "metadata JSON doit représenter un objet, "
+                f"reçu : {type(parsed).__name__}."
+            )
+        metadata = parsed
+    else:
+        raise StatsAdminError(
+            f"metadata doit être une chaîne JSON ou None, "
+            f"reçu : {type(raw_metadata).__name__}."
+        )
+    return {
+        "id": row["id"],
+        "name": row["name"],
+        "label": row["label"],
+        "category": row["category"],
+        "metadata": metadata,
+        "created_at": row["created_at"],
+    }
+
+
+def list_stats_events(
+    fetch_all: Callable[[str, tuple], Iterable[dict]],
+    name: str | None = None,
+    category: str | None = None,
+    limit: int = _DEFAULT_LIMIT,
+) -> list[dict[str, Any]]:
+    """List stats events from the database using the provided fetch_all executor.
+
+    Returns a list of normalized dicts. The caller must supply fetch_all —
+    Forge never accesses the database automatically.
+    """
+    sql = get_stats_events_admin_sql(name=name, category=category, limit=limit)
+    params = prepare_stats_events_admin_params(name=name, category=category, limit=limit)
+    rows = fetch_all(sql, params)
+    return [normalize_stats_event_row(row) for row in rows]

forge_mvc_stats-1.0.0b7/forge_mvc_stats/events.py

@@ -0,0 +1,106 @@
+"""Événements statistiques génériques pour Forge.
+
+Les noms d'événements sont de simples chaînes snake_case définies par l'application.
+Forge ne préconise aucune liste de noms — ce principe est conforme à la Charte Forge
+(Principe 1 : le framework n'est pas l'application).
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+
+_VALID_NAME_RE = re.compile(r"^[a-z][a-z0-9_]*$")
+_SAFE_NORMALIZE_RE = re.compile(r"[\s\-]+")
+_UNSAFE_CHARS_RE = re.compile(r"[^a-z0-9_\s\-]")
+
+
+class StatsEventError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class StatsEvent:
+    name: str
+    label: str = ""
+    category: str = "general"
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        validated_name = validate_event_name(self.name)
+        object.__setattr__(self, "name", validated_name)
+        if not self.label:
+            object.__setattr__(self, "label", validated_name)
+        if not self.category:
+            object.__setattr__(self, "category", "general")
+        if self.metadata is None:
+            object.__setattr__(self, "metadata", {})
+        if not isinstance(self.metadata, dict):
+            raise StatsEventError(
+                f"metadata doit être un dictionnaire, reçu : {type(self.metadata).__name__}."
+            )
+
+
+def normalize_event_name(value: str) -> str:
+    """Convert a raw string to a valid snake_case event name.
+
+    Spaces and hyphens are converted to underscores.
+    Any other non-alphanumeric character raises StatsEventError.
+    """
+    if not isinstance(value, str):
+        raise StatsEventError("Le nom d'événement doit être une chaîne.")
+    lowered = value.strip().lower()
+    if _UNSAFE_CHARS_RE.search(lowered):
+        raise StatsEventError(
+            f"Le nom d'événement '{value}' contient des caractères non autorisés. "
+            "Utilisez uniquement des lettres, des chiffres, des espaces et des tirets."
+        )
+    normalized = _SAFE_NORMALIZE_RE.sub("_", lowered)
+    normalized = re.sub(r"_+", "_", normalized).strip("_")
+    return normalized
+
+
+def validate_event_name(value: str) -> str:
+    """Validate and return a normalized event name, or raise StatsEventError."""
+    if not isinstance(value, str):
+        raise StatsEventError("Le nom d'événement doit être une chaîne.")
+    if not value or not value.strip():
+        raise StatsEventError("Le nom d'événement ne peut pas être vide.")
+    normalized = normalize_event_name(value)
+    if not normalized:
+        raise StatsEventError(
+            f"Le nom d'événement '{value}' est invalide après normalisation."
+        )
+    if not _VALID_NAME_RE.match(normalized):
+        raise StatsEventError(
+            f"Le nom d'événement '{value}' est invalide. "
+            "Format attendu : lettres minuscules, chiffres et tirets bas, "
+            "commençant par une lettre."
+        )
+    return normalized
+
+
+def make_event(
+    name: str,
+    label: str = "",
+    category: str = "general",
+    metadata: dict[str, Any] | None = None,
+) -> StatsEvent:
+    """Create a validated StatsEvent."""
+    return StatsEvent(
+        name=name,
+        label=label,
+        category=category,
+        metadata=metadata if metadata is not None else {},
+    )
+
+
+def validate_event(event: StatsEvent) -> StatsEvent:
+    """Validate an existing StatsEvent and return it, or raise StatsEventError."""
+    if not isinstance(event, StatsEvent):
+        raise StatsEventError(
+            f"Un StatsEvent est attendu, reçu : {type(event).__name__}."
+        )
+    return event

forge_mvc_stats-1.0.0b7/forge_mvc_stats/schema.py

@@ -0,0 +1,33 @@
+"""Définition SQL générique de la table d'événements statistiques Forge."""
+
+from __future__ import annotations
+
+STATS_EVENTS_TABLE = "forge_stats_events"
+
+STATS_EVENTS_COLUMNS = (
+    "id",
+    "name",
+    "label",
+    "category",
+    "metadata",
+    "created_at",
+)
+
+_SQL = """\
+CREATE TABLE IF NOT EXISTS forge_stats_events (
+    id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
+    name VARCHAR(100) NOT NULL,
+    label VARCHAR(150) NOT NULL,
+    category VARCHAR(100) NOT NULL DEFAULT 'general',
+    metadata JSON NULL,
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (id),
+    INDEX idx_forge_stats_events_name (name),
+    INDEX idx_forge_stats_events_category (category),
+    INDEX idx_forge_stats_events_created_at (created_at)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;"""
+
+
+def get_stats_events_schema_sql() -> str:
+    """Return the SQL CREATE TABLE statement for forge_stats_events."""
+    return _SQL

forge_mvc_stats-1.0.0b7/forge_mvc_stats/tracking.py

@@ -0,0 +1,73 @@
+"""Helper Python explicite de tracking statistique pour Forge."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable
+
+from .events import StatsEvent, StatsEventError, make_event, validate_event
+from .schema import STATS_EVENTS_TABLE
+
+_INSERT_SQL = (
+    f"INSERT INTO {STATS_EVENTS_TABLE}"
+    " (name, label, category, metadata)"
+    " VALUES (?, ?, ?, ?)"
+)
+
+
+def get_track_event_sql() -> str:
+    """Return the INSERT SQL for recording a stats event."""
+    return _INSERT_SQL
+
+
+def _serialize_metadata(metadata: dict[str, Any]) -> str:
+    try:
+        return json.dumps(metadata, ensure_ascii=False, sort_keys=True)
+    except (TypeError, ValueError) as exc:
+        raise StatsEventError(
+            f"metadata non sérialisable en JSON : {exc}"
+        ) from exc
+
+
+def prepare_track_event_values(event: StatsEvent) -> tuple[str, str, str, str]:
+    """Return the SQL parameter tuple for a StatsEvent."""
+    if not isinstance(event, StatsEvent):
+        raise StatsEventError(
+            f"Un StatsEvent est attendu, reçu : {type(event).__name__}."
+        )
+    return (
+        event.name,
+        event.label,
+        event.category,
+        _serialize_metadata(event.metadata),
+    )
+
+
+def track_event(
+    execute: Callable,
+    event_or_name: StatsEvent | str,
+    label: str = "",
+    category: str = "general",
+    metadata: dict[str, Any] | None = None,
+) -> StatsEvent:
+    """Record a stats event by calling the provided SQL executor.
+
+    The executor must be callable as execute(sql, params).
+    Forge never calls this automatically — the developer must call it explicitly.
+    """
+    if isinstance(event_or_name, StatsEvent):
+        event = validate_event(event_or_name)
+    elif isinstance(event_or_name, str):
+        event = make_event(
+            name=event_or_name,
+            label=label,
+            category=category,
+            metadata=metadata,
+        )
+    else:
+        raise StatsEventError(
+            "event_or_name doit être un StatsEvent ou un nom d'événement, "
+            f"reçu : {type(event_or_name).__name__}."
+        )
+    execute(get_track_event_sql(), prepare_track_event_values(event))
+    return event

forge_mvc_stats-1.0.0b7/forge_mvc_stats.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: forge-mvc-stats
+Version: 1.0.0b7
+Summary: Forge stats — événements génériques, schéma SQL, tracking et consultation.
+Author: Roger Cauchon
+License-Expression: LicenseRef-Forge-Proprietary
+Project-URL: Homepage, https://github.com/caucrogeGit/Forge
+Project-URL: Repository, https://github.com/caucrogeGit/Forge
+Project-URL: Documentation, https://caucrogegit.github.io/Forge/
+Keywords: python,mvc,forge,stats,statistiques
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: forge-mvc<2,>=1.0.0b5
+
+# forge-mvc-stats
+
+Module stats pour Forge — événements génériques, schéma SQL, tracking et consultation.
+
+Extrait du core Forge depuis la version 2.8.0 (ADR-004).
+
+## Installation
+
+```bash
+pip install forge-mvc-stats
+# ou en mode developpement
+pip install -e packages/forge-mvc-stats/
+```
+
+## Usage
+
+```python
+from forge_mvc_stats import make_event, track_event
+
+# Créer un événement
+event = make_event(
+    "page_view",
+    label="Vue de page",
+    category="traffic",
+    metadata={"path": "/contact"},
+)
+
+# Enregistrer dans la base (db.execute est fourni par l'application)
+track_event(db.execute, event)
+
+# Raccourci direct par nom
+track_event(db.execute, "contact_click", label="Clic contact")
+```
+
+## Consultation
+
+```python
+from forge_mvc_stats import list_stats_events
+
+# Lister les 50 derniers événements (fetch_all est fourni par l'application)
+events = list_stats_events(my_fetch_all)
+
+# Filtrer par nom ou catégorie
+page_views = list_stats_events(my_fetch_all, name="page_view")
+traffic    = list_stats_events(my_fetch_all, category="traffic", limit=100)
+```
+
+## Schéma SQL
+
+```python
+from forge_mvc_stats import get_stats_events_schema_sql, STATS_EVENTS_TABLE
+
+print(STATS_EVENTS_TABLE)           # "forge_stats_events"
+sql = get_stats_events_schema_sql() # CREATE TABLE IF NOT EXISTS forge_stats_events (...)
+```
+
+## Cas d'usage
+
+- Comptage de visites de pages
+- Suivi de clics sur des liens ou boutons
+- Mesure de soumissions de formulaires
+- Traçage d'événements métier applicatifs
+
+## API publique
+
+- `StatsEvent` — dataclass d'événement (name, label, category, metadata)
+- `StatsEventError` — exception de validation
+- `make_event(name, label, category, metadata)` — crée et valide un événement
+- `validate_event(event)` — valide un événement existant
+- `normalize_event_name(value)` — normalise en snake_case
+- `validate_event_name(value)` — valide un nom normalisé
+- `STATS_EVENTS_TABLE` — nom de la table SQL (`forge_stats_events`)
+- `STATS_EVENTS_COLUMNS` — tuple des colonnes
+- `get_stats_events_schema_sql()` — SQL `CREATE TABLE IF NOT EXISTS`
+- `track_event(execute, event_or_name, ...)` — enregistre un événement en base
+- `get_track_event_sql()` — SQL `INSERT` paramétré
+- `prepare_track_event_values(event)` — tuple de paramètres prêts pour `execute`
+- `list_stats_events(fetch_all, name, category, limit)` — liste des événements normalisés
+- `get_stats_events_admin_sql(name, category, limit)` — SQL `SELECT` filtré
+- `prepare_stats_events_admin_params(name, category, limit)` — paramètres du SELECT
+- `normalize_stats_event_row(row)` — normalise une ligne brute (metadata JSON → dict)
+- `StatsAdminError` — exception de consultation

forge_mvc_stats-1.0.0b7/forge_mvc_stats.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+forge_mvc_stats/__init__.py
+forge_mvc_stats/admin.py
+forge_mvc_stats/events.py
+forge_mvc_stats/schema.py
+forge_mvc_stats/tracking.py
+forge_mvc_stats.egg-info/PKG-INFO
+forge_mvc_stats.egg-info/SOURCES.txt
+forge_mvc_stats.egg-info/dependency_links.txt
+forge_mvc_stats.egg-info/requires.txt
+forge_mvc_stats.egg-info/top_level.txt

forge_mvc_stats-1.0.0b7/forge_mvc_stats.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

forge_mvc_stats-1.0.0b7/forge_mvc_stats.egg-info/requires.txt

@@ -0,0 +1 @@
+forge-mvc<2,>=1.0.0b5

forge_mvc_stats-1.0.0b7/forge_mvc_stats.egg-info/top_level.txt

@@ -0,0 +1 @@
+forge_mvc_stats

forge_mvc_stats-1.0.0b7/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "forge-mvc-stats"
+version = "1.0.0b7"
+description = "Forge stats — événements génériques, schéma SQL, tracking et consultation."
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.12"
+authors = [
+    { name = "Roger Cauchon" },
+]
+license = "LicenseRef-Forge-Proprietary"
+keywords = ["python", "mvc", "forge", "stats", "statistiques"]
+dependencies = [
+    "forge-mvc>=1.0.0b5,<2",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[project.urls]
+Homepage = "https://github.com/caucrogeGit/Forge"
+Repository = "https://github.com/caucrogeGit/Forge"
+Documentation = "https://caucrogegit.github.io/Forge/"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["forge_mvc_stats*"]

forge_mvc_stats-1.0.0b7/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+