brio-sdk 0.1.0__py3-none-any.whl

brio_sdk/__init__.py

@@ -0,0 +1,107 @@
+"""brio-sdk — client (sync + async) des services IA BRIO.
+
+    from brio_sdk import BrioClient, Service
+    from brio_sdk.services import SplitDocumentBody, SplitDocumentResult
+
+    with BrioClient() as client:                       # credentials depuis l'environnement
+        upload = client.upload_file("dossier.pdf")
+        pending = client.submit_task(Service.SPLIT_DOCUMENT, SplitDocumentBody(file_id=upload.file_id))
+        success = client.wait_for_result(Service.SPLIT_DOCUMENT, pending.data.task_id)
+        split = SplitDocumentResult.model_validate(success.result)
+
+Compatibilité ancrée sur l'API `/v1` de l'async-api, pas sur un numéro de version serveur.
+"""
+
+from __future__ import annotations
+
+from brio_sdk._clock import AsyncClock, AsyncSystemClock, Clock, SystemClock
+from brio_sdk._config import ClientConfig, RetryConfig
+from brio_sdk._constants import SDK_VERSION
+from brio_sdk.async_client import AsyncBrioClient
+from brio_sdk.client import BrioClient
+from brio_sdk.exceptions import (
+    AuthenticationError,
+    BodyValidationError,
+    BrioConfigError,
+    BrioError,
+    BrioServerError,
+    BrioTransportError,
+    FileNotFound,
+    Issue,
+    MissingMultipartField,
+    NotImplementedByServer,
+    QuotaExceeded,
+    ServerErrorCode,
+    ServiceForbidden,
+    ServiceNotFound,
+    ServiceUnavailable,
+    TaskFailed,
+    TaskNotFound,
+    TaskTimeoutError,
+    TextTooLarge,
+)
+from brio_sdk.models import (
+    Callback,
+    CallbackPayload,
+    MeResponse,
+    PresignedDownloadResponse,
+    PresignedUploadResponse,
+    ServiceAuthorization,
+    StorageUploadResponse,
+    TaskData,
+    TaskDataFailed,
+    TaskDataPending,
+    TaskDataProgress,
+    TaskDataSuccess,
+    TaskResponse,
+    TaskStatus,
+)
+from brio_sdk.services import Service
+
+__version__ = SDK_VERSION
+
+__all__ = [
+    "AsyncBrioClient",
+    "AsyncClock",
+    "AsyncSystemClock",
+    "AuthenticationError",
+    "BodyValidationError",
+    "BrioClient",
+    "BrioConfigError",
+    "BrioError",
+    "BrioServerError",
+    "BrioTransportError",
+    "Callback",
+    "CallbackPayload",
+    "ClientConfig",
+    "Clock",
+    "FileNotFound",
+    "Issue",
+    "MeResponse",
+    "MissingMultipartField",
+    "NotImplementedByServer",
+    "PresignedDownloadResponse",
+    "PresignedUploadResponse",
+    "QuotaExceeded",
+    "RetryConfig",
+    "ServerErrorCode",
+    "Service",
+    "ServiceAuthorization",
+    "ServiceForbidden",
+    "ServiceNotFound",
+    "ServiceUnavailable",
+    "StorageUploadResponse",
+    "SystemClock",
+    "TaskData",
+    "TaskDataFailed",
+    "TaskDataPending",
+    "TaskDataProgress",
+    "TaskDataSuccess",
+    "TaskFailed",
+    "TaskNotFound",
+    "TaskResponse",
+    "TaskStatus",
+    "TaskTimeoutError",
+    "TextTooLarge",
+    "__version__",
+]

brio_sdk/_clock.py

@@ -0,0 +1,59 @@
+"""Horloges injectables (DI par `Protocol`).
+
+Le temps est une dépendance comme une autre : en test on injecte une horloge qui
+n'attend pas mais avance le temps, ce qui permet de couvrir les timeouts et le backoff
+sans dormir. `monotonic` (et pas `time()`) : le temps écoulé reste juste même si
+l'heure système change pendant l'attente.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Clock(Protocol):
+    """Horloge synchrone."""
+
+    def monotonic(self) -> float: ...
+
+    def sleep(self, seconds: float) -> None: ...
+
+
+@runtime_checkable
+class AsyncClock(Protocol):
+    """Horloge asynchrone (même surface, `sleep` awaitable)."""
+
+    def monotonic(self) -> float: ...
+
+    async def sleep(self, seconds: float) -> None: ...
+
+
+class SystemClock:
+    """Horloge réelle synchrone."""
+
+    __slots__ = ()
+
+    def monotonic(self) -> float:
+        return time.monotonic()
+
+    def sleep(self, seconds: float) -> None:
+        time.sleep(seconds)
+
+
+class AsyncSystemClock:
+    """Horloge réelle asynchrone.
+
+    `asyncio.sleep` est un point d'annulation : une `CancelledError` se propage
+    naturellement, sans laisser de tâche fantôme.
+    """
+
+    __slots__ = ()
+
+    def monotonic(self) -> float:
+        return time.monotonic()
+
+    async def sleep(self, seconds: float) -> None:
+        await asyncio.sleep(seconds)

brio_sdk/_config.py

@@ -0,0 +1,98 @@
+"""Résolution de la configuration client : arguments explicites > variables d'environnement.
+
+Le manque de credentials est détecté **au constructeur** (`BrioConfigError`) et non au
+premier appel : un script mal configuré échoue tout de suite, pas après un upload.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+from brio_sdk._constants import (
+    DEFAULT_BACKOFF_BASE_SECONDS,
+    DEFAULT_BACKOFF_CAP_SECONDS,
+    DEFAULT_BACKOFF_JITTER_RATIO,
+    DEFAULT_MAX_ATTEMPTS,
+    DEFAULT_TIMEOUT_SECONDS,
+    ENV_BASE_URL,
+    ENV_CLIENT_ID,
+    ENV_CLIENT_SECRET,
+)
+from brio_sdk.exceptions import BrioConfigError
+
+
+@dataclass(frozen=True, slots=True)
+class RetryConfig:
+    """Politique de réessai. `max_attempts=1` désactive le retry."""
+
+    max_attempts: int = DEFAULT_MAX_ATTEMPTS
+    backoff_base_seconds: float = DEFAULT_BACKOFF_BASE_SECONDS
+    backoff_cap_seconds: float = DEFAULT_BACKOFF_CAP_SECONDS
+    jitter_ratio: float = DEFAULT_BACKOFF_JITTER_RATIO
+
+    def __post_init__(self) -> None:
+        if self.max_attempts < 1:
+            message = "max_attempts doit valoir au moins 1 (1 = aucun réessai)."
+            raise BrioConfigError(message)
+
+
+@dataclass(frozen=True, slots=True)
+class ClientConfig:
+    """Configuration résolue d'un client."""
+
+    base_url: str
+    client_id: str
+    client_secret: str
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS
+    retry: RetryConfig = RetryConfig()
+
+
+def _first_present(explicit: str | None, env_var: str) -> str | None:
+    if explicit is not None and explicit != "":
+        return explicit
+    from_env = os.environ.get(env_var)
+    return from_env if from_env else None
+
+
+def resolve_config(
+    base_url: str | None = None,
+    client_id: str | None = None,
+    client_secret: str | None = None,
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS,
+    retry: RetryConfig | None = None,
+) -> ClientConfig:
+    """Construit la config depuis les arguments, en retombant sur l'environnement.
+
+    Lève `BrioConfigError` en listant **tous** les réglages manquants d'un coup, pour
+    éviter de corriger une variable d'env à la fois.
+    """
+    resolved_base_url = _first_present(base_url, ENV_BASE_URL)
+    resolved_client_id = _first_present(client_id, ENV_CLIENT_ID)
+    resolved_client_secret = _first_present(client_secret, ENV_CLIENT_SECRET)
+
+    missing = [
+        env_var
+        for value, env_var in (
+            (resolved_base_url, ENV_BASE_URL),
+            (resolved_client_id, ENV_CLIENT_ID),
+            (resolved_client_secret, ENV_CLIENT_SECRET),
+        )
+        if value is None
+    ]
+    if missing:
+        message = (
+            "Configuration incomplète : "
+            + ", ".join(missing)
+            + " manquant(s). Passez-les au constructeur ou définissez ces variables d'environnement."
+        )
+        raise BrioConfigError(message)
+
+    # Les valeurs sont non-None ici (garanti par le contrôle ci-dessus).
+    return ClientConfig(
+        base_url=str(resolved_base_url).rstrip("/"),
+        client_id=str(resolved_client_id),
+        client_secret=str(resolved_client_secret),
+        timeout_seconds=timeout_seconds,
+        retry=retry if retry is not None else RetryConfig(),
+    )

brio_sdk/_constants.py

@@ -0,0 +1,73 @@
+"""Constantes internes — aucun magic number/string ailleurs dans le SDK.
+
+Les valeurs marquées « vérifié » ont été relues dans le code serveur : elles doivent
+être re-vérifiées si `api/` bouge (la détection de drift de #436 sert à ça).
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+from typing import Final
+
+# --- Version & en-têtes ---
+# Lue depuis les métadonnées du package installé : une seule source de vérité, celle que
+# `release-please` met à jour dans `pyproject.toml`. Aucun risque de version en dur périmée.
+_LOCAL_VERSION_FALLBACK: Final[str] = "0.0.0+local"
+try:
+    SDK_VERSION: Final[str] = version("brio-sdk")
+except PackageNotFoundError:  # pragma: no cover — package non installé (exécution depuis le dépôt)
+    SDK_VERSION = _LOCAL_VERSION_FALLBACK
+USER_AGENT: Final[str] = f"brio-sdk/{SDK_VERSION}"
+SDK_VERSION_HEADER: Final[str] = "X-SDK-Version"
+
+# --- Préfixes serveur (vérifié : api/main.py, RoutePrefix) ---
+# Les tâches et /me sont sous /v1 ; le stockage est monté sous /storage, PAS /v1/storage.
+API_V1_PREFIX: Final[str] = "/v1"
+STORAGE_PREFIX: Final[str] = "/storage"
+
+PATH_ME: Final[str] = f"{API_V1_PREFIX}/me"
+PATH_TASKS_TEMPLATE: Final[str] = f"{API_V1_PREFIX}/services/{{service}}/tasks"
+PATH_TASK_TEMPLATE: Final[str] = f"{API_V1_PREFIX}/services/{{service}}/tasks/{{task_id}}"
+PATH_UPLOAD: Final[str] = f"{STORAGE_PREFIX}/upload"
+PATH_PRESIGNED_UPLOAD: Final[str] = f"{STORAGE_PREFIX}/presigned-upload"
+PATH_PRESIGNED_DOWNLOAD: Final[str] = f"{STORAGE_PREFIX}/presigned-download"
+
+# Nom du champ multipart attendu par POST /storage/upload (vérifié : api/routes/storage.py).
+UPLOAD_FIELD_NAME: Final[str] = "file"
+
+# --- Variables d'environnement ---
+ENV_BASE_URL: Final[str] = "BRIO_BASE_URL"
+ENV_CLIENT_ID: Final[str] = "BRIO_CLIENT_ID"
+ENV_CLIENT_SECRET: Final[str] = "BRIO_CLIENT_SECRET"  # noqa: S105 — nom de variable, pas un secret
+
+# --- Timeouts & retry ---
+DEFAULT_TIMEOUT_SECONDS: Final[float] = 30.0
+DEFAULT_MAX_ATTEMPTS: Final[int] = 3
+DEFAULT_BACKOFF_BASE_SECONDS: Final[float] = 0.5
+DEFAULT_BACKOFF_CAP_SECONDS: Final[float] = 30.0
+DEFAULT_BACKOFF_JITTER_RATIO: Final[float] = 0.25
+
+# --- Polling (wait_for_result) ---
+DEFAULT_POLL_TIMEOUT_SECONDS: Final[float] = 300.0
+DEFAULT_POLL_INITIAL_INTERVAL_SECONDS: Final[float] = 1.0
+DEFAULT_POLL_MAX_INTERVAL_SECONDS: Final[float] = 30.0
+
+# --- Upload : bascule direct -> presigned ---
+# Vérifié : API_UPLOAD_MAX_SIZE_MB = 25 (transit API, aligné sur proxy-body-size de l'ingress)
+# et S3_PRESIGNED_UPLOAD_MAX_SIZE_MB = 500 (plafond content-length-range de la policy).
+_BYTES_PER_MB: Final[int] = 1024 * 1024
+DIRECT_UPLOAD_MAX_SIZE_BYTES: Final[int] = 25 * _BYTES_PER_MB
+PRESIGNED_UPLOAD_MAX_SIZE_BYTES: Final[int] = 500 * _BYTES_PER_MB
+
+# Taille des chunks pour l'écriture d'un fichier téléchargé.
+DOWNLOAD_CHUNK_SIZE_BYTES: Final[int] = 64 * 1024
+
+DEFAULT_MIME_TYPE: Final[str] = "application/octet-stream"
+
+# --- Statuts HTTP ---
+HTTP_TOO_MANY_REQUESTS: Final[int] = 429
+RETRYABLE_SERVER_STATUS: Final[frozenset[int]] = frozenset({502, 503, 504})
+
+# En-tête standard de réessai (RFC 7231). Le serveur ne l'émet pas aujourd'hui : on le lit
+# quand même, il primera sur le backoff dès qu'il apparaîtra.
+RETRY_AFTER_HEADER: Final[str] = "Retry-After"

brio_sdk/_http.py

@@ -0,0 +1,145 @@
+"""Cœur pur : décisions et parsing HTTP, **sans aucune I/O**.
+
+Ces fonctions reçoivent une `httpx.Response` déjà obtenue, elles n'en émettent jamais.
+Conséquence : elles sont testées une seule fois et servent à l'identique aux deux clients
+(sync et async), ce qui garantit un comportement strictement identique des deux côtés.
+"""
+
+from __future__ import annotations
+
+import random
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from pydantic import BaseModel, ValidationError
+
+if TYPE_CHECKING:
+    import httpx
+
+from brio_sdk._constants import (
+    HTTP_TOO_MANY_REQUESTS,
+    RETRY_AFTER_HEADER,
+    RETRYABLE_SERVER_STATUS,
+    SDK_VERSION,
+    SDK_VERSION_HEADER,
+    USER_AGENT,
+)
+from brio_sdk.exceptions import BrioServerError, map_error
+
+ModelT = TypeVar("ModelT", bound=BaseModel)
+
+_HTTP_ERROR_THRESHOLD = 400
+_INVALID_RESPONSE_MESSAGE = "Réponse serveur non conforme au contrat attendu."
+# En-tête que httpx pose par défaut : le remplacer ne piétine aucun choix de l'appelant.
+_DEFAULT_HTTPX_USER_AGENT_PREFIX = "python-httpx/"
+
+
+def configure_client_identity(
+    client: httpx.Client | httpx.AsyncClient,
+    *,
+    base_url: str,
+    auth: httpx.Auth,
+) -> None:
+    """Applique l'identité du SDK à un client httpx, y compris injecté.
+
+    Un client fourni par l'appelant (proxy, mTLS, timeouts maison) ne doit pas perdre
+    l'authentification ni la `base_url` : sans ça, l'injection produit silencieusement des
+    appels anonymes vers une URL relative. On ne remplace en revanche ni une `base_url` ni
+    une auth déjà choisies explicitement, ni un `User-Agent` personnalisé.
+    """
+    client.headers[SDK_VERSION_HEADER] = SDK_VERSION
+    current_user_agent = client.headers.get("User-Agent", "")
+    if current_user_agent.startswith(_DEFAULT_HTTPX_USER_AGENT_PREFIX):
+        client.headers["User-Agent"] = USER_AGENT
+    if not str(client.base_url):
+        client.base_url = base_url
+    if client.auth is None:
+        client.auth = auth
+
+
+def should_retry_status(status_code: int) -> bool:
+    """Vrai si le statut mérite un réessai.
+
+    429 (quota, transitoire par nature) et 502/503/504 (indisponibilité amont). Les
+    autres 4xx sont des erreurs du client : les rejouer ne change rien.
+    """
+    return status_code == HTTP_TOO_MANY_REQUESTS or status_code in RETRYABLE_SERVER_STATUS
+
+
+def compute_backoff(
+    attempt: int,
+    *,
+    base_seconds: float,
+    cap_seconds: float,
+    jitter_ratio: float,
+) -> float:
+    """Backoff exponentiel plafonné, avec jitter.
+
+    `attempt` est 0-indexé. Le jitter évite que N clients réessayent en même temps
+    (thundering herd) après une même 429.
+    """
+    exponential = base_seconds * (2**attempt)
+    jitter = exponential * jitter_ratio * random.random()  # noqa: S311 — pas d'usage cryptographique
+    return min(exponential + jitter, cap_seconds)
+
+
+def parse_retry_after(response: httpx.Response) -> float | None:
+    """Lit l'en-tête `Retry-After` (secondes ou date HTTP). `None` s'il est absent/illisible.
+
+    Le serveur ne l'émet pas aujourd'hui ; dès qu'il le fera, il primera sur le backoff.
+    """
+    raw = response.headers.get(RETRY_AFTER_HEADER)
+    if not raw:
+        return None
+
+    try:
+        return float(raw)
+    except ValueError:
+        pass
+
+    try:
+        target = parsedate_to_datetime(raw)
+    except (TypeError, ValueError):
+        return None
+
+    reference = datetime.now(target.tzinfo) if target.tzinfo is not None else datetime.now(timezone.utc)  # noqa: UP017
+    return max((target - reference).total_seconds(), 0.0)
+
+
+def decode_json(response: httpx.Response) -> Any | None:
+    """Corps JSON décodé, ou `None` si le corps n'est pas du JSON exploitable."""
+    try:
+        return response.json()
+    except ValueError:
+        return None
+
+
+def raise_for_error(response: httpx.Response) -> None:
+    """Lève l'exception SDK correspondante si la réponse est une erreur."""
+    if response.status_code < _HTTP_ERROR_THRESHOLD:
+        return
+    raise map_error(
+        response.status_code,
+        decode_json(response),
+        retry_after=parse_retry_after(response),
+    )
+
+
+def parse_response(response: httpx.Response, model: type[ModelT]) -> ModelT:
+    """Valide une réponse de succès dans `model`, ou lève l'exception SDK adéquate.
+
+    Un corps de succès non conforme est une anomalie serveur, pas une erreur client :
+    on lève `BrioServerError` en gardant le payload brut pour le diagnostic.
+    """
+    raise_for_error(response)
+
+    payload = decode_json(response)
+    try:
+        return model.model_validate(payload)
+    except ValidationError as error:
+        raise BrioServerError(
+            _INVALID_RESPONSE_MESSAGE,
+            status_code=response.status_code,
+            response_payload=payload,
+        ) from error

brio_sdk/_payloads.py

@@ -0,0 +1,58 @@
+"""Construction des corps de requête et petites règles de polling — cœur pur, sans I/O.
+
+Factorisé ici pour que les deux clients (sync et async) partagent exactement les mêmes
+règles : un seul endroit à tester, aucune dérive possible entre les deux surfaces.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from brio_sdk.models import PresignedUploadResponse
+
+_TIMEOUT_MESSAGE_TEMPLATE = (
+    "Délai d'attente de {timeout:g}s dépassé : la tâche est toujours en cours côté serveur. "
+    "Relancez wait_for_result avec le même task_id pour continuer à attendre."
+)
+
+
+def dump_body(body: Mapping[str, Any] | BaseModel) -> dict[str, Any]:
+    """Normalise un body en dict JSON-sérialisable.
+
+    Un modèle typé est dumpé avec `exclude_none` : les champs optionnels non renseignés
+    ne sont pas envoyés, ce qui laisse le serveur appliquer ses propres défauts.
+    """
+    if isinstance(body, BaseModel):
+        return body.model_dump(mode="json", exclude_none=True)
+    return dict(body)
+
+
+def build_task_payload(
+    body: Mapping[str, Any] | BaseModel,
+    callback: Mapping[str, Any] | BaseModel | None = None,
+) -> dict[str, Any]:
+    """Corps de `POST /v1/services/{service}/tasks`."""
+    payload: dict[str, Any] = {"body": dump_body(body)}
+    if callback is not None:
+        payload["callback"] = dump_body(callback)
+    return payload
+
+
+def build_presigned_upload_fields(presigned: PresignedUploadResponse) -> dict[str, str]:
+    """Champs de formulaire à renvoyer tels quels dans le POST S3, avant le champ `file`."""
+    return dict(presigned.fields)
+
+
+def poll_interval_after(interval_seconds: float, max_interval_seconds: float) -> float:
+    """Intervalle du prochain poll : doublement plafonné."""
+    return min(interval_seconds * 2, max_interval_seconds)
+
+
+def timeout_message(timeout_seconds: float) -> str:
+    """Message d'un dépassement de délai — dit explicitement que la tâche continue."""
+    return _TIMEOUT_MESSAGE_TEMPLATE.format(timeout=timeout_seconds)

brio_sdk/_upload.py

@@ -0,0 +1,91 @@
+"""Préparation d'un upload — mesure de taille et type MIME, sans charger le fichier en RAM.
+
+Le consommateur ne doit pas connaître le seuil de bascule API/S3 : c'est `resolve_source`
+qui donne la taille, et le client qui choisit la voie. La taille est obtenue par `stat()`
+pour un chemin et par `seek/tell` pour un flux — jamais en lisant le contenu, sinon un
+scan de 200 Mo tiendrait en mémoire.
+"""
+
+from __future__ import annotations
+
+import mimetypes
+from dataclasses import dataclass
+from pathlib import Path
+from typing import BinaryIO
+
+from brio_sdk._constants import DEFAULT_MIME_TYPE, DIRECT_UPLOAD_MAX_SIZE_BYTES
+from brio_sdk.exceptions import BrioConfigError
+
+_UNKNOWN_SIZE_MESSAGE = (
+    "Impossible de mesurer la taille du flux fourni (non seekable). "
+    "Passez un chemin de fichier, ou un objet binaire seekable."
+)
+
+
+@dataclass(slots=True)
+class UploadSource:
+    """Source d'upload prête à être envoyée : nom, type MIME, taille et flux."""
+
+    filename: str
+    mime_type: str
+    size_bytes: int
+    stream: BinaryIO
+    # Vrai si le flux a été ouvert par le SDK : c'est alors à lui de le refermer.
+    owns_stream: bool
+
+    def close(self) -> None:
+        if self.owns_stream:
+            self.stream.close()
+
+    @property
+    def needs_presigned_upload(self) -> bool:
+        """Vrai si le fichier dépasse ce que la voie directe (transit API) accepte."""
+        return self.size_bytes >= DIRECT_UPLOAD_MAX_SIZE_BYTES
+
+
+def guess_mime_type(filename: str) -> str:
+    """Type MIME déduit de l'extension, avec repli sur `application/octet-stream`."""
+    guessed, _ = mimetypes.guess_type(filename)
+    return guessed or DEFAULT_MIME_TYPE
+
+
+def _stream_size(stream: BinaryIO) -> int:
+    """Taille restante d'un flux seekable, sans en lire le contenu."""
+    if not stream.seekable():
+        raise BrioConfigError(_UNKNOWN_SIZE_MESSAGE)
+    current = stream.tell()
+    size = stream.seek(0, 2) - current
+    stream.seek(current)
+    return size
+
+
+def resolve_source(
+    file: Path | str | BinaryIO,
+    filename: str | None = None,
+    mime_type: str | None = None,
+) -> UploadSource:
+    """Normalise un chemin ou un flux binaire en `UploadSource`.
+
+    Le flux d'un chemin est ouvert ici (`owns_stream=True`) : le client le refermera.
+    Un flux fourni par l'appelant lui reste, on n'y touche pas.
+    """
+    if isinstance(file, (str, Path)):
+        path = Path(file)
+        resolved_name = filename or path.name
+        return UploadSource(
+            filename=resolved_name,
+            mime_type=mime_type or guess_mime_type(resolved_name),
+            size_bytes=path.stat().st_size,
+            stream=path.open("rb"),
+            owns_stream=True,
+        )
+
+    resolved_name = filename or getattr(file, "name", None) or "upload.bin"
+    resolved_name = Path(str(resolved_name)).name
+    return UploadSource(
+        filename=resolved_name,
+        mime_type=mime_type or guess_mime_type(resolved_name),
+        size_bytes=_stream_size(file),
+        stream=file,
+        owns_stream=False,
+    )