Update core/visual_engine.py

core/visual_engine.py

@@ -1,192 +1,208 @@
 # core/visual_engine.py
+import tempfile
+import logging
+from pathlib import Path
 from PIL import Image, ImageDraw, ImageFont
 from moviepy.editor import ImageClip, concatenate_videoclips
 import os
 
+# Set up logging
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
 class VisualEngine:
-    def __init__(self, output_dir="temp_generated_media"): # Changed default to avoid confusion with local dev
-        self.output_dir = output_dir
+    def __init__(self, output_dir=None):
+        """
+        Initialize the visual engine with a safe output directory.
+        
+        If no output_dir is provided, creates a temporary directory in the system temp location.
+        This avoids permission issues as /tmp is typically writable by all users.
+        """
+        self.output_dir = output_dir or self._create_temp_output_dir()
+        logger.info(f"Using output directory: {self.output_dir}")
+        
+        # Ensure the directory exists and has proper permissions
         os.makedirs(self.output_dir, exist_ok=True)
+        os.chmod(self.output_dir, 0o775)  # Ensure writable by user and group
         
         # --- Font Setup ---
-        # This path should match where you COPY the font in your Dockerfile.
-        # Example: COPY assets/fonts/arial.ttf /usr/local/share/fonts/truetype/mycustomfonts/arial.ttf
-        self.font_filename = "arial.ttf" # Or "DejaVuSans.ttf" or your chosen font
-        self.font_path_in_container = f"/usr/local/share/fonts/truetype/mycustomfonts/{self.font_filename}"
+        self.font_filename = "arial.ttf"
         self.font_size_pil = 24
         
-        try:
-            self.font = ImageFont.truetype(self.font_path_in_container, self.font_size_pil)
-            print(f"Successfully loaded font: {self.font_path_in_container} with size {self.font_size_pil}")
-        except IOError:
-            print(f"Error: Could not load font from '{self.font_path_in_container}'. "
-                  f"Ensure the font file '{self.font_filename}' is in 'assets/fonts/' "
-                  f"and the Dockerfile correctly copies it. Falling back to default font.")
+        # Try multiple font locations with fallbacks
+        self.font = self._load_font_with_fallbacks()
+        
+        if self.font:
+            logger.info(f"Successfully loaded font: {self.font_path}")
+        else:
+            logger.warning("Could not load any custom font. Falling back to default font.")
             self.font = ImageFont.load_default()
-            # Adjust size if using default font, as it's typically smaller and metrics differ
-            self.font_size_pil = 11 # Default font is often ~10px, this is an estimate for line height
-
+            self.font_size_pil = 11  # Adjust for default font
+
+    def _create_temp_output_dir(self):
+        """Create a temporary directory with appropriate permissions"""
+        temp_dir = tempfile.mkdtemp(prefix="cinegen_media_")
+        os.chmod(temp_dir, 0o775)  # rwxrwxr-x permissions
+        return temp_dir
+
+    def _load_font_with_fallbacks(self):
+        """Try multiple font locations with graceful fallback"""
+        # List of possible font locations (Docker and local development)
+        possible_font_paths = [
+            # Docker container path
+            f"/usr/local/share/fonts/truetype/mycustomfonts/{self.font_filename}",
+            # Local development path (relative to script)
+            os.path.join(os.path.dirname(__file__), "..", "assets", "fonts", self.font_filename),
+            # System fonts as last resort
+            f"/usr/share/fonts/truetype/{self.font_filename}",
+            f"/usr/share/fonts/TTF/{self.font_filename}"
+        ]
+        
+        for font_path in possible_font_paths:
+            try:
+                if os.path.exists(font_path):
+                    self.font_path = font_path
+                    return ImageFont.truetype(font_path, self.font_size_pil)
+            except IOError as e:
+                logger.warning(f"Could not load font from {font_path}: {str(e)}")
+        
+        return None
 
     def _get_text_dimensions(self, text_content, font_obj):
         """
         Gets the width and height of a single line of text with the given font.
         Returns (width, height).
         """
-        if text_content == "" or text_content is None: # Handle empty string
-            return 0, self.font_size_pil # Return 0 width, default height
+        if not text_content:
+            return 0, self.font_size_pil
 
         try:
-            if hasattr(font_obj, 'getbbox'): # For newer Pillow versions (>=8.0.0)
-                # getbbox returns (left, top, right, bottom)
+            # Modern Pillow (>=8.0.0)
+            if hasattr(font_obj, 'getbbox'):
                 bbox = font_obj.getbbox(text_content)
-                width = bbox[2] - bbox[0]
-                height = bbox[3] - bbox[1]
-                # If height is 0 for some reason (e.g. empty string was passed and not caught), use font_size_pil
-                return width, height if height > 0 else self.font_size_pil
-            elif hasattr(font_obj, 'getsize'): # For older Pillow versions
-                width, height = font_obj.getsize(text_content)
-                return width, height if height > 0 else self.font_size_pil
-            else: # Fallback for very basic font objects (like default font after failure)
-                avg_char_width = self.font_size_pil * 0.6 # Rough estimate
-                height_estimate = self.font_size_pil * 1.2
-                return int(len(text_content) * avg_char_width), int(height_estimate if height_estimate > 0 else self.font_size_pil)
+                return bbox[2] - bbox[0], bbox[3] - bbox[1]
+            # Legacy Pillow
+            elif hasattr(font_obj, 'getsize'):
+                return font_obj.getsize(text_content)
         except Exception as e:
-            print(f"Warning: Error getting text dimensions for '{text_content}': {e}. Using estimates.")
-            # Fallback estimates if any error occurs
-            avg_char_width = self.font_size_pil * 0.6
-            height_estimate = self.font_size_pil * 1.2
-            return int(len(text_content) * avg_char_width), int(height_estimate if height_estimate > 0 else self.font_size_pil)
-
+            logger.warning(f"Error measuring text: {str(e)}")
+        
+        # Fallback calculation
+        avg_char_width = self.font_size_pil * 0.6
+        return int(len(text_content) * avg_char_width), self.font_size_pil
 
     def create_placeholder_image(self, text_description, filename, size=(1280, 720)):
-        img = Image.new('RGB', size, color=(30, 30, 60))  # Darker blueish background
-        draw = ImageDraw.Draw(img)
+        """Create placeholder image with wrapped text"""
+        try:
+            img = Image.new('RGB', size, color=(30, 30, 60))
+            draw = ImageDraw.Draw(img)
+            
+            if not text_description:
+                text_description = "No description provided"
+                
+            # Create text with wrapping
+            lines = self._wrap_text(text_description, size[0] - 80, draw)
+            
+            # Calculate vertical position to center text
+            _, line_height = self._get_text_dimensions("Tg", self.font)
+            total_height = len(lines) * line_height * 1.3
+            y_pos = max(40, (size[1] - total_height) / 2)
+            
+            # Draw each line
+            for line in lines:
+                line_width, _ = self._get_text_dimensions(line, self.font)
+                x_pos = (size[0] - line_width) / 2
+                draw.text((x_pos, y_pos), line, fill=(220, 220, 150), font=self.font)
+                y_pos += line_height * 1.3
+                
+            # Save to output directory
+            output_path = os.path.join(self.output_dir, filename)
+            img.save(output_path)
+            logger.debug(f"Created placeholder image: {output_path}")
+            return output_path
+            
+        except Exception as e:
+            logger.error(f"Error creating placeholder image: {str(e)}")
+            return None
 
-        padding = 40
-        max_text_width = size[0] - (2 * padding)
+    def _wrap_text(self, text, max_width, draw):
+        """Wrap text to fit within specified width"""
+        words = text.split()
         lines = []
+        current_line = []
         
-        if not text_description: # Handle case where text_description might be None or empty
-            text_description = "(No description provided)"
-
-        words = text_description.split()
-        current_line = ""
-
-        if not self.font: # Should not happen if __init__ fallback works, but as a safeguard
-            print("Error: Font object is not initialized in create_placeholder_image. Cannot draw text.")
-            return None
-
         for word in words:
-            test_line_candidate = current_line + word + " "
-            line_width, _ = self._get_text_dimensions(test_line_candidate.strip(), self.font)
-
-            if line_width <= max_text_width and current_line != "": # If it fits and current_line is not empty
-                current_line = test_line_candidate
-            elif line_width <= max_text_width and current_line == "": # First word, and it fits
-                 current_line = test_line_candidate
-            elif current_line != "": # If it doesn't fit and current_line is not empty, finalize current_line
-                lines.append(current_line.strip())
-                current_line = word + " " # Start new line with current word
-            else: # Word itself is too long for a line
-                # Simple truncation for very long words (can be improved with character-level wrapping)
-                temp_word = word
-                while self._get_text_dimensions(temp_word, self.font)[0] > max_text_width and len(temp_word) > 0:
-                    temp_word = temp_word[:-1]
-                lines.append(temp_word)
-                current_line = "" # Reset current line
-
-        if current_line.strip(): # Add the last line if it has content
-            lines.append(current_line.strip())
-        
-        if not lines: # If after all that, lines is empty (e.g. only very long words that got truncated to nothing)
-            lines.append("(Text too long or error)")
-
-        # Calculate starting y position to center the text block
-        _, single_line_height = self._get_text_dimensions("Tg", self.font) # Get height of a typical line
-        if single_line_height == 0: # Safety for failed get_text_dimensions
-            single_line_height = self.font_size_pil 
+            test_line = ' '.join(current_line + [word])
+            test_width, _ = self._get_text_dimensions(test_line, self.font)
             
-        line_spacing_factor = 1.3 # Adjust for spacing between lines
-        estimated_line_block_height = len(lines) * single_line_height * line_spacing_factor
+            if test_width <= max_width:
+                current_line.append(word)
+            else:
+                if current_line:
+                    lines.append(' '.join(current_line))
+                current_line = [word]
+                
+                # Handle very long words
+                if self._get_text_dimensions(word, self.font)[0] > max_width:
+                    # Break word if needed
+                    while self._get_text_dimensions(''.join(current_line), self.font)[0] > max_width:
+                        current_line[0] = current_line[0][:-1]
         
-        y_text = (size[1] - estimated_line_block_height) / 2.0
-        if y_text < padding: # Ensure text doesn't start too high if too much text
-            y_text = float(padding)
-
-        for line in lines:
-            line_width, _ = self._get_text_dimensions(line, self.font)
-            x_text = (size[0] - line_width) / 2.0
-            if x_text < padding: # Ensure text doesn't start too left
-                x_text = float(padding)
-
-            draw.text(
-                xy=(x_text, y_text),
-                text=line,
-                fill=(220, 220, 150),  # Lighter Yellow text
-                font=self.font
-            )
-            y_text += single_line_height * line_spacing_factor
-
-        filepath = os.path.join(self.output_dir, filename)
-        try:
-            img.save(filepath)
-            # print(f"Placeholder image saved: {filepath}") # Can be noisy, uncomment for debugging
-        except Exception as e:
-            print(f"Error saving image {filepath}: {e}")
-            return None
-        return filepath
-
+        if current_line:
+            lines.append(' '.join(current_line))
+            
+        return lines or ["(Text rendering error)"]
 
     def create_video_from_images(self, image_paths, output_filename="final_video.mp4", fps=1, duration_per_image=3):
+        """Create video from sequence of images"""
         if not image_paths:
-            print("No images provided to create video.")
+            logger.error("No images provided for video creation")
             return None
-
-        valid_image_paths = [p for p in image_paths if p and os.path.exists(p)]
-        if not valid_image_paths:
-            print("No valid image paths found to create video. Ensure images were generated and paths are correct.")
+            
+        valid_paths = [p for p in image_paths if p and os.path.exists(p)]
+        if not valid_paths:
+            logger.error("No valid image paths found")
             return None
+            
+        logger.info(f"Creating video from {len(valid_paths)} images")
         
-        print(f"Attempting to create video from {len(valid_image_paths)} images: {valid_image_paths}")
-
         try:
             clips = []
-            for m_path in valid_image_paths:
+            for img_path in valid_paths:
                 try:
-                    clip = ImageClip(m_path).set_duration(duration_per_image)
+                    clip = ImageClip(img_path).set_duration(duration_per_image)
                     clips.append(clip)
-                except Exception as e_clip:
-                    print(f"Error creating ImageClip for {m_path}: {e_clip}. Skipping this image.")
+                except Exception as e:
+                    logger.error(f"Error processing {img_path}: {str(e)}")
             
             if not clips:
-                print("Could not create any ImageClips from the provided image paths.")
                 return None
                 
-            video_clip = concatenate_videoclips(clips, method="compose")
+            video = concatenate_videoclips(clips, method="compose")
             output_path = os.path.join(self.output_dir, output_filename)
             
-            print(f"Writing video to: {output_path}")
-            video_clip.write_videofile(
+            # Write video file
+            video.write_videofile(
                 output_path,
                 fps=fps,
                 codec='libx264',
-                audio_codec='aac', # Required even if no audio, or can cause issues
-                temp_audiofile=os.path.join(self.output_dir, 'temp-audio.m4a'), # Ensure this path is writable
+                audio_codec='aac',
+                temp_audiofile=os.path.join(self.output_dir, 'temp_audio.m4a'),
                 remove_temp=True,
-                threads=os.cpu_count() or 2, # Use available CPUs or default to 2
-                logger='bar' # Use 'bar' for progress, None to suppress totally
+                threads=os.cpu_count() or 2,
+                logger=None  # Suppress moviepy's verbose output
             )
-            # Close clips to release file handles, especially important on some OS / Docker
-            for clip_to_close in clips:
-                clip_to_close.close()
-            if hasattr(video_clip, 'close'):
-                video_clip.close()
-
-            print(f"Video successfully created: {output_path}")
+            
+            # Clean up resources
+            for clip in clips:
+                clip.close()
+            video.close()
+            
+            logger.info(f"Video created: {output_path}")
             return output_path
+            
         except Exception as e:
-            print(f"Error creating video: {e}")
-            if isinstance(e, OSError): # Or check for specific ffmpeg error messages
-                print("OSError during video creation. This often indicates an issue with ffmpeg, "
-                      "its installation, or permissions to write temporary files.")
+            logger.error(f"Video creation failed: {str(e)}")
+            if isinstance(e, OSError):
+                logger.error("OSError: Check ffmpeg installation and file permissions")
             return None