Delete routers/twitter.py

routers/twitter.py

@@ -1,502 +0,0 @@
-from fastapi import APIRouter, Query, HTTPException
-from fastapi.responses import StreamingResponse
-from PIL import Image, ImageDraw, ImageFont
-from io import BytesIO
-import requests
-import re
-from html import unescape
-
-router = APIRouter()
-
-def fetch_tweet_data(tweet_id: str) -> dict:
-    url = f"https://tweethunter.io/api/thread?tweetId={tweet_id}"
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:141.0) Gecko/20100101 Firefox/141.0",
-        "Accept": "application/json",
-        "Referer": "https://tweethunter.io/tweetpik"
-    }
-    try:
-        resp = requests.get(url, headers=headers, timeout=10)
-        resp.raise_for_status()
-        data = resp.json()
-        if not data:
-            raise HTTPException(status_code=404, detail="Tweet não encontrado")
-        return data[0]
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=f"Erro ao buscar tweet: {e}")
-
-def download_emoji(emoji_url: str) -> Image.Image:
-    try:
-        response = requests.get(emoji_url, timeout=10)
-        response.raise_for_status()
-        emoji_img = Image.open(BytesIO(response.content)).convert("RGBA")
-        return emoji_img.resize((32, 32), Image.Resampling.LANCZOS)
-    except Exception as e:
-        print(f"Erro ao baixar emoji {emoji_url}: {e}")
-        return None
-
-def clean_tweet_text(text: str) -> str:
-    if not text:
-        return ""
-    
-    text = re.sub(r'<a[^>]*>pic\.x\.com/[^<]*</a>', '', text)
-    
-    text = re.sub(r'<img[^>]*alt="([^"]*)"[^>]*/?>', r'\1', text)
-    
-    text = re.sub(r'<[^>]+>', '', text)
-    
-    text = unescape(text)
-    
-    text = text.replace('\\n', '\n')
-    
-    text = re.sub(r'\n\s*\n', '\n\n', text)
-    text = text.strip()
-    
-    return text
-
-def extract_emojis_from_html(text: str) -> list:
-    emoji_pattern = r'<img[^>]*class="emoji"[^>]*alt="([^"]*)"[^>]*src="([^"]*)"[^>]*/?>'
-    emojis = []
-    
-    for match in re.finditer(emoji_pattern, text):
-        emoji_char = match.group(1)
-        emoji_url = match.group(2)
-        start_pos = match.start()
-        end_pos = match.end()
-        emojis.append({
-            'char': emoji_char,
-            'url': emoji_url,
-            'start': start_pos,
-            'end': end_pos
-        })
-    
-    return emojis
-
-def wrap_text_with_emojis(text: str, font: ImageFont.FreeTypeFont, max_width: int, draw: ImageDraw.Draw) -> list:
-    emojis = extract_emojis_from_html(text)
-    clean_text = clean_tweet_text(text)
-    
-    paragraphs = clean_text.split('\n')
-    all_lines = []
-    emoji_positions = []
-    current_char_index = 0
-    
-    for paragraph in paragraphs:
-        if not paragraph.strip():
-            all_lines.append({
-                'text': "",
-                'emojis': []
-            })
-            current_char_index += 1
-            continue
-            
-        words = paragraph.split()
-        current_line = ""
-        line_emojis = []
-        
-        for word in words:
-            test_line = f"{current_line} {word}".strip()
-            
-            emoji_count_in_word = 0
-            for emoji in emojis:
-                if emoji['char'] in word:
-                    emoji_count_in_word += len(emoji['char'])
-            
-            text_width = draw.textlength(test_line, font=font)
-            emoji_width = emoji_count_in_word * 32
-            total_width = text_width + emoji_width
-            
-            if total_width <= max_width:
-                current_line = test_line
-                for emoji in emojis:
-                    if emoji['char'] in word:
-                        emoji_pos_in_line = len(current_line) - len(word) + word.find(emoji['char'])
-                        line_emojis.append({
-                            'emoji': emoji,
-                            'position': emoji_pos_in_line
-                        })
-            else:
-                if current_line:
-                    all_lines.append({
-                        'text': current_line,
-                        'emojis': line_emojis.copy()
-                    })
-                current_line = word
-                line_emojis = []
-                for emoji in emojis:
-                    if emoji['char'] in word:
-                        emoji_pos_in_line = word.find(emoji['char'])
-                        line_emojis.append({
-                            'emoji': emoji,
-                            'position': emoji_pos_in_line
-                        })
-        
-        if current_line:
-            all_lines.append({
-                'text': current_line,
-                'emojis': line_emojis.copy()
-            })
-        
-        current_char_index += len(paragraph) + 1
-    
-    return all_lines
-
-def wrap_text_with_newlines(text: str, font: ImageFont.FreeTypeFont, max_width: int, draw: ImageDraw.Draw) -> list[str]:
-    paragraphs = text.split('\n')
-    all_lines = []
-    
-    for paragraph in paragraphs:
-        if not paragraph.strip():
-            all_lines.append("")
-            continue
-            
-        words = paragraph.split()
-        current_line = ""
-        
-        for word in words:
-            test_line = f"{current_line} {word}".strip()
-            if draw.textlength(test_line, font=font) <= max_width:
-                current_line = test_line
-            else:
-                if current_line:
-                    all_lines.append(current_line)
-                current_line = word
-        
-        if current_line:
-            all_lines.append(current_line)
-    
-    return all_lines
-
-def download_and_resize_image(url: str, max_width: int, max_height: int) -> Image.Image:
-    try:
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        
-        img = Image.open(BytesIO(response.content)).convert("RGB")
-        
-        original_width, original_height = img.size
-        ratio = min(max_width / original_width, max_height / original_height)
-        
-        new_width = int(original_width * ratio)
-        new_height = int(original_height * ratio)
-        
-        return img.resize((new_width, new_height), Image.Resampling.LANCZOS)
-    except Exception as e:
-        print(f"Erro ao baixar imagem {url}: {e}")
-        return None
-
-def create_verification_badge(draw: ImageDraw.Draw, x: int, y: int, size: int = 24):
-    blue_color = (27, 149, 224)
-    
-    draw.ellipse((x, y, x + size, y + size), fill=blue_color)
-    
-    check_points = [
-        (x + size * 0.25, y + size * 0.5),
-        (x + size * 0.45, y + size * 0.7),
-        (x + size * 0.75, y + size * 0.3)
-    ]
-    
-    line_width = max(2, size // 12)
-    for i in range(len(check_points) - 1):
-        draw.line([check_points[i], check_points[i + 1]], fill=(255, 255, 255), width=line_width)
-
-def format_number(num: int) -> str:
-    if num >= 1000000:
-        return f"{num / 1000000:.1f}M"
-    elif num >= 1000:
-        return f"{num / 1000:.1f}K"
-    else:
-        return str(num)
-
-def draw_rounded_rectangle(draw: ImageDraw.Draw, bbox: tuple, radius: int, fill: tuple):
-    x1, y1, x2, y2 = bbox
-    
-    draw.rectangle((x1 + radius, y1, x2 - radius, y2), fill=fill)
-    draw.rectangle((x1, y1 + radius, x2, y2 - radius), fill=fill)
-    
-    draw.pieslice((x1, y1, x1 + 2*radius, y1 + 2*radius), 180, 270, fill=fill)
-    draw.pieslice((x2 - 2*radius, y1, x2, y1 + 2*radius), 270, 360, fill=fill)
-    draw.pieslice((x1, y2 - 2*radius, x1 + 2*radius, y2), 90, 180, fill=fill)
-    draw.pieslice((x2 - 2*radius, y2 - 2*radius, x2, y2), 0, 90, fill=fill)
-
-def draw_rounded_image(img: Image.Image, photo_img: Image.Image, x: int, y: int, radius: int = 16):
-    mask = Image.new("L", photo_img.size, 0)
-    mask_draw = ImageDraw.Draw(mask)
-    mask_draw.rounded_rectangle((0, 0, photo_img.width, photo_img.height), radius, fill=255)
-    
-    rounded_img = Image.new("RGBA", photo_img.size, (0, 0, 0, 0))
-    rounded_img.paste(photo_img, (0, 0))
-    rounded_img.putalpha(mask)
-    
-    img.paste(rounded_img, (x, y), rounded_img)
-
-def create_tweet_image(tweet: dict) -> BytesIO:
-    WIDTH, HEIGHT = 1080, 1350
-    
-    OUTER_BG_COLOR = (0, 0, 0)
-    INNER_BG_COLOR = (255, 255, 255)
-    TEXT_COLOR = (2, 6, 23)
-    SECONDARY_COLOR = (100, 116, 139)
-    STATS_COLOR = (110, 118, 125)
-    
-    OUTER_PADDING = 64
-    INNER_PADDING = 48
-    BORDER_RADIUS = 32
-    AVATAR_SIZE = 96
-    
-    raw_text = tweet.get("textHtml", "")
-    cleaned_text = clean_tweet_text(raw_text)
-    photos = tweet.get("photos", [])
-    videos = tweet.get("videos", [])
-    
-    media_url = None
-    if videos and videos[0].get("poster"):
-        media_url = videos[0]["poster"]
-    elif photos:
-        media_url = photos[0]
-    
-    has_media = media_url is not None
-    
-    base_font_size = 40
-    max_iterations = 10
-    current_iteration = 0
-    
-    while current_iteration < max_iterations:
-        try:
-            font_name = ImageFont.truetype("fonts/Chirp Bold.woff", int(base_font_size * 0.9))
-            font_handle = ImageFont.truetype("fonts/Chirp Regular.woff", int(base_font_size * 0.9))
-            font_text = ImageFont.truetype("fonts/Chirp Regular.woff", base_font_size)
-            font_stats_number = ImageFont.truetype("fonts/Chirp Bold.woff", int(base_font_size * 0.9))
-            font_stats_label = ImageFont.truetype("fonts/Chirp Regular.woff", int(base_font_size * 0.9))
-        except:
-            font_name = ImageFont.load_default()
-            font_handle = ImageFont.load_default()
-            font_text = ImageFont.load_default()
-            font_stats_number = ImageFont.load_default()
-            font_stats_label = ImageFont.load_default()
-        
-        text_max_width = WIDTH - (2 * OUTER_PADDING) - (2 * INNER_PADDING)
-        
-        temp_img = Image.new("RGB", (100, 100))
-        temp_draw = ImageDraw.Draw(temp_img)
-        
-        has_emojis = '<img' in raw_text and 'emoji' in raw_text
-        
-        if has_emojis:
-            lines = wrap_text_with_emojis(raw_text, font_text, text_max_width - 100, temp_draw)
-        else:
-            text_lines = wrap_text_with_newlines(cleaned_text, font_text, text_max_width, temp_draw)
-            lines = [{'text': line, 'emojis': []} for line in text_lines]
-        
-        line_height = int(font_text.size * 1.2)
-        text_height = len(lines) * line_height
-        
-        media_height = 0
-        media_margin = 0
-        if has_media:
-            if len(cleaned_text) > 200:
-                media_height = 250
-            elif len(cleaned_text) > 100:
-                media_height = 350
-            else:
-                media_height = 450
-            media_margin = 24
-        
-        header_height = AVATAR_SIZE + 16
-        text_margin = 20
-        stats_height = 40
-        stats_margin = 32
-        
-        total_content_height = (
-            INNER_PADDING +
-            header_height +
-            text_margin +
-            text_height +
-            (media_margin if has_media else 0) +
-            media_height +
-            (media_margin if has_media else 0) +
-            stats_margin +
-            stats_height +
-            INNER_PADDING
-        )
-        
-        max_card_height = HEIGHT - (2 * OUTER_PADDING)
-        
-        if total_content_height <= max_card_height or base_font_size <= 24:
-            break
-        
-        base_font_size -= 2
-        current_iteration += 1
-    
-    card_height = min(total_content_height, HEIGHT - (2 * OUTER_PADDING))
-    card_width = WIDTH - (2 * OUTER_PADDING)
-    
-    card_x = OUTER_PADDING
-    card_y = (HEIGHT - card_height) // 2 - 30
-    
-    img = Image.new("RGB", (WIDTH, HEIGHT), OUTER_BG_COLOR)
-    draw = ImageDraw.Draw(img)
-    
-    draw_rounded_rectangle(
-        draw, 
-        (card_x, card_y, card_x + card_width, card_y + card_height),
-        BORDER_RADIUS,
-        INNER_BG_COLOR
-    )
-    
-    content_x = card_x + INNER_PADDING
-    current_y = card_y + INNER_PADDING
-    
-    avatar_y = current_y
-    try:
-        avatar_resp = requests.get(tweet["avatarUrl"], timeout=10)
-        avatar_img = Image.open(BytesIO(avatar_resp.content)).convert("RGBA")
-        avatar_img = avatar_img.resize((AVATAR_SIZE, AVATAR_SIZE), Image.Resampling.LANCZOS)
-        
-        mask = Image.new("L", (AVATAR_SIZE, AVATAR_SIZE), 0)
-        mask_draw = ImageDraw.Draw(mask)
-        mask_draw.ellipse((0, 0, AVATAR_SIZE, AVATAR_SIZE), fill=255)
-        
-        img.paste(avatar_img, (content_x, avatar_y), mask)
-    except:
-        draw.ellipse(
-            (content_x, avatar_y, content_x + AVATAR_SIZE, avatar_y + AVATAR_SIZE),
-            fill=(200, 200, 200)
-        )
-    
-    user_info_x = content_x + AVATAR_SIZE + 20
-    user_info_y = avatar_y
-    
-    name = tweet.get("nameHtml", "Nome Desconhecido")
-    name = clean_tweet_text(name)
-    draw.text((user_info_x, user_info_y), name, font=font_name, fill=TEXT_COLOR)
-    
-    verified = tweet.get("verified", False)
-    if verified:
-        name_width = draw.textlength(name, font=font_name)
-        badge_x = user_info_x + name_width + 14
-        badge_y = user_info_y + 6
-        create_verification_badge(draw, badge_x, badge_y, 28)
-    
-    handle = tweet.get("handler", "@unknown")
-    if not handle.startswith('@'):
-        handle = f"@{handle}"
-    
-    handle_y = user_info_y + 44
-    draw.text((user_info_x, handle_y), handle, font=font_handle, fill=SECONDARY_COLOR)
-    
-    current_y = avatar_y + header_height + text_margin
-    
-    for line_data in lines:
-        line_text = line_data['text']
-        line_emojis = line_data.get('emojis', [])
-        
-        if line_text.strip() or line_emojis:
-            text_x = content_x
-            
-            if has_emojis and line_emojis:
-                current_x = text_x
-                text_parts = []
-                last_pos = 0
-                
-                sorted_emojis = sorted(line_emojis, key=lambda e: e['position'])
-                
-                for emoji_data in sorted_emojis:
-                    emoji_pos = emoji_data['position']
-                    emoji_info = emoji_data['emoji']
-                    
-                    if emoji_pos > last_pos:
-                        text_before = line_text[last_pos:emoji_pos]
-                        if text_before:
-                            draw.text((current_x, current_y), text_before, font=font_text, fill=TEXT_COLOR)
-                            current_x += draw.textlength(text_before, font=font_text)
-                    
-                    emoji_img = download_emoji(emoji_info['url'])
-                    if emoji_img:
-                        emoji_y = current_y + (line_height - 32) // 2
-                        img.paste(emoji_img, (int(current_x), int(emoji_y)), emoji_img)
-                        current_x += 32
-                    else:
-                        draw.text((current_x, current_y), emoji_info['char'], font=font_text, fill=TEXT_COLOR)
-                        current_x += draw.textlength(emoji_info['char'], font=font_text)
-                    
-                    last_pos = emoji_pos + len(emoji_info['char'])
-                
-                if last_pos < len(line_text):
-                    remaining_text = line_text[last_pos:]
-                    draw.text((current_x, current_y), remaining_text, font=font_text, fill=TEXT_COLOR)
-            else:
-                draw.text((text_x, current_y), line_text, font=font_text, fill=TEXT_COLOR)
-        
-        current_y += line_height
-    
-    if has_media:
-        current_y += media_margin
-        media_img = download_and_resize_image(media_url, text_max_width, media_height)
-        
-        if media_img:
-            media_x = content_x
-            media_y = current_y
-            
-            draw_rounded_image(img, media_img, media_x, media_y, 16)
-            current_y = media_y + media_img.height + media_margin
-    
-    current_y += stats_margin
-    stats_y = current_y
-    stats_x = content_x
-    
-    retweets = tweet.get("retweets", 0)
-    retweets_text = format_number(retweets)
-    draw.text((stats_x, stats_y), retweets_text, font=font_stats_number, fill=TEXT_COLOR)
-    
-    retweets_num_width = draw.textlength(retweets_text, font=font_stats_number)
-    retweets_label_x = stats_x + retweets_num_width + 12
-    draw.text((retweets_label_x, stats_y), "Retweets", font=font_stats_label, fill=STATS_COLOR)
-    
-    retweets_label_width = draw.textlength("Retweets", font=font_stats_label)
-    likes_x = retweets_label_x + retweets_label_width + 44
-    
-    likes = tweet.get("likes", 0)
-    likes_text = format_number(likes)
-    draw.text((likes_x, stats_y), likes_text, font=font_stats_number, fill=TEXT_COLOR)
-    
-    likes_num_width = draw.textlength(likes_text, font=font_stats_number)
-    likes_label_x = likes_x + likes_num_width + 12
-    draw.text((likes_label_x, stats_y), "Likes", font=font_stats_label, fill=STATS_COLOR)
-    
-    try:
-        logo_path = "recurve.png"
-        logo = Image.open(logo_path).convert("RGBA")
-        logo_width, logo_height = 121, 23
-        logo_resized = logo.resize((logo_width, logo_height))
-        
-        logo_with_opacity = Image.new("RGBA", logo_resized.size)
-        for x in range(logo_resized.width):
-            for y in range(logo_resized.height):
-                r, g, b, a = logo_resized.getpixel((x, y))
-                new_alpha = int(a * 0.42)
-                logo_with_opacity.putpixel((x, y), (r, g, b, new_alpha))
-        
-        logo_x = WIDTH - logo_width - 64
-        logo_y = HEIGHT - logo_height - 64
-        img.paste(logo_with_opacity, (logo_x, logo_y), logo_with_opacity)
-    except Exception as e:
-        print(f"Erro ao carregar a logo: {e}")
-    
-    buffer = BytesIO()
-    img.save(buffer, format="PNG", quality=95)
-    buffer.seek(0)
-    return buffer
-
-def extract_tweet_id(tweet_url: str) -> str:
-    match = re.search(r"/status/(\d+)", tweet_url)
-    if not match:
-        raise HTTPException(status_code=400, detail="URL de tweet inválida")
-    return match.group(1)
-
-@router.get("/tweet/image")
-def get_tweet_image(tweet_url: str = Query(..., description="URL do tweet")):
-    tweet_id = extract_tweet_id(tweet_url)
-    tweet_data = fetch_tweet_data(tweet_id)
-    img_buffer = create_tweet_image(tweet_data)
-    return StreamingResponse(img_buffer, media_type="image/png")