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

mojo/apps/fileman/renderer/video.py

@@ -0,0 +1,304 @@
+import os
+import io
+import subprocess
+import tempfile
+import logging
+import mimetypes
+import shutil
+from typing import Dict, Optional, Tuple, Union, BinaryIO, List
+
+from mojo.apps.fileman.models import File, FileRendition
+from mojo.apps.fileman.renderer.base import BaseRenderer, RenditionRole
+
+logger = logging.getLogger(__name__)
+
+class VideoRenderer(BaseRenderer):
+    """
+    Renderer for video files
+    
+    Creates various renditions like thumbnails, previews, and different formats using ffmpeg
+    """
+    
+    # Video file categories
+    supported_categories = ['video']
+    
+    # Default rendition definitions with options
+    default_renditions = {
+        RenditionRole.VIDEO_THUMBNAIL: {
+            'width': 300, 
+            'height': 169, 
+            'time_offset': '00:00:03',
+            'format': 'jpg'
+        },
+        RenditionRole.THUMBNAIL: {
+            'width': 300, 
+            'height': 169, 
+            'time_offset': '00:00:03',
+            'format': 'jpg'
+        },
+        RenditionRole.VIDEO_PREVIEW: {
+            'width': 640,
+            'height': 360,
+            'bitrate': '500k',
+            'duration': 10,
+            'format': 'mp4',
+            'audio': True,
+        },
+        RenditionRole.VIDEO_MP4: {
+            'width': 1280,
+            'height': 720,
+            'bitrate': '2000k',
+            'format': 'mp4',
+            'audio': True,
+        },
+        RenditionRole.VIDEO_WEBM: {
+            'width': 1280,
+            'height': 720,
+            'bitrate': '2000k',
+            'format': 'webm',
+            'audio': True,
+        },
+    }
+    
+    def __init__(self, file: File):
+        super().__init__(file)
+        # Check if ffmpeg is available
+        self._check_ffmpeg()
+    
+    def _check_ffmpeg(self):
+        """Check if ffmpeg is available in the system"""
+        try:
+            subprocess.run(["ffmpeg", "-version"], 
+                           stdout=subprocess.PIPE, 
+                           stderr=subprocess.PIPE, 
+                           check=True)
+        except (subprocess.SubprocessError, FileNotFoundError):
+            logger.warning("ffmpeg is not available. Video rendering may not work properly.")
+    
+    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
+            with open(temp_path, 'wb') as f:
+                backend.download(self.file.storage_file_path, f)
+            
+            return temp_path
+        except Exception as e:
+            logger.error(f"Failed to download original video file: {str(e)}")
+            return None
+    
+    def _create_thumbnail(self, source_path: str, width: int, height: int, 
+                        time_offset: str, output_format: str) -> Tuple[str, str, int]:
+        """
+        Create a thumbnail from a video at specified time offset
+        
+        Args:
+            source_path: Path to the source video
+            width: Target width
+            height: Target height
+            time_offset: Time offset for thumbnail (format: HH:MM:SS)
+            output_format: Output format (jpg, png)
+            
+        Returns:
+            Tuple[str, str, int]: (Output path, mime type, file size)
+        """
+        temp_output = self.get_temp_path(f".{output_format}")
+        
+        try:
+            # Use ffmpeg to extract a frame
+            cmd = [
+                "ffmpeg",
+                "-y",  # Overwrite output files
+                "-ss", time_offset,  # Seek to time offset
+                "-i", source_path,  # Input file
+                "-vframes", "1",  # Extract one frame
+                "-s", f"{width}x{height}",  # Set size
+                "-f", "image2",  # Force image2 format
+                temp_output  # Output file
+            ]
+            
+            subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            # Get file size
+            file_size = os.path.getsize(temp_output)
+            
+            # Get mime type
+            mime_type = mimetypes.guess_type(f"file.{output_format}")[0]
+            
+            return temp_output, mime_type, file_size
+            
+        except subprocess.SubprocessError as e:
+            logger.error(f"Failed to create video thumbnail: {str(e)}")
+            if os.path.exists(temp_output):
+                os.unlink(temp_output)
+            raise
+    
+    def _create_video_rendition(self, source_path: str, options: Dict) -> Tuple[str, str, int]:
+        """
+        Create a video rendition with specified options
+        
+        Args:
+            source_path: Path to the source video
+            options: Video processing options
+            
+        Returns:
+            Tuple[str, str, int]: (Output path, mime type, file size)
+        """
+        width = options.get('width', 1280)
+        height = options.get('height', 720)
+        bitrate = options.get('bitrate', '2000k')
+        output_format = options.get('format', 'mp4')
+        duration = options.get('duration')  # Optional duration limit in seconds
+        audio = options.get('audio', True)
+        
+        temp_output = self.get_temp_path(f".{output_format}")
+        
+        try:
+            # Build ffmpeg command
+            cmd = [
+                "ffmpeg",
+                "-y",  # Overwrite output files
+                "-i", source_path,  # Input file
+            ]
+            
+            # Add duration limit if specified
+            if duration:
+                cmd.extend(["-t", str(duration)])
+            
+            # Video settings
+            cmd.extend([
+                "-vf", f"scale={width}:{height}",
+                "-c:v", "libx264" if output_format == "mp4" else "libvpx",
+                "-b:v", bitrate,
+            ])
+            
+            # Audio settings
+            if audio:
+                if output_format == "mp4":
+                    cmd.extend(["-c:a", "aac", "-b:a", "128k"])
+                else:  # webm
+                    cmd.extend(["-c:a", "libvorbis", "-b:a", "128k"])
+            else:
+                cmd.extend(["-an"])  # No audio
+            
+            # Add output file
+            cmd.append(temp_output)
+            
+            subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            
+            # Get file size
+            file_size = os.path.getsize(temp_output)
+            
+            # Get mime type
+            mime_type = mimetypes.guess_type(f"file.{output_format}")[0]
+            
+            return temp_output, mime_type, file_size
+            
+        except subprocess.SubprocessError as e:
+            logger.error(f"Failed to create video rendition: {str(e)}")
+            if os.path.exists(temp_output):
+                os.unlink(temp_output)
+            raise
+    
+    def create_rendition(self, role: str, options: Dict = None) -> Optional[FileRendition]:
+        """
+        Create a video 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)
+            
+            # Download the original file
+            source_path = self._download_original()
+            if not source_path:
+                return None
+            
+            try:
+                temp_output = None
+                mime_type = None
+                file_size = None
+                
+                # Process based on role type
+                if role in [RenditionRole.THUMBNAIL, RenditionRole.VIDEO_THUMBNAIL]:
+                    # Create thumbnail image
+                    width = settings.get('width', 300)
+                    height = settings.get('height', 169)
+                    time_offset = settings.get('time_offset', '00:00:03')
+                    output_format = settings.get('format', 'jpg')
+                    
+                    temp_output, mime_type, file_size = self._create_thumbnail(
+                        source_path, width, height, time_offset, output_format
+                    )
+                    
+                    # Set filename
+                    name, _ = os.path.splitext(self.file.filename)
+                    filename = f"{name}_{role}.{output_format}"
+                    category = 'image'  # Thumbnails are images
+                    
+                else:
+                    # Create video rendition
+                    temp_output, mime_type, file_size = self._create_video_rendition(
+                        source_path, settings
+                    )
+                    
+                    # Set filename
+                    name, _ = os.path.splitext(self.file.filename)
+                    output_format = settings.get('format', 'mp4')
+                    filename = f"{name}_{role}.{output_format}"
+                    category = 'video'
+                
+                # 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
+                with open(temp_output, 'rb') as f:
+                    backend.save(f, storage_path, mime_type)
+                
+                # Create rendition record
+                rendition = self._create_rendition_object(
+                    role=role,
+                    filename=filename,
+                    storage_path=storage_path,
+                    content_type=mime_type,
+                    category=category,
+                    file_size=file_size
+                )
+                
+                return rendition
+                
+            finally:
+                # Clean up temporary files
+                if source_path and os.path.exists(source_path):
+                    os.unlink(source_path)
+                if temp_output and os.path.exists(temp_output):
+                    os.unlink(temp_output)
+                    
+        except Exception as e:
+            logger.error(f"Failed to create video rendition '{role}': {str(e)}")
+            return None

mojo/apps/fileman/rest/__init__.py

@@ -3,21 +3,4 @@ File Manager REST API endpoints
 """
 
 from .fileman import on_filemanager, on_file
-from .upload import (
-    on_upload_initiate,
-    on_upload_finalize,
-    on_direct_upload,
-    on_download
-)
-
-__all__ = [
-    # File manager model endpoints
-    'on_filemanager',
-    'on_file',
-    
-    # File upload/download endpoints
-    'on_upload_initiate',
-    'on_upload_finalize',
-    'on_direct_upload',
-    'on_download'
-]
+from .upload import *

mojo/apps/fileman/rest/upload.py

@@ -1,12 +1,7 @@
 from mojo import decorators as md
 from mojo import JsonResponse
+import mojo.errors
 from mojo.apps.fileman.models import File, FileManager
-from mojo.apps.fileman.utils.upload import (
-    initiate_upload,
-    finalize_upload,
-    direct_upload,
-    get_download_url
-)
 
 
 @md.POST('upload/initiate')
@@ -20,40 +15,35 @@ def on_upload_initiate(request):
             {
                 "filename": "document.pdf",
                 "content_type": "application/pdf",
-                "size": 1024000
+                "file_size": 1024000
             }
         ],
-        "file_manager_id": 123,  // optional
-        "group_id": 456,  // optional
+        "file_manager": 123,  // optional
+        "group": 456,  // optional
+        "user": 789,  // optional
         "metadata": {  // optional global metadata
             "source": "web_upload",
             "category": "documents"
         }
     }
     """
-    response_data = initiate_upload(request, request.DATA)
-    status_code = response_data.pop('status_code', 200)
-    return JsonResponse(response_data, status=status_code)
-
-
-@md.POST('upload/finalize')
-def on_upload_finalize(request):
-    """
-    Finalize a file upload
-
-    Request body format:
-    {
-        "upload_token": "abc123...",
-        "file_size": 1024000,  // optional
-        "checksum": "md5:abcdef...",  // optional
-        "metadata": {  // optional additional metadata
-            "processing_complete": true
-        }
-    }
-    """
-    response_data = finalize_upload(request, request.DATA)
-    status_code = response_data.pop('status_code', 200)
-    return JsonResponse(response_data, status=status_code)
+    # first we need to get the correct file manager
+    file_manager = FileManager.get_from_request(request)
+    if file_manager is None:
+        raise mojo.errors.ValueException("No file manager found")
+    # new lets create a new file
+    file = File(
+        filename=request.DATA['filename'],
+        content_type=request.DATA['content_type'],
+        file_size=request.DATA['file_size'],
+        file_manager=file_manager,
+        group=file_manager.group,
+        user=request.user)
+    file.on_rest_pre_save({}, True)
+    file.mark_as_uploading()
+    file.save()
+    file.request_upload_url()
+    return file.on_rest_get(request, "upload")
 
 
 @md.POST('upload/<str:upload_token>')

mojo/apps/fileman/signals.py

@@ -0,0 +1,58 @@
+import logging
+from django.db.models.signals import post_save, post_delete
+from django.dispatch import receiver
+from mojo.apps.fileman.models import File
+from mojo.apps.fileman.tasks import process_file_renditions, cleanup_renditions
+
+logger = logging.getLogger(__name__)
+
+@receiver(post_save, sender=File)
+def handle_file_upload_completed(sender, instance, created, **kwargs):
+    """
+    When a file is marked as completed, automatically create renditions
+    
+    This connects to the post_save signal of the File model and checks if the
+    file has been marked as completed. If so, it queues a task to create renditions.
+    """
+    # Only process if the file upload is completed
+    if instance.is_completed:
+        # Check if this is a status change to completed
+        if not created:
+            try:
+                # Get the previous instance from the database
+                old_instance = sender.objects.get(pk=instance.pk)
+                if old_instance.upload_status != instance.upload_status and instance.upload_status == File.COMPLETED:
+                    logger.info(f"File {instance.id} ({instance.filename}) marked as completed, creating renditions")
+                    # Queue task to create renditions
+                    process_file_renditions.delay(instance.id)
+            except Exception as e:
+                logger.error(f"Error checking file status change: {str(e)}")
+        else:
+            # For new files that are already completed
+            if instance.upload_status == File.COMPLETED:
+                logger.info(f"New file {instance.id} ({instance.filename}) is completed, creating renditions")
+                # Queue task to create renditions
+                process_file_renditions.delay(instance.id)
+
+@receiver(post_delete, sender=File)
+def handle_file_deleted(sender, instance, **kwargs):
+    """
+    When a file is deleted, clean up its renditions
+    
+    This connects to the post_delete signal of the File model and ensures that
+    when a file is deleted, its renditions are also removed from storage.
+    """
+    try:
+        # Check if we have any renditions to clean up
+        from mojo.apps.fileman.models import FileRendition
+        if FileRendition.objects.filter(original_file_id=instance.id).exists():
+            logger.info(f"File {instance.id} ({instance.filename}) deleted, cleaning up renditions")
+            # Queue task to clean up renditions
+            # Note: We can't use instance.id directly in the task since the object is being deleted
+            # So we pass the ID value
+            cleanup_renditions.delay(instance.id)
+    except Exception as e:
+        logger.error(f"Error queueing rendition cleanup for deleted file: {str(e)}")
+
+# Note: No need to manually connect signals as Django will automatically
+# discover and connect properly decorated signal handlers