Update app.py

app.py

@@ -10,17 +10,15 @@ app = Flask(__name__)
 
 class TelegramChatGenerator:
     def __init__(self):
-        # Modern Telegram colors with gradients
-        self.bg_gradient_start = (15, 20, 28)
-        self.bg_gradient_end = (22, 32, 45)
-        self.bubble_color = (55, 125, 255)  # Telegram blue
-        self.bubble_shadow = (35, 90, 200)  # Darker shadow
-        self.reply_bubble_color = (45, 48, 55)
-        self.reply_line_color = (55, 125, 255)  # Blue accent line
+        # Custom bubble colors
+        self.bubble_color = (31, 39, 69)  # #1f2745
+        self.bubble_shadow = (20, 25, 45)  # Darker shadow
+        self.reply_bubble_color = (25, 31, 55)  # Darker for contrast
+        self.reply_line_color = (70, 130, 255)  # Blue accent line
         self.text_color = (255, 255, 255)
-        self.reply_text_color = (140, 150, 165)
+        self.reply_text_color = (160, 170, 185)
         self.username_color = (255, 255, 255)
-        self.time_color = (140, 150, 165)
+        self.time_color = (160, 170, 185)
         
         # Load fonts with fallbacks
         self.load_fonts()
@@ -31,11 +29,11 @@ class TelegramChatGenerator:
     def load_fonts(self):
         """Load fonts with multiple fallbacks"""
         font_paths = [
-            "fonts/Roboto-Regular.ttf",
-            "fonts/Arial.ttf", 
-            "/System/Library/Fonts/Arial.ttf",
-            "C:/Windows/Fonts/arial.ttf",
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"
+            "Roboto-Regular.ttf",
+            "Arial.ttf", 
+            "Arial.ttf",
+            "arial.ttf",
+            "DejaVuSans.ttf"
         ]
         
         try:
@@ -59,22 +57,6 @@ class TelegramChatGenerator:
             self.reply_font = ImageFont.load_default()
             self.time_font = ImageFont.load_default()
     
-    def create_gradient_background(self, size):
-        """Create a gradient background"""
-        img = Image.new('RGB', size, self.bg_gradient_start)
-        draw = ImageDraw.Draw(img)
-        
-        # Create vertical gradient
-        for y in range(size[1]):
-            ratio = y / size[1]
-            r = int(self.bg_gradient_start[0] * (1 - ratio) + self.bg_gradient_end[0] * ratio)
-            g = int(self.bg_gradient_start[1] * (1 - ratio) + self.bg_gradient_end[1] * ratio)
-            b = int(self.bg_gradient_start[2] * (1 - ratio) + self.bg_gradient_end[2] * ratio)
-            
-            draw.line([(0, y), (size[0], y)], fill=(r, g, b))
-        
-        return img
-    
     def wrap_text(self, text, font, max_width):
         """Smart text wrapping based on pixel width"""
         words = text.split()
@@ -101,8 +83,8 @@ class TelegramChatGenerator:
         
         return '\n'.join(lines)
     
-    def draw_advanced_bubble(self, draw, coords, radius, fill, shadow_offset=3):
-        """Draw bubble with shadow and gradient effect"""
+    def draw_telegram_bubble(self, draw, coords, radius, fill, shadow_offset=6):
+        """Draw Telegram-style bubble with enhanced shadow"""
         x1, y1, x2, y2 = coords
         
         # Ensure coordinates are valid
@@ -114,20 +96,29 @@ class TelegramChatGenerator:
         if max_radius < 1:
             max_radius = 1
         
-        # Draw shadow first (with bounds check)
-        if shadow_offset > 0:
-            shadow_coords = (x1 + shadow_offset, y1 + shadow_offset, 
-                            x2 + shadow_offset, y2 + shadow_offset)
-            self.draw_rounded_rectangle(draw, shadow_coords, max_radius, (0, 0, 0, 30))
+        # Draw multiple shadow layers for depth
+        for i in range(shadow_offset, 0, -1):
+            shadow_alpha = max(10, 40 - i * 5)  # Varying opacity
+            shadow_coords = (x1 + i, y1 + i, x2 + i, y2 + i)
+            shadow_color = (0, 0, 0, shadow_alpha)
+            
+            # Create shadow layer
+            shadow_layer = Image.new('RGBA', draw.im.size, (0, 0, 0, 0))
+            shadow_draw = ImageDraw.Draw(shadow_layer)
+            self.draw_rounded_rectangle(shadow_draw, shadow_coords, max_radius, shadow_color)
+            
+            # Blur the shadow
+            shadow_layer = shadow_layer.filter(ImageFilter.GaussianBlur(radius=1))
+            draw.im.paste(shadow_layer, (0, 0), shadow_layer)
         
         # Draw main bubble
         self.draw_rounded_rectangle(draw, coords, max_radius, fill)
         
-        # Add subtle highlight (only if bubble is tall enough)
-        if y2 - y1 > 4:
-            highlight_coords = (x1, y1, x2, y1 + 2)
-            lighter_fill = tuple(min(255, c + 20) for c in fill)
-            self.draw_rounded_rectangle(draw, highlight_coords, max_radius, lighter_fill)
+        # Add subtle inner highlight
+        if y2 - y1 > 6:
+            highlight_coords = (x1 + 1, y1 + 1, x2 - 1, y1 + 3)
+            lighter_fill = tuple(min(255, c + 15) for c in fill)
+            self.draw_rounded_rectangle(draw, highlight_coords, max_radius - 1, lighter_fill)
     
     def draw_rounded_rectangle(self, draw, coords, radius, fill):
         """Draw a perfect rounded rectangle with bounds checking"""
@@ -197,73 +188,52 @@ class TelegramChatGenerator:
                 draw.ellipse([x, y, x + 2, y + 2], fill=color)
     
     def generate_chat_bubble(self, message, username, reply_to=None, replied_username=None):
-        # Create square canvas
-        img = self.create_gradient_background((self.image_size, self.image_size))
-        
-        # Add subtle pattern
-        self.add_subtle_pattern(img)
-        
-        draw = ImageDraw.Draw(img)
-        
-        # Calculate bubble dimensions with proper spacing
-        padding = 50
-        max_bubble_width = self.image_size - (padding * 2) - 60
-        
-        # Ensure minimum dimensions
-        if max_bubble_width < 200:
-            max_bubble_width = 200
+        # Calculate bubble dimensions first to determine canvas size
+        padding = 40
+        bubble_padding = 25
         
-        # Wrap text intelligently
-        wrapped_message = self.wrap_text(message, self.font, max_bubble_width - 60)
+        # Estimate text dimensions
+        wrapped_message = self.wrap_text(message, self.font, 500)  # Max width estimate
         msg_width, msg_height = self.get_text_dimensions(wrapped_message, self.font)
-        
         username_width, username_height = self.get_text_dimensions(username, self.username_font)
         
-        # Handle reply if present
+        # Handle reply dimensions
         reply_height = 0
         wrapped_reply = ""
         if reply_to and replied_username:
-            # Truncate and wrap reply
             truncated_reply = reply_to[:100] + "..." if len(reply_to) > 100 else reply_to
-            wrapped_reply = self.wrap_text(truncated_reply, self.reply_font, max_bubble_width - 80)
+            wrapped_reply = self.wrap_text(truncated_reply, self.reply_font, 450)
             reply_username_w, reply_username_h = self.get_text_dimensions(replied_username, self.reply_font)
             reply_msg_w, reply_msg_h = self.get_text_dimensions(wrapped_reply, self.reply_font)
             reply_height = reply_username_h + reply_msg_h + 25
         
-        # Calculate total bubble dimensions with minimums
-        bubble_padding = 25
-        min_bubble_width = 300
-        bubble_width = max(min_bubble_width, min(max_bubble_width, msg_width + bubble_padding * 2))
-        bubble_height = max(80, username_height + msg_height + bubble_padding * 2 + 50)
+        # Calculate bubble dimensions
+        bubble_width = max(300, min(600, msg_width + bubble_padding * 2 + 50))
+        bubble_height = max(100, username_height + msg_height + bubble_padding * 2 + 50)
         
         if reply_to:
             bubble_height += reply_height + 15
         
-        # Ensure bubble fits in canvas
-        if bubble_width > self.image_size - padding:
-            bubble_width = self.image_size - padding
-        if bubble_height > self.image_size - padding:
-            bubble_height = self.image_size - padding
-        
-        # Center the bubble vertically in the square
-        bubble_x = max(padding, self.image_size - bubble_width - padding)
-        bubble_y = max(padding, (self.image_size - bubble_height) // 2)
-        
-        # Ensure bubble coordinates are valid
-        if bubble_x + bubble_width > self.image_size:
-            bubble_x = self.image_size - bubble_width - 10
-        if bubble_y + bubble_height > self.image_size:
-            bubble_y = self.image_size - bubble_height - 10
-        
-        # Draw main bubble with shadow
-        if bubble_width > 0 and bubble_height > 0:
-            self.draw_advanced_bubble(
-                draw,
-                [bubble_x, bubble_y, bubble_x + bubble_width, bubble_y + bubble_height],
-                radius=20,
-                fill=self.bubble_color,
-                shadow_offset=4
-            )
+        # Create canvas with transparent background, sized to fit bubble + padding
+        canvas_width = bubble_width + padding * 2
+        canvas_height = bubble_height + padding * 2
+        
+        # Create image with transparent background
+        img = Image.new('RGBA', (canvas_width, canvas_height), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(img)
+        
+        # Position bubble in center of canvas
+        bubble_x = padding
+        bubble_y = padding
+        
+        # Draw main bubble with enhanced shadow
+        self.draw_telegram_bubble(
+            draw,
+            [bubble_x, bubble_y, bubble_x + bubble_width, bubble_y + bubble_height],
+            radius=18,
+            fill=self.bubble_color,
+            shadow_offset=6
+        )
         
         # Current position for content
         content_y = bubble_y + bubble_padding
@@ -273,7 +243,7 @@ class TelegramChatGenerator:
             reply_y = content_y
             reply_bubble_height = max(30, reply_height + 10)
             
-            # Reply background (with bounds checking)
+            # Reply background
             reply_bubble_x1 = bubble_x + 15
             reply_bubble_x2 = bubble_x + bubble_width - 15
             reply_bubble_y1 = reply_y
@@ -287,27 +257,27 @@ class TelegramChatGenerator:
                     fill=self.reply_bubble_color
                 )
                 
-                # Blue accent line
+                # Blue accent line (thicker and more prominent)
                 if reply_bubble_height > 10:
-                    draw.rectangle([bubble_x + 20, reply_y + 5, bubble_x + 24, reply_y + reply_bubble_height - 5], 
+                    draw.rectangle([bubble_x + 18, reply_y + 8, bubble_x + 22, reply_y + reply_bubble_height - 8], 
                                  fill=self.reply_line_color)
                 
                 # Reply content
-                reply_content_x = bubble_x + 35
-                reply_content_y = reply_y + 8
+                reply_content_x = bubble_x + 30
+                reply_content_y = reply_y + 12
                 
                 # Reply username
                 if reply_content_x < bubble_x + bubble_width - 20:
                     draw.text((reply_content_x, reply_content_y), replied_username, 
                              fill=self.reply_line_color, font=self.reply_font)
-                    reply_content_y += 20
+                    reply_content_y += 22
                     
                     # Reply message
                     for line in wrapped_reply.split('\n'):
                         if reply_content_y < bubble_y + bubble_height - 30:
                             draw.text((reply_content_x, reply_content_y), line, 
                                      fill=self.reply_text_color, font=self.reply_font)
-                            reply_content_y += 20
+                            reply_content_y += 18
             
             content_y += reply_bubble_height + 15
         
@@ -315,30 +285,30 @@ class TelegramChatGenerator:
         if content_y < bubble_y + bubble_height - 50:
             draw.text((bubble_x + bubble_padding, content_y), username, 
                      fill=self.username_color, font=self.username_font)
-            content_y += username_height + 10
+            content_y += username_height + 12
         
         # Main message text with better spacing
         for line in wrapped_message.split('\n'):
             if content_y < bubble_y + bubble_height - 40:
                 draw.text((bubble_x + bubble_padding, content_y), line, 
                          fill=self.text_color, font=self.font)
-                content_y += 28
+                content_y += 30
         
-        # Add timestamp
+        # Add timestamp in bottom right
         current_time = datetime.now().strftime("%H:%M")
         time_bbox = self.time_font.getbbox(current_time)
         time_width = time_bbox[2] - time_bbox[0]
         
-        timestamp_x = bubble_x + bubble_width - time_width - bubble_padding
-        timestamp_y = bubble_y + bubble_height - 25
+        timestamp_x = bubble_x + bubble_width - time_width - bubble_padding - 30
+        timestamp_y = bubble_y + bubble_height - 28
         
         if timestamp_x > bubble_x and timestamp_y > bubble_y:
             draw.text((timestamp_x, timestamp_y), 
                      current_time, fill=self.time_color, font=self.time_font)
         
-        # Add checkmark (delivered status)
+        # Add double checkmarks
         check_x = bubble_x + bubble_width - 25
-        check_y = bubble_y + bubble_height - 22
+        check_y = bubble_y + bubble_height - 25
         
         if check_x > bubble_x and check_y > bubble_y:
             self.draw_checkmarks(draw, check_x, check_y)