django-nativemojo 0.1.10__py3-none-any.whl → 0.1.16__py3-none-any.whl

mojo/apps/fileman/renderer/image.py

@@ -0,0 +1,222 @@
+import os
+import io
+from typing import Dict, Optional, Tuple, Union, BinaryIO
+from PIL import Image, ImageOps
+import mimetypes
+import logging
+
+from mojo.apps.fileman.models import File, FileRendition
+from mojo.apps.fileman.renderer.base import BaseRenderer, RenditionRole
+
+logger = logging.getLogger(__name__)
+
+class ImageRenderer(BaseRenderer):
+    """
+    Renderer for image files
+
+    Creates various renditions like thumbnails, square crops, and resized versions
+    """
+
+    # Image file categories
+    supported_categories = ['image']
+
+    # Default rendition definitions with sizes and options
+    default_renditions = {
+        RenditionRole.THUMBNAIL: {'width': 150, 'height': 150, 'mode': 'contain'},
+        RenditionRole.THUMBNAIL_SM: {'width': 32, 'height': 32, 'mode': 'contain'},
+        RenditionRole.THUMBNAIL_MD: {'width': 64, 'height': 64, 'mode': 'contain'},
+        RenditionRole.THUMBNAIL_LG: {'width': 300, 'height': 300, 'mode': 'contain'},
+        RenditionRole.SQUARE_SM: {'width': 100, 'height': 100, 'mode': 'crop'}
+    }
+
+    # Default output format settings
+    default_format = 'JPEG'
+    default_quality = 85
+
+    def __init__(self, file: File):
+        super().__init__(file)
+        # Map of file extensions to PIL format names
+        self.format_map = {
+            '.jpg': 'JPEG',
+            '.jpeg': 'JPEG',
+            '.png': 'PNG',
+            '.gif': 'GIF',
+            '.bmp': 'BMP',
+            '.webp': 'WEBP',
+            '.tiff': 'TIFF',
+        }
+
+    def _download_original(self) -> Union[str, None]:
+        """
+        Download the original file to a temporary location
+
+        Returns:
+            str: Path to the downloaded file, or None if download failed
+        """
+        try:
+            file_manager = self.file.file_manager
+            backend = file_manager.backend
+
+            # Get file extension
+            _, ext = os.path.splitext(self.file.filename)
+            temp_path = self.get_temp_path(ext)
+
+            # Download file from storage
+            backend.download(self.file.storage_file_path, temp_path)
+            return temp_path
+        except Exception as e:
+            logger.error(f"Failed to download original file: {str(e)}")
+            return None
+
+    def _get_output_format(self, source_path: str, options: Dict = None) -> Tuple[str, str]:
+        """
+        Determine the output format and file extension
+
+        Args:
+            source_path: Path to the source image
+            options: Additional options for format selection
+
+        Returns:
+            Tuple[str, str]: (PIL format name, file extension)
+        """
+        _, ext = os.path.splitext(source_path.lower())
+
+        # Use specified format if provided
+        if options and 'format' in options:
+            format_name = options['format'].upper()
+            if format_name == 'JPEG':
+                return format_name, '.jpg'
+            return format_name, f".{options['format'].lower()}"
+
+        # Use original format if supported
+        if ext in self.format_map:
+            return self.format_map[ext], ext
+
+        # Default to JPEG
+        return self.default_format, '.jpg'
+
+    def _process_image(self, source_path: str, width: int, height: int,
+                      mode: str = 'contain', options: Dict = None) -> Tuple[BinaryIO, str, str]:
+        """
+        Process image to create a rendition
+
+        Args:
+            source_path: Path to the source image
+            width: Target width
+            height: Target height
+            mode: Resize mode ('contain', 'crop', 'stretch')
+            options: Additional processing options
+
+        Returns:
+            Tuple[BinaryIO, str, str]: (Image data, format, mime type)
+        """
+        options = options or {}
+        quality = options.get('quality', self.default_quality)
+
+        try:
+            # Open the image
+            with Image.open(source_path) as img:
+                # Convert to RGB if RGBA (unless PNG or format with alpha support)
+                if img.mode == 'RGBA' and options.get('format', '').upper() != 'PNG':
+                    img = img.convert('RGB')
+
+                # Process based on mode
+                if mode == 'crop':
+                    # Square crop (centered)
+                    img = ImageOps.fit(img, (width, height), Image.Resampling.LANCZOS)
+                elif mode == 'contain':
+                    # Resize to fit within dimensions while maintaining aspect ratio
+                    img.thumbnail((width, height), Image.Resampling.LANCZOS)
+                elif mode == 'stretch':
+                    # Stretch to fill dimensions
+                    img = img.resize((width, height), Image.Resampling.LANCZOS)
+
+                # Determine output format
+                format_name, extension = self._get_output_format(source_path, options)
+
+                # Save to buffer
+                buffer = io.BytesIO()
+                if format_name == 'JPEG':
+                    img.save(buffer, format=format_name, quality=quality, optimize=True)
+                else:
+                    img.save(buffer, format=format_name)
+
+                buffer.seek(0)
+                mime_type = mimetypes.guess_type(f"file{extension}")[0]
+
+                return buffer, extension, mime_type
+        except Exception as e:
+            logger.error(f"Image processing error: {str(e)}")
+            raise
+
+    def create_rendition(self, role: str, options: Dict = None) -> Optional[FileRendition]:
+        """
+        Create an image rendition for the specified role
+
+        Args:
+            role: The role of the rendition
+            options: Additional options for creating the rendition
+
+        Returns:
+            FileRendition: The created rendition, or None if creation failed
+        """
+        try:
+            # Get rendition settings
+            settings = self.default_renditions.get(role, {})
+            if options:
+                settings.update(options)
+
+            # Default dimensions and mode
+            width = settings.get('width', 150)
+            height = settings.get('height', 150)
+            mode = settings.get('mode', 'contain')
+
+            # Download the original file
+            source_path = self._download_original()
+            if not source_path:
+                return None
+
+            try:
+                # Process the image
+                buffer, extension, mime_type = self._process_image(
+                    source_path, width, height, mode, settings
+                )
+
+                # Generate output filename
+                name, _ = os.path.splitext(self.file.storage_filename)
+                filename = f"{name}_renditions/{role}{extension}"
+
+                # Save to storage
+                file_manager = self.file.file_manager
+                backend = file_manager.backend
+                storage_path = os.path.join(
+                    os.path.dirname(self.file.storage_file_path),
+                    filename
+                )
+
+                # Upload to storage
+                # print(storage_path)
+                backend.save(buffer, storage_path, mime_type)
+
+                # Get file size
+                file_size = buffer.getbuffer().nbytes
+
+                # Create rendition record
+                rendition = self._create_rendition_object(
+                    role=role,
+                    filename=filename,
+                    storage_path=storage_path,
+                    content_type=mime_type,
+                    category='image',
+                    file_size=file_size
+                )
+
+                return rendition
+            finally:
+                # Clean up temporary file
+                if os.path.exists(source_path):
+                    os.unlink(source_path)
+
+        except Exception as e:
+            logger.error(f"Failed to create image rendition '{role}': {str(e)}")
+            return None

mojo/apps/fileman/renderer/utils.py

@@ -0,0 +1,297 @@
+import os
+import mimetypes
+import tempfile
+import logging
+import shutil
+import hashlib
+from typing import Dict, List, Tuple, Optional, Union, Any
+
+logger = logging.getLogger(__name__)
+
+# Additional MIME type mappings that might not be in the standard library
+ADDITIONAL_MIME_TYPES = {
+    '.webp': 'image/webp',
+    '.heic': 'image/heic',
+    '.heif': 'image/heif',
+    '.webm': 'video/webm',
+    '.mkv': 'video/x-matroska',
+    '.m4a': 'audio/mp4',
+    '.flac': 'audio/flac',
+}
+
+# Register additional MIME types
+for ext, type_name in ADDITIONAL_MIME_TYPES.items():
+    mimetypes.add_type(type_name, ext)
+
+# Map of file categories by MIME type prefix
+CATEGORY_MAP = {
+    'image/': 'image',
+    'video/': 'video',
+    'audio/': 'audio',
+    'text/': 'document',
+    'application/pdf': 'pdf',
+    'application/msword': 'document',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml': 'document',
+    'application/vnd.ms-excel': 'spreadsheet',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml': 'spreadsheet',
+    'application/vnd.ms-powerpoint': 'presentation',
+    'application/vnd.openxmlformats-officedocument.presentationml': 'presentation',
+    'application/zip': 'archive',
+    'application/x-rar-compressed': 'archive',
+    'application/x-7z-compressed': 'archive',
+    'application/x-tar': 'archive',
+    'application/gzip': 'archive',
+}
+
+def get_file_category(mime_type: str) -> str:
+    """
+    Determine the category of a file based on its MIME type.
+    
+    Args:
+        mime_type: The MIME type of the file
+        
+    Returns:
+        str: The category of the file (image, video, audio, document, etc.)
+    """
+    if not mime_type:
+        return 'unknown'
+    
+    # Check for exact matches
+    if mime_type in CATEGORY_MAP:
+        return CATEGORY_MAP[mime_type]
+    
+    # Check for prefix matches
+    for prefix, category in CATEGORY_MAP.items():
+        if prefix.endswith('/'):
+            if mime_type.startswith(prefix):
+                return category
+    
+    # Default category
+    return 'other'
+
+def get_file_info(file_path: str) -> Dict[str, Any]:
+    """
+    Get information about a file
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        Dict with file information (size, mime_type, category, etc.)
+    """
+    if not os.path.exists(file_path):
+        return {
+            'exists': False,
+            'size': 0,
+            'mime_type': None,
+            'category': 'unknown',
+        }
+    
+    file_size = os.path.getsize(file_path)
+    mime_type, _ = mimetypes.guess_type(file_path)
+    category = get_file_category(mime_type)
+    
+    return {
+        'exists': True,
+        'size': file_size,
+        'mime_type': mime_type,
+        'category': category,
+        'extension': os.path.splitext(file_path)[1].lower(),
+    }
+
+def create_temp_directory() -> str:
+    """
+    Create a temporary directory for file processing
+    
+    Returns:
+        str: Path to the temporary directory
+    """
+    return tempfile.mkdtemp()
+
+def create_temp_file(suffix: str = '') -> str:
+    """
+    Create a temporary file for processing
+    
+    Args:
+        suffix: Optional suffix for the temp file (e.g., '.jpg')
+        
+    Returns:
+        str: Path to the temporary file
+    """
+    fd, path = tempfile.mkstemp(suffix=suffix)
+    os.close(fd)
+    return path
+
+def cleanup_temp_files(paths: List[str]):
+    """
+    Clean up temporary files and directories
+    
+    Args:
+        paths: List of paths to clean up
+    """
+    for path in paths:
+        if not path:
+            continue
+        try:
+            if os.path.isdir(path):
+                shutil.rmtree(path, ignore_errors=True)
+            elif os.path.exists(path):
+                os.unlink(path)
+        except Exception as e:
+            logger.warning(f"Failed to clean up temporary path {path}: {str(e)}")
+
+def calculate_file_hash(file_path: str, algorithm: str = 'md5') -> str:
+    """
+    Calculate hash for a file
+    
+    Args:
+        file_path: Path to the file
+        algorithm: Hash algorithm to use (md5, sha1, sha256)
+        
+    Returns:
+        str: Hex digest of the hash
+    """
+    if algorithm == 'md5':
+        hash_obj = hashlib.md5()
+    elif algorithm == 'sha1':
+        hash_obj = hashlib.sha1()
+    elif algorithm == 'sha256':
+        hash_obj = hashlib.sha256()
+    else:
+        raise ValueError(f"Unsupported hash algorithm: {algorithm}")
+    
+    with open(file_path, 'rb') as f:
+        for chunk in iter(lambda: f.read(4096), b''):
+            hash_obj.update(chunk)
+    
+    return hash_obj.hexdigest()
+
+def calculate_dimensions(original_width: int, original_height: int, 
+                         target_width: int, target_height: int, 
+                         mode: str = 'contain') -> Tuple[int, int]:
+    """
+    Calculate dimensions for resizing an image or video
+    
+    Args:
+        original_width: Original width
+        original_height: Original height
+        target_width: Target width
+        target_height: Target height
+        mode: Resize mode ('contain', 'cover', 'stretch')
+        
+    Returns:
+        Tuple[int, int]: (new_width, new_height)
+    """
+    if mode == 'stretch':
+        return target_width, target_height
+    
+    # Calculate aspect ratios
+    original_ratio = original_width / original_height
+    target_ratio = target_width / target_height
+    
+    if mode == 'contain':
+        # Fit within target dimensions while maintaining aspect ratio
+        if original_ratio > target_ratio:
+            # Width is the limiting factor
+            new_width = target_width
+            new_height = int(new_width / original_ratio)
+        else:
+            # Height is the limiting factor
+            new_height = target_height
+            new_width = int(new_height * original_ratio)
+    else:  # cover
+        # Fill target dimensions while maintaining aspect ratio
+        if original_ratio > target_ratio:
+            # Height is the limiting factor
+            new_height = target_height
+            new_width = int(new_height * original_ratio)
+        else:
+            # Width is the limiting factor
+            new_width = target_width
+            new_height = int(new_width / original_ratio)
+    
+    return new_width, new_height
+
+def get_video_duration(video_path: str) -> Optional[float]:
+    """
+    Get the duration of a video file in seconds
+    
+    Args:
+        video_path: Path to the video file
+        
+    Returns:
+        float: Duration in seconds, or None if duration couldn't be determined
+    """
+    try:
+        import subprocess
+        
+        # Use ffprobe to get video duration
+        cmd = [
+            "ffprobe",
+            "-v", "error",
+            "-show_entries", "format=duration",
+            "-of", "default=noprint_wrappers=1:nokey=1",
+            video_path
+        ]
+        
+        result = subprocess.run(cmd, 
+                               stdout=subprocess.PIPE, 
+                               stderr=subprocess.PIPE, 
+                               text=True, 
+                               check=True)
+        
+        duration = float(result.stdout.strip())
+        return duration
+    except Exception as e:
+        logger.error(f"Failed to get video duration: {str(e)}")
+        return None
+
+def get_audio_duration(audio_path: str) -> Optional[float]:
+    """
+    Get the duration of an audio file in seconds
+    
+    Args:
+        audio_path: Path to the audio file
+        
+    Returns:
+        float: Duration in seconds, or None if duration couldn't be determined
+    """
+    return get_video_duration(audio_path)  # Use the same ffprobe method
+
+def get_image_dimensions(image_path: str) -> Optional[Tuple[int, int]]:
+    """
+    Get dimensions of an image
+    
+    Args:
+        image_path: Path to the image file
+        
+    Returns:
+        Tuple[int, int]: (width, height), or None if dimensions couldn't be determined
+    """
+    try:
+        from PIL import Image
+        with Image.open(image_path) as img:
+            return img.size
+    except Exception as e:
+        logger.error(f"Failed to get image dimensions: {str(e)}")
+        return None
+
+def format_filesize(size_in_bytes: int) -> str:
+    """
+    Format a file size in bytes to a human-readable string
+    
+    Args:
+        size_in_bytes: Size in bytes
+        
+    Returns:
+        str: Human-readable file size (e.g., "1.2 MB")
+    """
+    if size_in_bytes < 1024:
+        return f"{size_in_bytes} B"
+    
+    for unit in ['KB', 'MB', 'GB', 'TB', 'PB']:
+        size_in_bytes /= 1024.0
+        if size_in_bytes < 1024.0:
+            return f"{size_in_bytes:.1f} {unit}"
+    
+    return f"{size_in_bytes:.1f} PB"