sepehr/office_translator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: revue de code, doc CODE_REVIEW, forfaits 2026, traduction LLM, providers avec modèle

Browse Source 
Made-with: Cursor
This commit is contained in:
Sepehr Ramezani
2026-03-07 11:42:58 +01:00
parent 3d37ce4582
commit 473b3e26c7
181 changed files with 30617 additions and 7170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
utils/__init__.py
View File

@@ -2,6 +2,7 @@
from .file_handler import FileHandler, file_handler
from .exceptions import (
TranslationError,
TranslationProviderError,
UnsupportedFileTypeError,
FileSizeLimitExceededError,
LanguageNotSupportedError,
@@ -12,6 +13,7 @@ from .exceptions import (
__all__ = [
'FileHandler', 'file_handler',
'TranslationError',
'TranslationProviderError',
'UnsupportedFileTypeError',
'FileSizeLimitExceededError',
'LanguageNotSupportedError',

136
utils/exceptions.py
View File

@@ -1,51 +1,141 @@
"""
Custom exceptions for the Document Translation API
"""
from fastapi import HTTPException
from typing import Any, Dict, Optional
class TranslationError(Exception):
"""Base exception for translation errors"""
pass
"""
Base exception for translation errors.
Includes an error code and optional details for structured JSON responses.
"""
def __init__(
self,
message: str,
code: str = "TRANSLATION_ERROR",
details: Optional[Dict[str, Any]] = None,
):
self.message = message
self.code = code
self.details = details or {}
super().__init__(message)
class UnsupportedFileTypeError(TranslationError):
"""Raised when an unsupported file type is provided"""
pass
def __init__(
self,
message: str = "Format de fichier non supporté.",
details: Optional[Dict[str, Any]] = None,
):
super().__init__(message, code="INVALID_FORMAT", details=details)
class FileSizeLimitExceededError(TranslationError):
"""Raised when a file exceeds the size limit"""
pass
def __init__(
self,
message: str = "Fichier trop volumineux.",
details: Optional[Dict[str, Any]] = None,
):
super().__init__(message, code="FILE_TOO_LARGE", details=details)
class LanguageNotSupportedError(TranslationError):
"""Raised when a language code is not supported"""
pass
def __init__(
self,
message: str = "Langue non supportée.",
details: Optional[Dict[str, Any]] = None,
):
super().__init__(message, code="INVALID_FORMAT", details=details)
class DocumentProcessingError(TranslationError):
"""Raised when there's an error processing the document"""
pass
def __init__(
self,
message: str = "Erreur lors du traitement du document.",
details: Optional[Dict[str, Any]] = None,
):
super().__init__(message, code="INTERNAL_ERROR", details=details)
def handle_translation_error(error: Exception) -> HTTPException:
"""
Convert translation errors to HTTP exceptions
class TranslationProviderError(TranslationError):
"""Raised when a translation provider returns a structured error."""
def __init__(
self, error_code: str, message: str, details: Optional[Dict[str, Any]] = None
):
super().__init__(message, code=error_code, details=details)
class GlossaryNotFoundError(TranslationError):
"""Raised when a glossary is not found or doesn't belong to the user.
Story 3.10: Glossaires - Application lors Traduction LLM
"""
def __init__(
self,
message: str = "Glossaire introuvable ou vous n'avez pas accès à cette ressource.",
details: Optional[Dict[str, Any]] = None,
):
super().__init__(message, code="GLOSSARY_NOT_FOUND", details=details)
class PromptNotFoundError(TranslationError):
"""Raised when a prompt is not found or doesn't belong to the user.
Story 3.12: Custom Prompts - Application lors Traduction LLM
"""
def __init__(
self,
message: str = "Prompt introuvable ou vous n'avez pas accès à cette ressource.",
details: Optional[Dict[str, Any]] = None,
):
super().__init__(message, code="PROMPT_NOT_FOUND", details=details)
# Map provider error codes to HTTP status (Story 2.2, 2.3, 2.6)
_PROVIDER_ERROR_HTTP_STATUS = {
"GOOGLE_QUOTA_EXCEEDED": 429,
"GOOGLE_INVALID_KEY": 401,
"GOOGLE_NETWORK_ERROR": 502,
"GOOGLE_UNSUPPORTED_LANGUAGE": 400,
"GOOGLE_TEXT_TOO_LONG": 413,
"DEEPL_QUOTA_EXCEEDED": 429,
"DEEPL_INVALID_KEY": 401,
"DEEPL_NETWORK_ERROR": 502,
"DEEPL_UNSUPPORTED_LANGUAGE": 400,
"DEEPL_TEXT_TOO_LONG": 413,
"ALL_PROVIDERS_FAILED": 502,
}
def handle_translation_error(error: TranslationError) -> tuple[dict, int]:
"""
Handle a translation error and return a tuple of (response_body, status_code).
Args:
error: Exception that occurred
error: The TranslationError to handle
Returns:
HTTPException with appropriate status code and message
Tuple of (error response dict, HTTP status code)
"""
if isinstance(error, UnsupportedFileTypeError):
return HTTPException(status_code=400, detail=str(error))
elif isinstance(error, FileSizeLimitExceededError):
return HTTPException(status_code=413, detail=str(error))
elif isinstance(error, LanguageNotSupportedError):
return HTTPException(status_code=400, detail=str(error))
elif isinstance(error, DocumentProcessingError):
return HTTPException(status_code=500, detail=str(error))
else:
return HTTPException(status_code=500, detail="An unexpected error occurred during translation")
status_code = _PROVIDER_ERROR_HTTP_STATUS.get(error.code, 400)
response = {
"error": error.code,
"message": error.message,
"details": error.details if error.details else {},
}
return response, status_code

107
utils/file_handler.py
View File

@@ -1,8 +1,10 @@
"""
Utility functions for file handling and validation
"""
import os
import uuid
import hashlib
from pathlib import Path
from typing import Optional
from fastapi import UploadFile, HTTPException
@@ -11,39 +13,66 @@ from config import config
class FileHandler:
"""Handles file operations for the translation API"""
@staticmethod
def calculate_sha256(file_path: Path) -> Optional[str]:
"""
Calculate the SHA256 hash of a file
Args:
file_path: Path to the file
Returns:
SHA256 hash string or None if error
"""
try:
if not file_path.exists():
return None
sha256_hash = hashlib.sha256()
with open(file_path, "rb") as f:
for byte_block in iter(lambda: f.read(4096), b""):
sha256_hash.update(byte_block)
return sha256_hash.hexdigest()
except Exception as e:
import logging
logging.getLogger(__name__).error(
f"SHA256 calculation failed for {file_path}: {e}"
)
return None
@staticmethod
def validate_file_extension(filename: str) -> str:
"""
Validate that the file extension is supported
Args:
filename: Name of the file
Returns:
File extension (lowercase, with dot)
Raises:
HTTPException: If file extension is not supported
"""
file_extension = Path(filename).suffix.lower()
if file_extension not in config.SUPPORTED_EXTENSIONS:
raise HTTPException(
status_code=400,
detail=f"Unsupported file type. Supported types: {', '.join(config.SUPPORTED_EXTENSIONS)}"
detail=f"Unsupported file type. Supported types: {', '.join(config.SUPPORTED_EXTENSIONS)}",
)
return file_extension
@staticmethod
def validate_file_size(file: UploadFile) -> None:
"""
Validate that the file size is within limits
Args:
file: Uploaded file
Raises:
HTTPException: If file is too large
"""
@@ -51,90 +80,100 @@ class FileHandler:
file.file.seek(0, 2) # Move to end of file
file_size = file.file.tell() # Get position (file size)
file.file.seek(0) # Reset to beginning
if file_size > config.MAX_FILE_SIZE_BYTES:
raise HTTPException(
status_code=400,
detail=f"File too large. Maximum size: {config.MAX_FILE_SIZE_MB}MB"
detail=f"File too large. Maximum size: {config.MAX_FILE_SIZE_MB}MB",
)
@staticmethod
async def save_upload_file(file: UploadFile, destination: Path) -> Path:
async def save_upload_file(file: UploadFile, destination: Path, chunk_size: int = 65536) -> Path:
"""
Save an uploaded file to disk
Save an uploaded file to disk using chunked streaming to avoid loading
the entire file into memory at once.
Args:
file: Uploaded file
destination: Path to save the file
chunk_size: Read/write chunk size in bytes (default 64KB)
Returns:
Path to the saved file
"""
destination.parent.mkdir(parents=True, exist_ok=True)
with open(destination, "wb") as buffer:
content = await file.read()
buffer.write(content)
while True:
chunk = await file.read(chunk_size)
if not chunk:
break
buffer.write(chunk)
return destination
@staticmethod
def generate_unique_filename(original_filename: str, prefix: str = "") -> str:
"""
Generate a unique filename to avoid collisions
Args:
original_filename: Original filename
prefix: Optional prefix for the filename
Returns:
Unique filename
"""
file_path = Path(original_filename)
unique_id = str(uuid.uuid4())[:8]
if prefix:
return f"{prefix}_{unique_id}_{file_path.stem}{file_path.suffix}"
else:
return f"{unique_id}_{file_path.stem}{file_path.suffix}"
@staticmethod
def cleanup_file(file_path: Path) -> None:
"""
Delete a file if it exists
Args:
file_path: Path to the file to delete
"""
import logging
_logger = logging.getLogger(__name__)
try:
if file_path.exists():
file_path.unlink()
_logger.debug(f"Deleted file: {file_path}")
except Exception as e:
print(f"Error deleting file {file_path}: {e}")
_logger.warning(f"Error deleting file {file_path}: {e}")
@staticmethod
def get_file_info(file_path: Path) -> dict:
"""
Get information about a file
Args:
file_path: Path to the file
Returns:
Dictionary with file information
"""
if not file_path.exists():
return {}
stat = file_path.stat()
return {
"filename": file_path.name,
"size_bytes": stat.st_size,
"size_mb": round(stat.st_size / (1024 * 1024), 2),
"sha256": FileHandler.calculate_sha256(file_path),
"extension": file_path.suffix,
"created": stat.st_ctime,
"modified": stat.st_mtime
"modified": stat.st_mtime,
}