forge-mvc-files 1.0.0b16__tar.gz

forge_mvc_files-1.0.0b16/LICENSE

@@ -0,0 +1,36 @@
+Forge — Licence propriétaire / source disponible
+
+Copyright (c) Roger Lequette.
+Tous droits réservés.
+
+Le code source de Forge est mis à disposition uniquement pour lecture, étude,
+évaluation et usage éducatif personnel.
+
+Sauf autorisation écrite préalable de Roger Lequette, il est interdit de :
+
+- utiliser Forge dans un cadre professionnel, commercial ou institutionnel ;
+- utiliser Forge pour une prestation client ;
+- intégrer Forge dans un produit, service, SaaS, application vendue ou solution
+  déployée pour un tiers ;
+- redistribuer Forge, modifié ou non ;
+- publier une version modifiée de Forge ;
+- vendre, louer, sous-licencier ou exploiter commercialement Forge ;
+- supprimer ou modifier les mentions de copyright et de licence.
+
+Les usages autorisés sans autorisation écrite préalable sont limités à :
+
+- lire le code ;
+- étudier son fonctionnement ;
+- tester Forge à titre personnel ;
+- l'utiliser dans un cadre éducatif personnel ou pédagogique non commercial ;
+- évaluer le framework avant une éventuelle demande d'autorisation.
+
+Toute utilisation non explicitement autorisée par cette licence nécessite une
+autorisation écrite préalable de Roger Lequette.
+
+Cette licence pourra évoluer ultérieurement. Toute version publiée de Forge
+reste soumise à la licence présente dans son dépôt au moment de sa récupération.
+
+LE LOGICIEL EST FOURNI « TEL QUEL », SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU
+IMPLICITE. EN AUCUN CAS LE DÉTENTEUR DU COPYRIGHT NE POURRA ÊTRE TENU
+RESPONSABLE DE TOUT DOMMAGE DÉCOULANT DE L'UTILISATION DE CE LOGICIEL.

forge_mvc_files-1.0.0b16/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: forge-mvc-files
+Version: 1.0.0b16
+Summary: Forge Files — module opt-in propriétaire de l'upload générique : écriture sécurisée, storage anti-traversal, service de fichiers, rate-limit. Extrait du core (ADR-019).
+Author: Roger Lequette
+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://forgemvc.com/docs/forge/
+Keywords: python,mvc,forge,files,upload,storage
+Classifier: Development Status :: 3 - Alpha
+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
+License-File: LICENSE
+Requires-Dist: forge-mvc<2,>=1.0.0b16
+Dynamic: license-file
+
+# forge-mvc-files
+
+Module **opt-in** propriétaire de l'**upload générique** dans Forge MVC :
+écriture disque sécurisée, storage anti-traversal, service de fichiers
+(streaming HTTP Range), suppression et rate-limit d'upload.
+
+## Statut : extraction complète (ADR-019)
+
+`forge-mvc-files` détient désormais **tout le pipeline d'upload générique**,
+extrait du core : `save_upload`, `SavedUpload`, `serve_media_file` (HTTP Range),
+storage anti-traversal, suppression et rate-limit. `core/uploads/` a été
+supprimé du core (`CORE-DROP-UPLOADS-001`). La **validation pure** de fichier
+(extension/MIME/taille + `UploadError`) reste dans le core (`core.forms`),
+réutilisée par ce paquet.
+
+Ce paquet cible la publication PyPI de la release beta.13.
+
+## Pourquoi ce module (ADR-019)
+
+Après l'extraction du traitement d'image (ADR-018), l'upload **générique** reste
+le dernier gros bloc applicatif logé dans le noyau. Un framework web peut
+exister sans upload de fichiers : c'est une brique applicative, pas un
+fondement. `forge-mvc-files` devient l'**unique** propriétaire de l'upload
+générique (principes 8 « noyau minimal » et 11 « une seule façon officielle »).
+
+### Ce qui a été déplacé du core
+
+- `manager` — `save_upload`, `SavedUpload`, `serve_media_file`, `delete_upload`,
+  `delete_media_file`, `get_upload_path`, `upload_root`, `_read_upload` ;
+- `storage` — écriture/anti-traversal (`normalize_media_path`,
+  `media_path_to_storage_path`, `is_safe_media_path`, `save_bytes`, `delete_file`) ;
+- `rate_limit` d'upload (`is_upload_rate_limited`, `record_upload_attempt`).
+
+### Ce qui reste dans le core (définitif)
+
+- Les **validators purs** (`validate_extension`, `validate_mime_type`,
+  `validate_size`) et la hiérarchie d'exceptions `UploadError` : `core/forms`
+  (`FileField`) en dépend, et le core ne peut pas dépendre d'un opt-in (ADR-004).
+  Ce sont des contrôles purs sans I/O. `forge-mvc-files` les réutilise.
+
+## Plan d'exécution (ADR-019)
+
+| Ticket | Description | État |
+|---|---|---|
+| `FILES-PKG-SCAFFOLD-001` | Squelette du paquet + enregistrement opt-in | livré |
+| `FILES-VALIDATORS-KEEP-001` | Relocaliser validators + exceptions dans le core | livré |
+| `FILES-MOVE-PIPELINE-001` | Déplacer manager + storage + rate_limit | livré |
+| `FILES-IMAGES-REPOINT-001` | forge-mvc-images dépend de forge-mvc-files | livré |
+| `FILES-CLI-RENAME-001` | Générateurs + forge_cli/uploads + starter | livré |
+| `FILES-DOCS-PERIMETER-001` | Docs + ADR-004 + CLAUDE.md §3 | livré |
+| `CORE-DROP-UPLOADS-001` | Suppression de `core/uploads/` | livré |
+
+## Installation (mode éditable, depuis les sources)
+
+```bash
+git clone https://github.com/caucrogeGit/Forge.git
+cd Forge
+pip install -e packages/forge-mvc-files/
+```
+
+## Référence
+
+- `docs/adr/019-upload-extraction.md` — décision et périmètre figés.
+- Charte principes 8 (noyau minimal), 11 (une seule façon officielle).

forge_mvc_files-1.0.0b16/README.md

@@ -0,0 +1,64 @@
+# forge-mvc-files
+
+Module **opt-in** propriétaire de l'**upload générique** dans Forge MVC :
+écriture disque sécurisée, storage anti-traversal, service de fichiers
+(streaming HTTP Range), suppression et rate-limit d'upload.
+
+## Statut : extraction complète (ADR-019)
+
+`forge-mvc-files` détient désormais **tout le pipeline d'upload générique**,
+extrait du core : `save_upload`, `SavedUpload`, `serve_media_file` (HTTP Range),
+storage anti-traversal, suppression et rate-limit. `core/uploads/` a été
+supprimé du core (`CORE-DROP-UPLOADS-001`). La **validation pure** de fichier
+(extension/MIME/taille + `UploadError`) reste dans le core (`core.forms`),
+réutilisée par ce paquet.
+
+Ce paquet cible la publication PyPI de la release beta.13.
+
+## Pourquoi ce module (ADR-019)
+
+Après l'extraction du traitement d'image (ADR-018), l'upload **générique** reste
+le dernier gros bloc applicatif logé dans le noyau. Un framework web peut
+exister sans upload de fichiers : c'est une brique applicative, pas un
+fondement. `forge-mvc-files` devient l'**unique** propriétaire de l'upload
+générique (principes 8 « noyau minimal » et 11 « une seule façon officielle »).
+
+### Ce qui a été déplacé du core
+
+- `manager` — `save_upload`, `SavedUpload`, `serve_media_file`, `delete_upload`,
+  `delete_media_file`, `get_upload_path`, `upload_root`, `_read_upload` ;
+- `storage` — écriture/anti-traversal (`normalize_media_path`,
+  `media_path_to_storage_path`, `is_safe_media_path`, `save_bytes`, `delete_file`) ;
+- `rate_limit` d'upload (`is_upload_rate_limited`, `record_upload_attempt`).
+
+### Ce qui reste dans le core (définitif)
+
+- Les **validators purs** (`validate_extension`, `validate_mime_type`,
+  `validate_size`) et la hiérarchie d'exceptions `UploadError` : `core/forms`
+  (`FileField`) en dépend, et le core ne peut pas dépendre d'un opt-in (ADR-004).
+  Ce sont des contrôles purs sans I/O. `forge-mvc-files` les réutilise.
+
+## Plan d'exécution (ADR-019)
+
+| Ticket | Description | État |
+|---|---|---|
+| `FILES-PKG-SCAFFOLD-001` | Squelette du paquet + enregistrement opt-in | livré |
+| `FILES-VALIDATORS-KEEP-001` | Relocaliser validators + exceptions dans le core | livré |
+| `FILES-MOVE-PIPELINE-001` | Déplacer manager + storage + rate_limit | livré |
+| `FILES-IMAGES-REPOINT-001` | forge-mvc-images dépend de forge-mvc-files | livré |
+| `FILES-CLI-RENAME-001` | Générateurs + forge_cli/uploads + starter | livré |
+| `FILES-DOCS-PERIMETER-001` | Docs + ADR-004 + CLAUDE.md §3 | livré |
+| `CORE-DROP-UPLOADS-001` | Suppression de `core/uploads/` | livré |
+
+## Installation (mode éditable, depuis les sources)
+
+```bash
+git clone https://github.com/caucrogeGit/Forge.git
+cd Forge
+pip install -e packages/forge-mvc-files/
+```
+
+## Référence
+
+- `docs/adr/019-upload-extraction.md` — décision et périmètre figés.
+- Charte principes 8 (noyau minimal), 11 (une seule façon officielle).

forge_mvc_files-1.0.0b16/forge_mvc_files/__init__.py

@@ -0,0 +1,75 @@
+"""Forge MVC Files — module opt-in propriétaire de l'upload générique.
+
+Ce paquet détient le **pipeline d'upload générique** extrait du core (ADR-019) :
+écriture disque sécurisée (anti-traversal), service de fichiers (`serve_media_file`,
+streaming HTTP Range), suppression, rate-limit d'upload, et l'API
+``save_upload`` / ``SavedUpload``.
+
+Depuis ``FILES-MOVE-PIPELINE-001``, ``manager`` + ``storage`` + ``rate_limit``
+vivent ici. La **validation pure** (validators + exceptions ``UploadError``)
+reste dans le core (``core.forms.upload_validation`` / ``upload_exceptions``),
+réutilisée ici : le core ne peut pas dépendre d'un opt-in (ADR-004). Le core
+expose des **shims transitoires** (``core/uploads``) supprimés au ticket
+``CORE-DROP-UPLOADS-001``. Voir ``docs/adr/019-upload-extraction.md``.
+"""
+
+from __future__ import annotations
+
+__version__ = "1.0.0b16"
+
+# Validation/exceptions : réexport depuis le core (où elles restent).
+from core.forms.upload_exceptions import (
+    UploadError,
+    UploadInvalidExtensionError,
+    UploadInvalidMimeTypeError,
+    UploadStorageError,
+    UploadTooLargeError,
+)
+from forge_mvc_files.manager import (
+    SavedUpload,
+    delete_media_file,
+    delete_upload,
+    get_upload_path,
+    save_upload,
+    serve_media_file,
+    upload_root,
+)
+from forge_mvc_files.rate_limit import (
+    is_upload_rate_limited,
+    record_upload_attempt,
+)
+from forge_mvc_files.storage import (
+    delete_file,
+    is_safe_media_path,
+    media_path_to_storage_path,
+    normalize_media_path,
+    save_bytes,
+    secure_filename,
+)
+
+__all__ = [
+    # Exceptions (réexportées du core)
+    "UploadError",
+    "UploadInvalidExtensionError",
+    "UploadInvalidMimeTypeError",
+    "UploadStorageError",
+    "UploadTooLargeError",
+    # Upload / service de fichiers (manager)
+    "SavedUpload",
+    "save_upload",
+    "serve_media_file",
+    "delete_upload",
+    "delete_media_file",
+    "get_upload_path",
+    "upload_root",
+    # Storage (anti-traversal)
+    "save_bytes",
+    "delete_file",
+    "normalize_media_path",
+    "media_path_to_storage_path",
+    "is_safe_media_path",
+    "secure_filename",
+    # Rate-limit d'upload
+    "is_upload_rate_limited",
+    "record_upload_attempt",
+]

forge_mvc_files-1.0.0b16/forge_mvc_files/manager.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import mimetypes
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from core.forge import get as _cfg
+from core.http.response import Response
+
+# FILES-MOVE-PIPELINE-001 (ADR-019) : le pipeline d'upload vit désormais dans
+# forge-mvc-files. La validation pure (validators + exceptions) reste dans le
+# core (core/forms), réutilisée ici (le core ne peut pas dépendre de l'opt-in).
+from core.forms.upload_exceptions import UploadStorageError
+from core.forms.upload_validation import validate_upload_metadata
+from forge_mvc_files import storage
+
+
+@dataclass(frozen=True)
+class SavedUpload:
+    filename: str
+    original_name: str
+    path: str
+    category: str
+    size: int
+    mime_type: str | None = None
+    variants: dict[str, str] = field(default_factory=dict)
+
+
+def _read_upload(file) -> tuple[str, str | None, bytes]:
+    filename = getattr(file, "filename", None) or getattr(file, "name", None)
+    mime_type = (
+        getattr(file, "content_type", None)
+        or getattr(file, "mimetype", None)
+        or getattr(file, "mime_type", None)
+    )
+
+    if hasattr(file, "content"):
+        data = file.content
+    elif hasattr(file, "read"):
+        data = file.read()
+    elif hasattr(file, "stream") and hasattr(file.stream, "read"):
+        data = file.stream.read()
+    else:
+        data = file
+
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    if data is None:
+        data = b""
+    if not isinstance(data, (bytes, bytearray)):
+        raise TypeError("Le fichier uploadé doit fournir des bytes ou une méthode read().")
+
+    return filename, mime_type, bytes(data)
+
+
+# ADR-032 : la config de stockage et de validation d'upload appartient à
+# l'opt-in files, lue directement depuis l'environnement. Seul `upload_max_size`
+# reste détenu par le noyau (borne le corps multipart dans core/http/request.py).
+_DEFAULT_EXTENSIONS = "jpg,jpeg,png,webp,pdf"
+_DEFAULT_MIME_TYPES = "image/jpeg,image/png,image/webp,application/pdf"
+
+
+def _env_list(key: str, default: str) -> list[str]:
+    return [item.strip() for item in os.getenv(key, default).split(",") if item.strip()]
+
+
+def upload_root() -> Path:
+    return Path(os.getenv("UPLOAD_ROOT", "storage/uploads"))
+
+
+def _require_image_processing(name: str):
+    """Résout un helper de traitement d'image depuis l'opt-in forge-mvc-images.
+
+    IMAGES-MOVE-PROCESSING-001 (ADR-018) : le traitement d'image (Pillow) a été
+    extrait du core vers ``forge-mvc-images``. Depuis
+    CORE-SAVEUPLOAD-GENERIC-CLEANUP, ``save_upload`` est purement générique ; il
+    ne reste qu'un seul appelant de ce delegate dans le core :
+    ``delete_media_file(variants=True)``, qui a besoin des chemins de variantes
+    (``image_variant_relative_paths``) pour supprimer les fichiers dérivés. Si
+    l'opt-in est absent, l'erreur est explicite plutôt qu'un ``ImportError`` brut
+    (charte §7 — sécuriser/échouer clairement).
+    """
+    try:
+        import forge_mvc_images
+    except ImportError as exc:  # pragma: no cover - dépend de l'environnement
+        raise UploadStorageError(
+            "Le traitement d'image requiert l'opt-in forge-mvc-images "
+            "(pip install forge-mvc-images)."
+        ) from exc
+    return getattr(forge_mvc_images, name)
+
+
+def save_upload(file, category: str = "documents") -> SavedUpload:
+    """Upload brut **générique** : valide, écrit, retourne un SavedUpload.
+
+    CORE-SAVEUPLOAD-GENERIC-CLEANUP (ADR-018) : ``save_upload`` ne connaît plus
+    rien des images (ni vérification de contenu, ni variantes). Le chemin
+    image-aware (vérification + variantes) appartient à l'opt-in
+    ``forge-mvc-images`` (``save_image_upload``), qui s'appuie lui-même sur cette
+    primitive générique. ``variants`` renvoyé est toujours vide ici.
+    """
+    if file is None:
+        raise UploadStorageError("Aucun fichier reçu.")
+
+    filename, mime_type, data = _read_upload(file)
+    validate_upload_metadata(
+        filename=filename,
+        size=len(data),
+        mime_type=mime_type,
+        allowed_extensions=_env_list("UPLOAD_ALLOWED_EXTENSIONS", _DEFAULT_EXTENSIONS),
+        allowed_mime_types=_env_list("UPLOAD_ALLOWED_MIME_TYPES", _DEFAULT_MIME_TYPES),
+        max_size=int(_cfg("upload_max_size")),
+    )
+    root = upload_root()
+    saved_path = storage.save_bytes(
+        data,
+        original_name=filename,
+        category=category,
+        root=root,
+    )
+    relative_path = saved_path.relative_to(root.resolve()).as_posix()
+    normalized_path = storage.normalize_media_path(relative_path)
+
+    return SavedUpload(
+        filename=saved_path.name,
+        original_name=filename,
+        path=normalized_path,
+        category=category,
+        size=len(data),
+        mime_type=mime_type,
+        variants={},
+    )
+
+
+def delete_upload(path) -> bool:
+    return storage.delete_file(path, root=upload_root())
+
+
+def delete_media_file(path: str, *, root: str | Path | None = None, variants: bool = False) -> dict[str, bool]:
+    if root is None:
+        root = upload_root()
+
+    relative_path = storage.normalize_media_path(path)
+    paths = {"original": relative_path}
+    if variants:
+        image_variant_relative_paths = _require_image_processing(
+            "image_variant_relative_paths"
+        )
+        paths = image_variant_relative_paths(relative_path)
+
+    return {
+        media_path: storage.delete_file(media_path, root=root)
+        for media_path in paths.values()
+    }
+
+
+def serve_media_file(path: str, *, root: str | Path | None = None) -> Response:
+    if root is None:
+        root = upload_root()
+
+    try:
+        relative_path = storage.normalize_media_path(path)
+        target = storage.media_path_to_storage_path(relative_path, root=root)
+        if not target.exists() or not target.is_file():
+            return Response(404, b"Not found", "text/plain; charset=utf-8")
+        content = target.read_bytes()
+    except (OSError, UploadStorageError):
+        return Response(404, b"Not found", "text/plain; charset=utf-8")
+
+    content_type = mimetypes.guess_type(target.name)[0] or "application/octet-stream"
+    return Response(200, content, content_type)
+
+
+def get_upload_path(filename: str, category: str = "documents") -> Path:
+    return storage.get_upload_path(filename, category, root=upload_root())

forge_mvc_files-1.0.0b16/forge_mvc_files/rate_limit.py

@@ -0,0 +1,53 @@
+"""Rate limiting pour les routes d'upload (mémoire, fenêtre glissante).
+
+Même structure que core.security.hashing pour le login : dict en mémoire,
+thread-safe, fenêtre glissante. Les compteurs upload sont isolés des
+compteurs de connexion.
+
+Usage dans un contrôleur :
+
+    from forge_mvc_files.rate_limit import is_upload_rate_limited, record_upload_attempt
+
+    def upload_avatar(request):
+        if is_upload_rate_limited(request.ip):
+            body = json.dumps({
+                "success": False,
+                "error": {"code": "rate_limited", "message": "Trop d'uploads."},
+            }).encode()
+            return Response(429, body, "application/json")
+        record_upload_attempt(request.ip)
+        # ... traitement normal
+"""
+from __future__ import annotations
+
+import threading
+import time
+
+UPLOAD_MAX_PAR_FENETRE: int = 10      # uploads autorisés par fenêtre par IP
+UPLOAD_RATE_LIMIT_WINDOW: int = 60    # durée de la fenêtre glissante (secondes)
+
+_compteurs: dict[str, list[float]] = {}
+_lock = threading.Lock()
+
+
+def is_upload_rate_limited(ip: str) -> bool:
+    """Retourne True si l'IP a atteint la limite d'uploads sur la fenêtre courante."""
+    with _lock:
+        maintenant = time.time()
+        historique = _compteurs.get(ip, [])
+        recents = [t for t in historique if maintenant - t < UPLOAD_RATE_LIMIT_WINDOW]
+        if recents:
+            _compteurs[ip] = recents
+        else:
+            _compteurs.pop(ip, None)
+        return len(recents) >= UPLOAD_MAX_PAR_FENETRE
+
+
+def record_upload_attempt(ip: str) -> None:
+    """Enregistre une tentative d'upload pour cette IP."""
+    with _lock:
+        maintenant = time.time()
+        historique = _compteurs.get(ip, [])
+        historique.append(maintenant)
+        recents = [t for t in historique if maintenant - t < UPLOAD_RATE_LIMIT_WINDOW]
+        _compteurs[ip] = recents

forge_mvc_files-1.0.0b16/forge_mvc_files/storage.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import os
+import posixpath
+import re
+from pathlib import Path
+from uuid import uuid4
+
+# FILES-MOVE-PIPELINE-001 (ADR-019) : validation/exceptions restent dans le core.
+from core.forms.upload_exceptions import UploadStorageError
+
+
+_SAFE_CATEGORY = re.compile(r"^[A-Za-z0-9_-]+$")
+_UNSAFE_CHARS = re.compile(r"[^A-Za-z0-9._-]+")
+_URI_SCHEME = re.compile(r"^[A-Za-z][A-Za-z0-9+.-]*:")
+
+
+def ensure_upload_dirs(root: str | Path, categories=("images", "documents", "tmp")) -> list[Path]:
+    root_path = Path(root)
+    created: list[Path] = []
+    root_path.mkdir(parents=True, exist_ok=True)
+    created.append(root_path)
+    for category in categories:
+        directory = root_path / safe_category(category)
+        directory.mkdir(parents=True, exist_ok=True)
+        created.append(directory)
+    return created
+
+
+def safe_category(category: str) -> str:
+    category = (category or "").strip()
+    if not category or not _SAFE_CATEGORY.fullmatch(category):
+        raise UploadStorageError(f"Categorie d'upload invalide : {category!r}.")
+    return category
+
+
+def secure_filename(filename: str) -> str:
+    base = os.path.basename(filename or "").strip().replace(" ", "_")
+    base = _UNSAFE_CHARS.sub("_", base).strip("._")
+    if not base:
+        raise UploadStorageError("Nom de fichier vide apres normalisation.")
+    return base
+
+
+def generate_unique_filename(original_name: str) -> str:
+    safe_name = secure_filename(original_name)
+    path = Path(safe_name)
+    stem = path.stem or "upload"
+    suffix = path.suffix.lower()
+    return f"{stem}-{uuid4().hex}{suffix}"
+
+
+def normalize_media_path(path: str) -> str:
+    """Retourne un chemin media relatif, normalise et sur.
+
+    Le chemin retourne est destine a etre stocke en base, typiquement dans
+    `Media.path`. Il est toujours relatif a `storage/uploads`.
+    """
+    if not isinstance(path, str):
+        raise UploadStorageError("Chemin media invalide.")
+
+    value = path.strip()
+    if not value:
+        raise UploadStorageError("Chemin media vide.")
+    if "\x00" in value:
+        raise UploadStorageError("Chemin media invalide.")
+    if _URI_SCHEME.match(value):
+        raise UploadStorageError("Chemin media absolu ou URL interdit.")
+
+    value = value.replace("\\", "/")
+    while "//" in value:
+        value = value.replace("//", "/")
+    if value.startswith("/"):
+        raise UploadStorageError("Chemin media absolu interdit.")
+
+    normalized = posixpath.normpath(value)
+    if normalized in {"", "."}:
+        raise UploadStorageError("Chemin media vide.")
+    if normalized == "storage/uploads":
+        raise UploadStorageError("Chemin media incomplet.")
+    if normalized.startswith("storage/uploads/"):
+        normalized = normalized[len("storage/uploads/"):]
+
+    parts = normalized.split("/")
+    if any(part in {"", ".", ".."} for part in parts):
+        raise UploadStorageError("Chemin media avec traversal interdit.")
+    if normalized.startswith("../") or normalized == "..":
+        raise UploadStorageError("Chemin media avec traversal interdit.")
+    return normalized
+
+
+def is_safe_media_path(path: str) -> bool:
+    try:
+        normalize_media_path(path)
+    except UploadStorageError:
+        return False
+    return True
+
+
+def media_path_to_storage_path(path: str, *, root: str | Path) -> Path:
+    root_path = Path(root).resolve()
+    relative_path = normalize_media_path(path)
+    target = (root_path / relative_path).resolve()
+    try:
+        if os.path.commonpath([root_path, target]) != str(root_path):
+            raise UploadStorageError("Chemin media hors du dossier d'upload.")
+    except ValueError as exc:
+        raise UploadStorageError("Chemin media invalide.") from exc
+    return target
+
+
+def category_dir(root: str | Path, category: str) -> Path:
+    root_path = Path(root).resolve()
+    directory = (root_path / safe_category(category)).resolve()
+    try:
+        if os.path.commonpath([root_path, directory]) != str(root_path):
+            raise UploadStorageError("Chemin d'upload hors du dossier racine.")
+    except ValueError as exc:
+        raise UploadStorageError("Chemin d'upload invalide.") from exc
+    directory.mkdir(parents=True, exist_ok=True)
+    return directory
+
+
+def get_upload_path(filename: str, category: str, *, root: str | Path) -> Path:
+    filename = secure_filename(filename)
+    target = (category_dir(root, category) / filename).resolve()
+    root_path = Path(root).resolve()
+    try:
+        if os.path.commonpath([root_path, target]) != str(root_path):
+            raise UploadStorageError("Chemin d'upload hors du dossier racine.")
+    except ValueError as exc:
+        raise UploadStorageError("Chemin d'upload invalide.") from exc
+    return target
+
+
+def save_bytes(data: bytes, *, original_name: str, category: str, root: str | Path) -> Path:
+    directory = category_dir(root, category)
+    for _ in range(20):
+        filename = generate_unique_filename(original_name)
+        target = directory / filename
+        try:
+            with target.open("xb") as file:
+                file.write(data)
+            return target
+        except FileExistsError:
+            continue
+        except OSError as exc:
+            raise UploadStorageError(f"Impossible d'enregistrer le fichier : {exc}") from exc
+    raise UploadStorageError("Impossible de generer un nom de fichier unique.")
+
+
+def delete_file(path: str | Path, *, root: str | Path) -> bool:
+    root_path = Path(root).resolve()
+    target = Path(path)
+    if not target.is_absolute():
+        target = root_path / target
+    target = target.resolve()
+    try:
+        if os.path.commonpath([root_path, target]) != str(root_path):
+            raise UploadStorageError("Suppression refusee hors du dossier d'upload.")
+    except ValueError as exc:
+        raise UploadStorageError("Chemin d'upload invalide.") from exc
+    if not target.exists():
+        return False
+    if not target.is_file():
+        raise UploadStorageError("Suppression refusee : le chemin n'est pas un fichier.")
+    try:
+        target.unlink()
+        return True
+    except OSError as exc:
+        raise UploadStorageError(f"Impossible de supprimer le fichier : {exc}") from exc

forge_mvc_files-1.0.0b16/forge_mvc_files.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: forge-mvc-files
+Version: 1.0.0b16
+Summary: Forge Files — module opt-in propriétaire de l'upload générique : écriture sécurisée, storage anti-traversal, service de fichiers, rate-limit. Extrait du core (ADR-019).
+Author: Roger Lequette
+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://forgemvc.com/docs/forge/
+Keywords: python,mvc,forge,files,upload,storage
+Classifier: Development Status :: 3 - Alpha
+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
+License-File: LICENSE
+Requires-Dist: forge-mvc<2,>=1.0.0b16
+Dynamic: license-file
+
+# forge-mvc-files
+
+Module **opt-in** propriétaire de l'**upload générique** dans Forge MVC :
+écriture disque sécurisée, storage anti-traversal, service de fichiers
+(streaming HTTP Range), suppression et rate-limit d'upload.
+
+## Statut : extraction complète (ADR-019)
+
+`forge-mvc-files` détient désormais **tout le pipeline d'upload générique**,
+extrait du core : `save_upload`, `SavedUpload`, `serve_media_file` (HTTP Range),
+storage anti-traversal, suppression et rate-limit. `core/uploads/` a été
+supprimé du core (`CORE-DROP-UPLOADS-001`). La **validation pure** de fichier
+(extension/MIME/taille + `UploadError`) reste dans le core (`core.forms`),
+réutilisée par ce paquet.
+
+Ce paquet cible la publication PyPI de la release beta.13.
+
+## Pourquoi ce module (ADR-019)
+
+Après l'extraction du traitement d'image (ADR-018), l'upload **générique** reste
+le dernier gros bloc applicatif logé dans le noyau. Un framework web peut
+exister sans upload de fichiers : c'est une brique applicative, pas un
+fondement. `forge-mvc-files` devient l'**unique** propriétaire de l'upload
+générique (principes 8 « noyau minimal » et 11 « une seule façon officielle »).
+
+### Ce qui a été déplacé du core
+
+- `manager` — `save_upload`, `SavedUpload`, `serve_media_file`, `delete_upload`,
+  `delete_media_file`, `get_upload_path`, `upload_root`, `_read_upload` ;
+- `storage` — écriture/anti-traversal (`normalize_media_path`,
+  `media_path_to_storage_path`, `is_safe_media_path`, `save_bytes`, `delete_file`) ;
+- `rate_limit` d'upload (`is_upload_rate_limited`, `record_upload_attempt`).
+
+### Ce qui reste dans le core (définitif)
+
+- Les **validators purs** (`validate_extension`, `validate_mime_type`,
+  `validate_size`) et la hiérarchie d'exceptions `UploadError` : `core/forms`
+  (`FileField`) en dépend, et le core ne peut pas dépendre d'un opt-in (ADR-004).
+  Ce sont des contrôles purs sans I/O. `forge-mvc-files` les réutilise.
+
+## Plan d'exécution (ADR-019)
+
+| Ticket | Description | État |
+|---|---|---|
+| `FILES-PKG-SCAFFOLD-001` | Squelette du paquet + enregistrement opt-in | livré |
+| `FILES-VALIDATORS-KEEP-001` | Relocaliser validators + exceptions dans le core | livré |
+| `FILES-MOVE-PIPELINE-001` | Déplacer manager + storage + rate_limit | livré |
+| `FILES-IMAGES-REPOINT-001` | forge-mvc-images dépend de forge-mvc-files | livré |
+| `FILES-CLI-RENAME-001` | Générateurs + forge_cli/uploads + starter | livré |
+| `FILES-DOCS-PERIMETER-001` | Docs + ADR-004 + CLAUDE.md §3 | livré |
+| `CORE-DROP-UPLOADS-001` | Suppression de `core/uploads/` | livré |
+
+## Installation (mode éditable, depuis les sources)
+
+```bash
+git clone https://github.com/caucrogeGit/Forge.git
+cd Forge
+pip install -e packages/forge-mvc-files/
+```
+
+## Référence
+
+- `docs/adr/019-upload-extraction.md` — décision et périmètre figés.
+- Charte principes 8 (noyau minimal), 11 (une seule façon officielle).

forge_mvc_files-1.0.0b16/forge_mvc_files.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+forge_mvc_files/__init__.py
+forge_mvc_files/manager.py
+forge_mvc_files/rate_limit.py
+forge_mvc_files/storage.py
+forge_mvc_files.egg-info/PKG-INFO
+forge_mvc_files.egg-info/SOURCES.txt
+forge_mvc_files.egg-info/dependency_links.txt
+forge_mvc_files.egg-info/requires.txt
+forge_mvc_files.egg-info/top_level.txt

forge_mvc_files-1.0.0b16/forge_mvc_files.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

forge_mvc_files-1.0.0b16/forge_mvc_files.egg-info/requires.txt

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

forge_mvc_files-1.0.0b16/forge_mvc_files.egg-info/top_level.txt

@@ -0,0 +1 @@
+forge_mvc_files

forge_mvc_files-1.0.0b16/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "forge-mvc-files"
+version = "1.0.0b16"
+description = "Forge Files — module opt-in propriétaire de l'upload générique : écriture sécurisée, storage anti-traversal, service de fichiers, rate-limit. Extrait du core (ADR-019)."
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.12"
+authors = [
+    { name = "Roger Lequette" },
+]
+license = "LicenseRef-Forge-Proprietary"
+keywords = ["python", "mvc", "forge", "files", "upload", "storage"]
+dependencies = [
+    "forge-mvc>=1.0.0b16,<2",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "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://forgemvc.com/docs/forge/"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["forge_mvc_files*"]

forge_mvc_files-1.0.0b16/setup.cfg

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