Create app.py

app.py

@@ -0,0 +1,653 @@
+import os
+import random
+import uuid
+import time
+import json
+import base64
+import asyncio 
+import logging
+import atexit
+import numpy as np
+import requests
+from flask import Flask, render_template, request, redirect
+from threading import Thread
+from pymongo import MongoClient
+from google.oauth2.credentials import Credentials
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaFileUpload
+from moviepy.editor import VideoFileClip, ColorClip, CompositeVideoClip, ImageClip
+from moviepy.video.fx import resize
+from moviepy.editor import VideoFileClip, CompositeVideoClip, ColorClip, ImageClip, TextClip
+from PIL import Image, ImageDraw, ImageFont
+from datetime import datetime, timedelta, timezone
+from moviepy.editor import *
+import builtins
+import logging
+import re
+
+import builtins
+import re
+import subprocess
+
+
+#====== LOGGING SETUP ======
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("app.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# ====== FLASK APP ======
+app = Flask(__name__)
+
+# ====== MONGO DB ======
+client = MongoClient(os.getenv("MONGO_URI", "mongodb+srv://kanhagarg930123:[email protected]/?retryWrites=true&w=majority&appName=kanha"))
+db1 = client.shortttt
+meta = db1.meta
+db2 = client["instagram_bot"]
+reel_progress = db2["reel_progresss"]
+# ====== CONSTANTS ======
+CAPTIONS = [
+    "Wait for it 😜", "Watch till end 😂", "Try not to laugh 🤣",
+    "Don't skip this 🔥", "You won't expect this! 😀", "Keep watching 😆",
+    "Stay till end! 💥", "Funniest one yet"
+]
+
+BLOCKLIST = [
+    "nsfw","18+", "xxx", "sexy", "adult", "porn", "onlyfans", "escort",
+    "betting", "gambling", "iplwin", "1xbet", "winzo", "my11circle", "dream11",
+    "rummy", "teenpatti", "fantasy", "casino", "promotion"
+]
+
+UPLOAD_TIMES = []
+NEXT_RESET = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
+
+# ====== FUNCTIONS ======
+def get_next_part():
+    last = meta.find_one(sort=[("part", -1)])
+    return 1 if not last else last["part"] + 1
+
+def generate_description(title):
+    return f"Watch this hilarious clip: {title}"
+
+# MongoDB integration assumed via reel_progress collection
+def get_next_fetch_index(username):
+    entry = reel_progress.find_one({"username": username})
+    return entry["last_index"] if entry and "last_index" in entry else 0
+
+def update_fetch_index(username, new_index):
+    reel_progress.update_one(
+        {"username": username},
+        {"$set": {"last_index": new_index}},
+        upsert=True
+    )
+
+def is_reel_fetched_or_skipped(username, reel_id):
+    entry = reel_progress.find_one({"username": username})
+    if not entry:
+        return False
+    return reel_id in entry.get("fetched_ids", []) or reel_id in entry.get("skipped_ids", [])
+
+def mark_reel_fetched(username, reel_id):
+    reel_progress.update_one(
+        {"username": username},
+        {"$addToSet": {"fetched_ids": reel_id}},
+        upsert=True
+    )
+
+def mark_reel_skipped(username, reel_id):
+    reel_progress.update_one(
+        {"username": username},
+        {"$addToSet": {"skipped_ids": reel_id}},
+        upsert=True
+    )
+
+import os
+import base64
+import tempfile
+from telethon.sync import TelegramClient
+
+import os
+from telethon.sync import TelegramClient
+from telethon.sessions import StringSession
+
+TG_API_ID = int(os.getenv("API_ID", 3704772))
+TG_API_HASH = os.getenv("API_HASH", "b8e50a035abb851c0dd424e14cac4c06")
+SESSION_B64 = os.getenv("SESSION", "1BVtsOIEBu5jNa-E88vbC710wzyAKnteiQK7WQNvDK6wCeD3Q_c33uSaqvlvCUMglbhuVtugstOwIuE7WV2EuLGUEHH3AFJ84MZ93WVs010bx4N9nQOaQJNjIZDe4Nllq9r5PKRXxjgwuSqN-B7_TfpjQJT_ztOqQNZTQV3o9EqPBXfpiMzVF5U638wuRDVkInjbgAkI9ao36KDmcvBJzAW91l27loIsUL-Zst9H6XbAbVgqfs1fTOI6xQqPEyrFA-gB7lHbKrkqILwAmK88tTRQFHOvvXkGkJpDrXb1MZQssaVilGfXQ7sXWPltMpHklRy8HaPdfOUJ8t105DHXf-CN6SvzombM=")
+
+if not SESSION_B64:
+    raise ValueError("SESSION is not set")
+
+client = TelegramClient(StringSession(SESSION_B64), TG_API_ID, TG_API_HASH)
+
+import json
+import time
+import random
+import pathlib
+import requests
+from typing import Optional, Tuple
+from telethon.sync import TelegramClient
+from telethon.tl.functions.messages import GetHistoryRequest
+
+# Assumes MongoDB functions are available:
+# get_next_fetch_index, update_fetch_index, is_reel_fetched_or_skipped,
+# mark_reel_fetched, mark_reel_skipped
+
+RAW_USERNAMES = os.getenv("RAW_USERNAMES", "nickyteja06,videshi__indian,_notyourtype_yt_,sisterfunnyreel").split(",")
+REACTED_USERNAMES = os.getenv("REACTED_USERNAMES", "biggestreact").split(",")
+
+
+import os
+import json
+import time
+import random
+import pathlib
+import requests
+from typing import Optional, Tuple
+from telethon.tl.functions.messages import GetHistoryRequest
+
+# Constants
+IG_HEADERS = {
+    "User-Agent": "Mozilla/5.0",
+    # Optional: Uncomment if using sessionid
+    # "Cookie": f"sessionid={os.getenv('IG_SESSION_ID')}"
+}
+
+def get_user_id(username: str) -> Optional[str]:
+    try:
+        res = requests.get(
+            f"https://www.instagram.com/api/v1/users/web_profile_info/?username={username}",
+            headers=IG_HEADERS,
+            timeout=10
+        )
+        if res.status_code == 200:
+            user_id = res.json()["data"]["user"]["id"]
+            logger.info(f"[🆔] Got user ID for @{username}: {user_id}")
+            return user_id
+        logger.warning(f"[⚠️] Failed to get user ID for @{username}, status {res.status_code}")
+    except Exception as e:
+        logger.warning(f"[❌] get_user_id({username}) error: {e}")
+    return None
+
+def get_links(user_id: str, limit: int = 5) -> list[Tuple[str, str]]:
+    links = []
+    query_hash = "58b6785bea111c67129decbe6a448951"
+    end_cursor = ""
+
+    while len(links) < limit:
+        variables = {
+            "id": user_id,
+            "first": 12,
+            "after": end_cursor
+        }
+        params = {
+            "query_hash": query_hash,
+            "variables": json.dumps(variables)
+        }
+
+        try:
+            res = requests.get("https://www.instagram.com/graphql/query/", params=params, headers=IG_HEADERS, timeout=10)
+            if res.status_code != 200:
+                logger.warning(f"[⚠️] Failed to get links for user {user_id}, status {res.status_code}")
+                break
+
+            media = res.json()["data"]["user"]["edge_owner_to_timeline_media"]
+            for edge in media["edges"]:
+                reel_id = edge["node"]["id"]
+                shortcode = edge["node"]["shortcode"]
+                link = f"https://www.instagram.com/p/{shortcode}/"
+                links.append((reel_id, link))
+                if len(links) >= limit:
+                    break
+
+            if not media["page_info"]["has_next_page"]:
+                break
+            end_cursor = media["page_info"]["end_cursor"]
+        except Exception as e:
+            logger.warning(f"[❌] get_links() error: {e}")
+            break
+    logger.info(f"[🔗] Found {len(links)} links for user ID {user_id}")
+    return links
+
+def send_to_bot_and_get_video(link: str) -> Optional[str]:
+    try:
+        entity = client.loop.run_until_complete(client.get_entity("instasavegrambot"))
+        client.loop.run_until_complete(client.send_message(entity, link))
+
+        for _ in range(15):  # Wait up to 30s
+            time.sleep(2)
+            history = client.loop.run_until_complete(
+                client(GetHistoryRequest(
+                    peer=entity,
+                    limit=2,
+                    offset_id=0,
+                    offset_date=None,
+                    add_offset=0,
+                    max_id=0,
+                    min_id=0,
+                    hash=0
+                ))
+            )
+            for msg in history.messages:
+                logger.info(f"[📨] Bot message: {msg.message or '[media]'}")
+                if msg.video and 20 <= msg.video.duration <= 180:
+                    path = f"reels/{msg.id}.mp4"
+                    pathlib.Path("reels").mkdir(exist_ok=True)
+                    client.loop.run_until_complete(msg.download_media(file=path))
+                    logger.info(f"[✅] Downloaded reel to {path}")
+                    return path
+    except Exception as e:
+        logger.warning(f"[❌] send_to_bot_and_get_video error: {e}")
+    return None
+
+def fetch_valid_reel() -> Tuple[Optional[str], Optional[str]]:
+    with client:
+        pools = [(RAW_USERNAMES, "raw"), (REACTED_USERNAMES, "reacted")]
+        pools = [(p, t) for p, t in pools if p]
+        if not pools:
+            logger.warning("[⚠️] No usernames in either RAW or REACTED pools.")
+            return None, None
+
+        random.shuffle(pools)
+
+        for usernames, reel_type in pools:
+            random.shuffle(usernames)
+            for username in usernames:
+                logger.info(f"[🔎] Trying @{username} ({reel_type})")
+                uid = get_user_id(username)
+                if not uid:
+                    logger.warning(f"[🚫] Skipping @{username}, failed to get user ID.")
+                    continue
+
+                fetch_idx = get_next_fetch_index(username)
+                links = get_links(uid, limit=5)
+
+                for idx, (reel_id, link) in enumerate(links[fetch_idx:], start=fetch_idx):
+                    if is_reel_fetched_or_skipped(username, reel_id):
+                        logger.info(f"[⏩] Already processed: @{username}/{reel_id}")
+                        continue
+
+                    logger.info(f"[📥] Sending link to bot: {link}")
+                    video_path = send_to_bot_and_get_video(link)
+                    if not video_path:
+                        logger.warning(f"[⚠️] Failed to fetch: {link}")
+                        mark_reel_skipped(username, reel_id)
+                        continue
+
+                    mark_reel_fetched(username, reel_id)
+                    update_fetch_index(username, idx + 1)
+                    return video_path, reel_type
+
+                update_fetch_index(username, fetch_idx + len(links))
+
+    logger.warning("[🚫] No valid reels found after checking all usernames.")
+    return None, None
+                                            
+def patch_moviepy():
+    original_resizer = resize.resize
+
+    def patched_resizer(clip, *args, **kwargs):
+        newsize = kwargs.get("newsize", None)
+        if newsize:
+            newsize = tuple(map(int, newsize))
+            clip = clip.fl_image(lambda img: img.resize(newsize, Image.Resampling.LANCZOS))
+        else:
+            clip = original_resizer(clip, *args, **kwargs)
+        return clip
+
+    resize.resize = patched_resizer
+
+patch_moviepy()
+
+import emoji
+from PIL import Image, ImageDraw, ImageFont
+import emoji
+import os
+import requests
+
+
+def create_text_image(text, width, height):
+    img = Image.new("RGB", (width, height), color=(255, 255, 255))
+    draw = ImageDraw.Draw(img)
+
+    # Load font
+    try:
+        font = ImageFont.truetype("DejaVuSans-Bold.ttf", size=60)
+    except:
+        font = ImageFont.load_default()
+
+    # Extract emoji and clean text
+    emojis = emoji.emoji_list(text)
+    pure_text = emoji.replace_emoji(text, replace='')
+
+    # Adjust font size to fit
+    max_font_size = 70
+    while True:
+        font = ImageFont.truetype("DejaVuSans-Bold.ttf", size=max_font_size)
+        text_width, text_height = draw.textsize(pure_text, font=font)
+        total_width = text_width + (len(emojis) * 60) + 20
+        if total_width <= width - 40 or max_font_size <= 30:
+            break
+        max_font_size -= 2
+
+    # Starting X & Y for centered layout
+    start_x = (width - total_width) // 2
+    y = (height - text_height) // 2
+
+    # Draw text first
+    draw.text((start_x, y), pure_text, font=font, fill=(0, 0, 0))
+
+    # Then draw emojis to the right of the text
+    x = start_x + text_width + 10
+    for e in emojis:
+        hexcode = '-'.join(f"{ord(c):x}" for c in e['emoji'])
+        emoji_path = f"emoji_pngs/{hexcode}.png"
+        if not os.path.exists(emoji_path):
+            download_emoji_png(e['emoji'])
+
+        if os.path.exists(emoji_path):
+            emoji_img = Image.open(emoji_path).convert("RGBA")
+            emoji_img = emoji_img.resize((60, 60))
+            img.paste(emoji_img, (x, y), emoji_img)
+            x += 60 + 4
+
+    return img
+
+from PIL import Image, ImageDraw, ImageFont
+import numpy as np
+from moviepy.editor import ImageClip
+
+def generate_watermark_img(text, width, height=50):
+    img = Image.new("RGBA", (width, height), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+
+    try:
+        font = ImageFont.truetype("DejaVuSans-Bold.ttf", size=35)
+    except:
+        font = ImageFont.load_default()
+
+    text_width, text_height = draw.textsize(text, font=font)
+    draw.text((5, height - text_height - 2), text, fill="white", font=font, stroke_width=1, stroke_fill="black")
+
+    return img
+    
+def download_emoji_png(emoji_char):
+    hexcode = '-'.join(f"{ord(c):x}" for c in emoji_char)
+    url = f"https://github.com/twitter/twemoji/raw/master/assets/72x72/{hexcode}.png"
+    os.makedirs("emoji_pngs", exist_ok=True)
+    path = f"emoji_pngs/{hexcode}.png"
+    try:
+        r = requests.get(url)
+        if r.status_code == 200:
+            with open(path, "wb") as f:
+                f.write(r.content)
+            print(f"✅ Downloaded emoji: {emoji_char} → {path}")
+        else:
+            print(f"❌ Failed to download emoji: {emoji_char}")
+    except Exception as e:
+        print(f"⚠️ Error downloading emoji {emoji_char}: {e}")
+
+
+def edit_video(video_path):
+    clip = VideoFileClip(video_path)
+
+    video_width = clip.w
+    video_height = clip.h
+    bar_height = 120
+    total_height = video_height + bar_height
+
+    # === 1. Background Canvas
+    final_bg = ColorClip(size=(video_width, total_height), color=(255, 255, 255), duration=clip.duration)
+
+    # === 2. Caption Bar (Top)
+    caption = random.choice(CAPTIONS)
+    caption_img = create_text_image(caption, video_width, bar_height)
+    caption_clip = ImageClip(np.array(caption_img)).set_duration(clip.duration).set_position((0, 0))
+
+    # === 3. Eye Protection Overlay (6% White Transparent)
+    eye_protection = ColorClip(size=(video_width, video_height), color=(255, 255, 255), duration=clip.duration)
+    eye_protection = eye_protection.set_opacity(0.1).set_position((0, bar_height))
+
+    # === 4. Watermark (Bottom-left using Pillow + ImageClip)
+    watermark_img = generate_watermark_img("@fulltosscomedy4u", video_width, height=50)
+    watermark_clip = ImageClip(np.array(watermark_img)).set_duration(clip.duration).set_position(("left", bar_height + video_height - 50))
+
+    # === 5. Position original video below top bar
+    video_clip = clip.set_position((0, bar_height))
+
+    # === 6. Combine everything
+    final = CompositeVideoClip(
+        [final_bg, caption_clip, video_clip, eye_protection, watermark_clip],
+        size=(video_width, total_height)
+    )
+
+    os.makedirs("edited", exist_ok=True)
+    output_path = f"edited/{uuid.uuid4().hex}.mp4"
+    final.write_videofile(
+        output_path,
+        codec="libx264",
+        audio_codec="aac",
+        preset="slow",
+        bitrate="12000k",
+        verbose=False,
+        logger=None
+    )
+    return output_path
+
+def edit_video_raw(video_path):
+    clip = VideoFileClip(video_path)
+    video_width = clip.w
+    video_height = clip.h
+    top_bar_height = 120
+    mid_bar_height = 80
+    total_height = video_height + top_bar_height + mid_bar_height
+
+    # === 1. Background Canvas
+    final_bg = ColorClip(size=(video_width, total_height), color=(255, 255, 255), duration=clip.duration + 6)
+
+    # === 2. Top Caption (Black on White)
+    caption = random.choice(CAPTIONS)
+    caption_img = create_text_image(
+        caption,
+        width=video_width,
+        height=top_bar_height,
+        font_size=min(max(int(video_width * 0.08), 48), 80),  # Auto-resize
+        align="center",
+        bg_color=(255, 255, 255),
+        text_color=(0, 0, 0)
+    )
+    caption_clip = ImageClip(np.array(caption_img)).set_duration(clip.duration + 6).set_position((0, 0))
+
+    # === 3. Middle Caption (White on Black)
+    mid_text = random.choice([
+        "Pura 1 din laga tab ye reel mili 🤣",
+        "Ye miss mat kr dena 😜",
+        "Kha thi ye reel ab tak 🤨🤗",
+        "Wait, ye dekh kr hi janna 💥💥"
+    ])
+    mid_img = create_text_image(
+        mid_text,
+        width=video_width,
+        height=mid_bar_height,
+        font_size=min(max(int(video_width * 0.06), 40), 64),
+        align="center",
+        bg_color=(0, 0, 0),
+        text_color=(255, 255, 255)
+    )
+    mid_caption_clip = ImageClip(np.array(mid_img)).set_duration(clip.duration + 6).set_position((0, top_bar_height))
+
+    # === 4. Eye Protection Overlay
+    eye_protection = ColorClip(size=(video_width, video_height), color=(255, 255, 255), duration=clip.duration + 6)
+    eye_protection = eye_protection.set_opacity(0.1).set_position((0, top_bar_height + mid_bar_height))
+
+    # === 5. Watermark (Bottom Left)
+    watermark_img = generate_watermark_img("@fulltosscomedy4u", video_width, height=50)
+    watermark_clip = ImageClip(np.array(watermark_img)).set_duration(clip.duration + 6).set_position(("left", total_height - 50))
+
+    # === 6. Meme Section: Laugh -> Freeze -> Laugh
+    laugh_index = random.choice([1, 2])
+    laugh_clip = VideoFileClip(f"laugh/{laugh_index}.mp4").resize(width=video_width).set_duration(2)
+    freeze_frame = laugh_clip.to_ImageClip().set_duration(max(1, clip.duration - 4))
+    meme_part = concatenate_videoclips([laugh_clip, freeze_frame, laugh_clip])
+
+    # === 7. Combine All Video Parts
+    full_video = concatenate_videoclips([meme_part, clip])
+    full_video = full_video.set_position((0, top_bar_height + mid_bar_height))
+
+    # === 8. Composite Final Video
+    final = CompositeVideoClip(
+        [final_bg, caption_clip, mid_caption_clip, full_video, eye_protection, watermark_clip],
+        size=(video_width, total_height)
+    )
+
+    # === 9. Export
+    os.makedirs("edited", exist_ok=True)
+    output_path = f"edited/{uuid.uuid4().hex}.mp4"
+    final.write_videofile(
+        output_path,
+        codec="libx264",
+        audio_codec="aac",
+        preset="slow",
+        bitrate="12000k",
+        threads=4,
+        verbose=False,
+        logger=None
+    )
+    return output_path
+    
+def upload_to_youtube(video_path, title, desc):
+    creds = Credentials(
+        token=None,
+        refresh_token=os.getenv("YT_REFRESH_TOKEN"),
+        token_uri="https://oauth2.googleapis.com/token",
+        client_id=os.getenv("YT_CLIENT_ID", "387804137131-sjih05p3329n5n72gsgglv1tb9t62882.apps.googleusercontent.com"),
+        client_secret=os.getenv("YT_CLIENT_SECRET", "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"),
+        scopes=["https://www.googleapis.com/auth/youtube.upload"]
+    )
+    creds.refresh(Request())
+    youtube = build("youtube", "v3", credentials=creds)
+    request = youtube.videos().insert(
+        part="snippet,status",
+        body={
+            "snippet": {
+                "title": title,
+                "description": desc,
+                "tags": ["funny", "memes", "comedy", "shorts"],
+                "categoryId": "23"
+            },
+            "status": {
+                "privacyStatus": "public",
+                "madeForKids": False
+            }
+        },
+        media_body=MediaFileUpload(video_path)
+    )
+    res = request.execute()
+    logger.info(f"Uploaded: https://youtube.com/watch?v={res['id']}")
+    return f"https://youtube.com/watch?v={res['id']}"
+
+first_run = True
+def save_to_db(part, title, desc, link):
+    meta.insert_one({"part": part, "title": title, "description": desc, "link": link, "uploaded": time.time()})
+
+def auto_loop():
+    asyncio.set_event_loop(asyncio.new_event_loop())
+    global UPLOAD_TIMES, NEXT_RESET, first_run
+
+    ist = timezone(timedelta(hours=5, minutes=30))  # IST timezone
+
+    daily_upload_count = random.randint(3, 5)
+    uploads_done_today = 0
+    NEXT_RESET = datetime.now(ist).replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
+
+    logger.info(f"[📅] Today's upload target: {daily_upload_count} reels.")
+
+    def wait_until(hour: int, minute: int = 0):
+        now = datetime.now(ist)
+        target = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+        if target < now:
+            return
+        logger.info(f"[🕗] Waiting until {target.strftime('%H:%M')} IST...")
+        while datetime.now(ist) < target:
+            time.sleep(10)
+
+    wait_until(8)
+
+    while True:
+        try:
+            now = datetime.now(ist)
+
+            if now >= NEXT_RESET:
+                UPLOAD_TIMES.clear()
+                NEXT_RESET = now.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
+                daily_upload_count = random.randint(3, 5)
+                uploads_done_today = 0
+                logger.info(f"[🔁] Reset for new day. New target: {daily_upload_count} uploads.")
+
+            if uploads_done_today >= daily_upload_count:
+                logger.info("[✅] Daily upload target reached.")
+                time.sleep(60)
+                continue
+
+            if now.hour < 8 or now.hour >= 20:
+                time.sleep(60)
+                continue
+
+            if not UPLOAD_TIMES or (now - UPLOAD_TIMES[-1]).total_seconds() >= random.randint(7200, 14400):
+                video_path, reel_type = fetch_valid_reel()
+
+                if not video_path:
+                    logger.warning("[⚠️] No valid reel found. Retrying...")
+                    time.sleep(60)
+                    continue
+                if reel_type == "reacted":
+                    edited = edit_video(video_path)
+                else:
+                    edited = edit_video_raw(video_path)
+                part = get_next_part()
+                title = f"Try not to laugh || #{part} #funny #memes #comedy #shorts"
+                desc = generate_description(title)
+                link = upload_to_youtube(edited, title, desc)
+                save_to_db(part, title, desc, link)
+
+                logger.info(f"[📤] Uploaded #{part}: {link}")
+                UPLOAD_TIMES.append(now)
+                uploads_done_today += 1
+
+                os.remove(video)
+                os.remove(edited)
+
+                if uploads_done_today < daily_upload_count:
+                    gap_seconds = random.randint(7200, 14400)
+                    next_time = datetime.now(ist) + timedelta(seconds=gap_seconds)
+                    if next_time.hour >= 20:
+                        logger.info("[🌙] Next upload would exceed 8PM. Skipping.")
+                        continue
+                    logger.info(f"[⏳] Waiting ~{gap_seconds // 60} minutes before next upload.")
+                    time.sleep(gap_seconds)
+            else:
+                time.sleep(60)
+
+        except Exception as e:
+            logger.error(f"Loop error: {e}")
+            time.sleep(60)
+
+@app.route('/')
+def home():
+    last = meta.find_one(sort=[("uploaded", -1)])
+    video_id = last["link"].split("v=")[-1] if last and "link" in last else None
+    return render_template("index.html", time=time.ctime(), video_id=video_id)
+
+@app.route('/run-now', methods=["POST"])
+def run_now():
+    Thread(target=auto_loop, daemon=True).start()
+    return redirect("/")
+
+if __name__ == "__main__":
+    Thread(target=auto_loop, daemon=True).start()
+    app.run(host="0.0.0.0", port=7860)