Spaces:
Sleeping
Sleeping
| """ | |
| Request validation utilities. | |
| """ | |
| import os | |
| from typing import Tuple, Optional | |
| from werkzeug.utils import secure_filename | |
| from PIL import Image | |
| def validate_image_file(file, max_size: int, allowed_extensions: tuple) -> Tuple[bool, Optional[str], Optional[str]]: | |
| """ | |
| Validate uploaded image file. | |
| Args: | |
| file: FileStorage object from Flask | |
| max_size: Maximum file size in bytes | |
| allowed_extensions: Tuple of allowed extensions (e.g., (".jpg", ".png")) | |
| Returns: | |
| Tuple of (is_valid, error_message, sanitized_filename) | |
| If valid: (True, None, filename) | |
| If invalid: (False, error_message, None) | |
| """ | |
| if not file or not file.filename: | |
| return False, "No file provided", None | |
| # Check filename | |
| filename = secure_filename(file.filename) | |
| if not filename: | |
| return False, "Invalid filename", None | |
| # Check extension | |
| ext = os.path.splitext(filename)[1].lower() | |
| if ext not in allowed_extensions: | |
| return False, f"Unsupported file type. Allowed: {', '.join(allowed_extensions)}", None | |
| # Check file size (if available) | |
| try: | |
| file.seek(0, os.SEEK_END) | |
| file_size = file.tell() | |
| file.seek(0) # Reset to beginning | |
| if file_size > max_size: | |
| max_mb = max_size / (1024 * 1024) | |
| return False, f"File too large. Maximum size: {max_mb:.1f}MB", None | |
| if file_size == 0: | |
| return False, "File is empty", None | |
| except Exception: | |
| # If we can't check size, continue (will be caught by MAX_CONTENT_LENGTH) | |
| pass | |
| # Validate it's actually an image by trying to open it | |
| try: | |
| file.seek(0) | |
| img = Image.open(file) | |
| img.verify() # Verify it's a valid image | |
| file.seek(0) # Reset after verification | |
| except Exception as e: | |
| return False, f"Invalid image file: {str(e)}", None | |
| return True, None, filename | |
| def validate_pagination_params(limit: Optional[str], offset: Optional[str]) -> Tuple[int, int, Optional[str]]: | |
| """ | |
| Validate pagination parameters. | |
| Returns: | |
| Tuple of (limit, offset, error_message) | |
| """ | |
| try: | |
| limit_val = int(limit) if limit else 20 | |
| limit_val = max(1, min(200, limit_val)) | |
| except ValueError: | |
| return 20, 0, "Invalid limit parameter. Must be an integer." | |
| try: | |
| offset_val = int(offset) if offset else 0 | |
| offset_val = max(0, offset_val) | |
| except ValueError: | |
| return limit_val, 0, "Invalid offset parameter. Must be an integer." | |
| return limit_val, offset_val, None | |
| def validate_confidence_range(min_conf: Optional[str], max_conf: Optional[str]) -> Tuple[Optional[float], Optional[float], Optional[str]]: | |
| """ | |
| Validate confidence range parameters. | |
| Returns: | |
| Tuple of (min_confidence, max_confidence, error_message) | |
| """ | |
| min_val = None | |
| max_val = None | |
| if min_conf: | |
| try: | |
| min_val = float(min_conf) | |
| if not 0 <= min_val <= 1: | |
| return None, None, "min_confidence must be between 0 and 1" | |
| except ValueError: | |
| return None, None, "Invalid min_confidence parameter. Must be a number." | |
| if max_conf: | |
| try: | |
| max_val = float(max_conf) | |
| if not 0 <= max_val <= 1: | |
| return None, None, "max_confidence must be between 0 and 1" | |
| except ValueError: | |
| return None, None, "Invalid max_confidence parameter. Must be a number." | |
| if min_val is not None and max_val is not None and min_val > max_val: | |
| return None, None, "min_confidence cannot be greater than max_confidence" | |
| return min_val, max_val, None | |