Spaces:
Build error
Build error
Hkoradiya123
feat: Initialize frontend with Zustand for state management, Tailwind CSS for styling, and TypeScript for type safety
4854e2b Download backend/app/utils/common.py from jinksQspider/fmproService: direct link, hf CLI and curl.
- Browser
- Download file 7.17 kB
-
https://huggingface.co/spaces/jinksQspider/fmproService/resolve/main/backend/app/utils/common.py
- Command line
-
hf download hf://spaces/jinksQspider/fmproService/backend/app/utils/common.py
-
curl -L -o common.py https://huggingface.co/spaces/jinksQspider/fmproService/resolve/main/backend/app/utils/common.py
7.17 kB
| """Utilities for image processing and face detection""" | |
| import logging | |
| from typing import Optional, Tuple, List | |
| import numpy as np | |
| from PIL import Image | |
| import io | |
| import hashlib | |
| import base64 | |
| logger = logging.getLogger(__name__) | |
| class ImageUtils: | |
| """Image processing utilities""" | |
| def load_image_from_bytes(image_bytes: bytes) -> Image.Image: | |
| """Load PIL Image from bytes""" | |
| return Image.open(io.BytesIO(image_bytes)) | |
| def load_image_from_base64(base64_str: str) -> Image.Image: | |
| """Load PIL Image from base64 string""" | |
| if base64_str.startswith("data:"): | |
| base64_str = base64_str.split(",")[1] | |
| image_bytes = base64.b64decode(base64_str) | |
| return Image.open(io.BytesIO(image_bytes)) | |
| def image_to_bytes(image: Image.Image, format: str = "PNG") -> bytes: | |
| """Convert PIL Image to bytes""" | |
| byte_arr = io.BytesIO() | |
| image.save(byte_arr, format=format) | |
| byte_arr.seek(0) | |
| return byte_arr.getvalue() | |
| def compute_image_hash(image_bytes: bytes) -> str: | |
| """Compute SHA256 hash of image for duplicate detection""" | |
| return hashlib.sha256(image_bytes).hexdigest() | |
| def resize_image(image: Image.Image, max_size: int = 640) -> Image.Image: | |
| """Resize image while maintaining aspect ratio""" | |
| image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS) | |
| return image | |
| def validate_image(image_bytes: bytes, max_size_mb: int = 10) -> bool: | |
| """Validate image""" | |
| # Check file size | |
| if len(image_bytes) > max_size_mb * 1024 * 1024: | |
| logger.error(f"Image too large: {len(image_bytes)} bytes") | |
| return False | |
| try: | |
| # Try to open image | |
| Image.open(io.BytesIO(image_bytes)) | |
| return True | |
| except Exception as e: | |
| logger.error(f"Invalid image: {str(e)}") | |
| return False | |
| class FaceUtils: | |
| """Face detection and processing utilities""" | |
| # Placeholder for InsightFace initialization (will be done in service layer) | |
| _detector = None | |
| def init_detector(cls): | |
| """Initialize InsightFace detector (lazy loading)""" | |
| if cls._detector is None: | |
| try: | |
| from insightface.app import FaceAnalysis | |
| from app.core.config import settings | |
| import onnxruntime | |
| # insightface==0.2.1: FaceAnalysis(name, root) only — no 'providers' kwarg. | |
| # GPU vs CPU is controlled via ctx_id in prepare(): | |
| # ctx_id=0 → CUDA GPU | |
| # ctx_id=-1 → CPU | |
| ctx_id = -1 # default: CPU | |
| if settings.INSIGHTFACE_GPU_AUTO: | |
| available = onnxruntime.get_available_providers() | |
| if "CUDAExecutionProvider" in available: | |
| ctx_id = 0 | |
| elif settings.INSIGHTFACE_GPU: | |
| ctx_id = 0 | |
| cls._detector = FaceAnalysis(name=settings.INSIGHTFACE_MODEL) | |
| cls._detector.prepare(ctx_id=ctx_id) | |
| logger.info( | |
| f"Face detector initialized: model={settings.INSIGHTFACE_MODEL}, " | |
| f"ctx_id={ctx_id} ({'GPU' if ctx_id == 0 else 'CPU'})" | |
| ) | |
| except Exception as e: | |
| logger.error(f"Failed to initialize face detector: {str(e)}") | |
| raise | |
| def detect_faces(cls, image: np.ndarray) -> List[dict]: | |
| """Detect faces in image using InsightFace""" | |
| if cls._detector is None: | |
| cls.init_detector() | |
| try: | |
| faces = cls._detector.get(image) | |
| return faces | |
| except Exception as e: | |
| logger.error(f"Face detection failed: {str(e)}") | |
| return [] | |
| def get_face_embedding(cls, image: np.ndarray, face) -> np.ndarray: | |
| """Extract embedding for a detected face""" | |
| if cls._detector is None: | |
| cls.init_detector() | |
| try: | |
| embedding = face.embedding | |
| return embedding | |
| except Exception as e: | |
| logger.error(f"Embedding extraction failed: {str(e)}") | |
| raise | |
| def get_face_quality(face) -> float: | |
| """Get quality score for a face (0-1)""" | |
| # This is a placeholder - actual quality can be computed from face landmarks | |
| try: | |
| if hasattr(face, 'det_score'): | |
| return float(face.det_score) | |
| except Exception: | |
| pass | |
| return 0.9 # Default high quality | |
| def get_face_angle(face) -> str: | |
| """Determine face angle (frontal, profile, etc.)""" | |
| try: | |
| if hasattr(face, 'pose'): | |
| pose = face.pose # [pitch, roll, yaw] | |
| yaw = float(pose[2]) if len(pose) > 2 else 0 | |
| abs_yaw = abs(yaw) | |
| if abs_yaw < 20: | |
| return "frontal" | |
| elif abs_yaw < 55: | |
| return "left-half-profile" if yaw < 0 else "right-half-profile" | |
| else: | |
| return "left-profile" if yaw < 0 else "right-profile" | |
| except Exception: | |
| pass | |
| return "unknown" | |
| def get_face_bbox(face) -> Optional[Tuple[float, float, float, float]]: | |
| """Get bounding box for face [x1, y1, x2, y2]""" | |
| try: | |
| if hasattr(face, 'bbox'): | |
| bbox = face.bbox | |
| return tuple(bbox) | |
| except Exception: | |
| pass | |
| return None | |
| class ValidationUtils: | |
| """Validation utilities""" | |
| def validate_email(email: str) -> bool: | |
| """Validate email format""" | |
| import re | |
| pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' | |
| return re.match(pattern, email) is not None | |
| def validate_person_id(person_id: str) -> bool: | |
| """Validate person_id format""" | |
| # Can contain alphanumeric, underscore, hyphen | |
| import re | |
| pattern = r'^[a-zA-Z0-9_-]+$' | |
| return len(person_id) > 0 and re.match(pattern, person_id) is not None | |
| def validate_password(password: str) -> Tuple[bool, str]: | |
| """Validate password strength""" | |
| if len(password) < 8: | |
| return False, "Password must be at least 8 characters" | |
| if not any(c.isupper() for c in password): | |
| return False, "Password must contain at least one uppercase letter" | |
| if not any(c.islower() for c in password): | |
| return False, "Password must contain at least one lowercase letter" | |
| if not any(c.isdigit() for c in password): | |
| return False, "Password must contain at least one digit" | |
| return True, "Password is valid" | |