Update core/visual_engine.py

core/visual_engine.py

@@ -1,7 +1,6 @@
 # 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
@@ -12,76 +11,59 @@ logging.basicConfig(level=logging.INFO)
 
 class VisualEngine:
     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 ---
-        self.font_filename = "arial.ttf"
+        # Font configuration
         self.font_size_pil = 24
-        
-        # Try multiple font locations with fallbacks
-        self.font = self._load_font_with_fallbacks()
+        self.font = self._load_system_font()
         
         if self.font:
-            logger.info(f"Successfully loaded font: {self.font_path}")
+            logger.info(f"Using font: {self.font.path if hasattr(self.font, 'path') else 'default'}")
         else:
-            logger.warning("Could not load any custom font. Falling back to default font.")
+            logger.warning("Could not load any suitable font. Falling back to default font.")
             self.font = ImageFont.load_default()
-            self.font_size_pil = 11  # Adjust for default font
+            self.font_size_pil = 11
 
     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
+        os.chmod(temp_dir, 0o775)
         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}"
+    def _load_system_font(self):
+        """Load the best available system font"""
+        font_names = [
+            "DejaVuSans.ttf",       # Common in Linux
+            "FreeSans.ttf",          # From fonts-freefont-ttf
+            "LiberationSans-Regular.ttf",  # Red Hat font
+            "Arial.ttf",             # Sometimes available
+            "Vera.ttf"               # Bitstream Vera
         ]
         
-        for font_path in possible_font_paths:
+        # Try to load each font in order
+        for font_name in font_names:
             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 ImageFont.truetype(font_name, self.font_size_pil)
+            except IOError:
+                continue
         
-        return None
+        # Try system default sans-serif as last resort
+        try:
+            return ImageFont.truetype("sans-serif", self.font_size_pil)
+        except:
+            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).
-        """
+        """Get text dimensions with modern Pillow methods"""
         if not text_content:
             return 0, self.font_size_pil
 
         try:
-            # Modern Pillow (>=8.0.0)
             if hasattr(font_obj, 'getbbox'):
                 bbox = font_obj.getbbox(text_content)
                 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:
@@ -101,7 +83,7 @@ class VisualEngine:
                 text_description = "No description provided"
                 
             # Create text with wrapping
-            lines = self._wrap_text(text_description, size[0] - 80, draw)
+            lines = self._wrap_text(text_description, size[0] - 80)
             
             # Calculate vertical position to center text
             _, line_height = self._get_text_dimensions("Tg", self.font)
@@ -118,15 +100,17 @@ class VisualEngine:
             # 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
 
-    def _wrap_text(self, text, max_width, draw):
+    def _wrap_text(self, text, max_width):
         """Wrap text to fit within specified width"""
+        if not text:
+            return ["(No text)"]
+            
         words = text.split()
         lines = []
         current_line = []
@@ -144,8 +128,7 @@ class VisualEngine:
                 
                 # 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:
+                    while current_line and self._get_text_dimensions(''.join(current_line), self.font)[0] > max_width:
                         current_line[0] = current_line[0][:-1]
         
         if current_line:
@@ -164,24 +147,11 @@ class VisualEngine:
             logger.error("No valid image paths found")
             return None
             
-        logger.info(f"Creating video from {len(valid_paths)} images")
-        
         try:
-            clips = []
-            for img_path in valid_paths:
-                try:
-                    clip = ImageClip(img_path).set_duration(duration_per_image)
-                    clips.append(clip)
-                except Exception as e:
-                    logger.error(f"Error processing {img_path}: {str(e)}")
-            
-            if not clips:
-                return None
-                
+            clips = [ImageClip(img_path).set_duration(duration_per_image) for img_path in valid_paths]
             video = concatenate_videoclips(clips, method="compose")
             output_path = os.path.join(self.output_dir, output_filename)
             
-            # Write video file
             video.write_videofile(
                 output_path,
                 fps=fps,
@@ -190,7 +160,7 @@ class VisualEngine:
                 temp_audiofile=os.path.join(self.output_dir, 'temp_audio.m4a'),
                 remove_temp=True,
                 threads=os.cpu_count() or 2,
-                logger=None  # Suppress moviepy's verbose output
+                logger=None
             )
             
             # Clean up resources
@@ -198,11 +168,8 @@ class VisualEngine:
                 clip.close()
             video.close()
             
-            logger.info(f"Video created: {output_path}")
             return output_path
             
         except Exception as e:
             logger.error(f"Video creation failed: {str(e)}")
-            if isinstance(e, OSError):
-                logger.error("OSError: Check ffmpeg installation and file permissions")
             return None