Update ccc.py

ccc.py

@@ -1,693 +1,51 @@
-import aiohttp
-import discord
-from discord.ext import commands
-import asyncio
-import json
-import re
-from collections import defaultdict, deque
-from datetime import datetime, timedelta
-import pytz
-import os
-import traceback
-
-TOKEN = os.environ['TOKEN']
-CHANNEL_ID = 1298830206387228682
-MONITORED_ITEMS_CHANNEL_ID = 1307752080139878500
-AUTHORIZED_USER_ID = 1219416244806094883
-
-PETS_API = 'https://petsapi.deno.dev/'
-EXISTS_API = 'https://existsapi.deno.dev/'
-RAP_API = 'https://rapapi.deno.dev/'
-
-last_rap_values = {
-    "Abyssal Treasure Chest": None,
-    "God Potion": None,
-    "Huge Egg": None,
-    "Winter God Potion": None
-}
-
-LIMITED_PETS = {
-    "Huge Shiba": 15000,
-    "Huge Dragon": 7500,
-    "Huge Nightmare Corgi": 15000,
-    "Huge Jelly Axolotl": 5000
-}
-
-JELLY_LEAVE_TIMES = {
-    "Huge Pilgrim Turkey": datetime.strptime('2024-12-06 12:00:00', '%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.timezone('US/Eastern')),
-    "Acorn": datetime.strptime('2024-12-06 12:00:00', '%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.timezone('US/Eastern'))
-}
-
-intents = discord.Intents.default()
-intents.message_content = True 
-bot = commands.Bot(command_prefix='!', intents=intents)
-
-pet_images = {}
-pet_difficulties = {}
-pet_raps = {}
-pet_changes = defaultdict(deque)
-recent_notifications = defaultdict(deque)
-
-async def fetch_exists_data(session):
-    try:
-        async with session.get(EXISTS_API) as response:
-            if response.status == 200:
-                data = await response.json()
-                return data.get('data', [])
-    except Exception as e:
-        print(f"Error fetching exists data: {e}")
-    return []
-
-def format_number(number):
-    if not isinstance(number, (int, float)):
-        return str(number)
-    
-    abs_number = abs(number)
-    if abs_number < 1000:
-        return str(number)
-    elif abs_number < 1000000:
-        return f"{number/1000:.1f}k"
-    elif abs_number < 1000000000:
-        return f"{number/1000000:.1f}m"
-    elif abs_number < 1000000000000:
-        return f"{number/1000000000:.1f}b"
-    else:
-        return f"{number/1000000000000:.1f}t"
-    
-async def fetch_pet_collection_data(session, pet_name):
-    try:
-        async with session.get('https://collectionpet.deno.dev') as response:
-            if response.status == 200:
-                data = await response.json()
-                for pet in data.get('data', []):
-                    if pet.get('configName', '').lower() == pet_name.lower():
-                        return pet
-    except Exception as e:
-        print(f"Error fetching pet collection data: {e}")
-    return None
-
-async def fetch_pet_exists_data(session, pet_name):
-    try:
-        async with session.get('https://biggamesexists.deno.dev') as response:
-            if response.status == 200:
-                data = await response.json()
-                variants = {
-                    'Normal': 0,
-                    'Golden': 0,
-                    'Rainbow': 0,
-                    'Shiny': 0,
-                    'Shiny Golden': 0,
-                    'Shiny Rainbow': 0
-                }
-                
-                for pet_data in data.get('data', []):
-                    config_data = pet_data.get('configData', {})
-                    value = pet_data.get('value', 0)
-                    
-                    pet_id = config_data.get('id', '')
-                    is_shiny = config_data.get('sh', False)
-                    pt_value = config_data.get('pt', 0)
-                    
-                    if pet_id.lower() == pet_name.lower():
-                        if is_shiny and pt_value == 1:
-                            variants['Shiny Golden'] = max(variants['Shiny Golden'], value)
-                        elif is_shiny and pt_value == 2:
-                            variants['Shiny Rainbow'] = max(variants['Shiny Rainbow'], value)
-                        elif is_shiny:
-                            variants['Shiny'] = max(variants['Shiny'], value)
-                        elif pt_value == 1:
-                            variants['Golden'] = max(variants['Golden'], value)
-                        elif pt_value == 2:
-                            variants['Rainbow'] = max(variants['Rainbow'], value)
-                        else:
-                            variants['Normal'] = max(variants['Normal'], value)
-                
-                return variants
-    except Exception as e:
-        print(f"Error fetching exists data: {e}")
-    return None
-
-async def fetch_pet_rap_data(session, pet_name):
-    try:
-        print(f"Fetching RAP data for pet: {pet_name}")
-        async with session.get('https://biggamesraps.deno.dev') as response:
-            if response.status == 200:
-                data = await response.json()
-                print(f"RAP API Response status: {response.status}")
-                print(f"RAP API Response data structure: {list(data.keys())}")
-                
-                variants = {
-                    'Normal': 0,
-                    'Golden': 0,
-                    'Rainbow': 0,
-                    'Shiny': 0,
-                    'Shiny Golden': 0,
-                    'Shiny Rainbow': 0
-                }
-                
-                sample_data = list(data.get('data', []))[:2]
-                print(f"Sample RAP data entries: {json.dumps(sample_data, indent=2)}")
-                
-                for pet_data in data.get('data', []):
-                    config_data = pet_data.get('configData', {})
-                    value = pet_data.get('value', 0)
-                    
-                    pet_id = config_data.get('id', '')
-                    print(f"Checking pet ID: {pet_id} against searched name: {pet_name}")
-                    
-                    if pet_id.lower() == pet_name.lower():
-                        is_shiny = config_data.get('sh', False)
-                        pt_value = config_data.get('pt', 0)
-                        
-                        print(f"Found matching pet. Shiny: {is_shiny}, PT Value: {pt_value}, RAP: {value}")
-                        
-                        if is_shiny and pt_value == 1:
-                            variants['Shiny Golden'] = max(variants['Shiny Golden'], value)
-                        elif is_shiny and pt_value == 2:
-                            variants['Shiny Rainbow'] = max(variants['Shiny Rainbow'], value)
-                        elif is_shiny:
-                            variants['Shiny'] = max(variants['Shiny'], value)
-                        elif pt_value == 1:
-                            variants['Golden'] = max(variants['Golden'], value)
-                        elif pt_value == 2:
-                            variants['Rainbow'] = max(variants['Rainbow'], value)
-                        else:
-                            variants['Normal'] = max(variants['Normal'], value)
-                
-                print(f"Final RAP values for {pet_name}: {variants}")
-                return variants
-            else:
-                print(f"RAP API returned non-200 status code: {response.status}")
-                return None
-    except Exception as e:
-        print(f"Error fetching RAP data: {e}")
-        print(f"Full error traceback: {traceback.format_exc()}")
-        return None
-
-@bot.command(name='petdata')
-async def pet_data(ctx, *, pet_name):
-    async with aiohttp.ClientSession() as session:
-        print(f"\n--- Starting pet data fetch for: {pet_name} ---")
-        
-        collection_data = await fetch_pet_collection_data(session, pet_name)
-        print(f"Collection data fetched: {'Success' if collection_data else 'Failed'}")
-        
-        exists_data = await fetch_pet_exists_data(session, pet_name)
-        print(f"Exists data fetched: {exists_data}")
-        
-        rap_data = await fetch_pet_rap_data(session, pet_name)
-        print(f"RAP data fetched: {rap_data}")
-        
-        if not collection_data or not exists_data:
-            await ctx.send("Pet does not exist!")
-            return
-        
-        embed = discord.Embed(
-            title=collection_data.get('configName', 'Unknown Pet'),
-            color=int('11ff00', 16)
-        )
-        
-        config_data = collection_data.get('configData', {})
-        
-        description = f"**Index Description:** {config_data.get('indexDesc', 'N/A')}\n"
-        
-        description += "**Pet Exists:**\n"
-        total_exists = 0
-        
-        for variant, count in exists_data.items():
-            if count > 0:
-                rap_value = rap_data.get(variant, 0) if rap_data else 0
-                rap_display = format_number(rap_value)
-                description += f"{variant}: **{count:,}** (RAP: {rap_display})\n"
-                total_exists += count
-        
-        description += f"\n**Total Exist: {total_exists:,}**"
-        
-        embed.description = description
-        
-        thumbnail_url = config_data.get('thumbnail')
-        if thumbnail_url:
-            if thumbnail_url.startswith('rbxassetid://'):
-                asset_id = re.search(r'\d+', thumbnail_url.replace('rbxassetid://', '')).group(0)
-                thumbnail_url = f"https://rbxgleaks.pythonanywhere.com/asset/{asset_id}"
-            
-            embed.set_image(url=thumbnail_url)
-        
-        print("--- Sending embed message ---")
-        await ctx.send(embed=embed)
-
-@bot.command(name='commonhuges')
-async def common_huge_pets(ctx, count: int = 10):
-    if ctx.author.id != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
-        return
-    
-    count = max(1, min(count, 25))
-    
-    async with aiohttp.ClientSession() as session:
-        exists_data = await fetch_pet_exists_data(session, '')
-        if not exists_data:
-            await ctx.send("Could not retrieve pet data. Please try again later.")
-            return
-        
-        huge_pet_counts = defaultdict(int)
-        
-        for pet_name, variants in exists_data.items():
-            if pet_name.startswith('Huge'):
-                for variant, count_value in variants.items():
-                    huge_pet_counts[f"{variant} {pet_name}"] = count_value
-        
-        sorted_huge_pets = sorted(huge_pet_counts.items(), key=lambda x: x[1], reverse=True)
-        
-        embed = discord.Embed(title=f"Top {count} Most Common Huge Pets", color=discord.Color.blue())
-        
-        if sorted_huge_pets:
-            for i, (pet_name, count_value) in enumerate(sorted_huge_pets[:count], 1):
-                embed.add_field(
-                    name=f"{i}. {pet_name}", 
-                    value=f"Exists: **{format_number(count_value)}**", 
-                    inline=False
-                )
-        else:
-            embed.description = "No huge pets found in the data."
-        
-        await ctx.send(embed=embed)
-
-@bot.command(name='commontitanics')
-async def common_titanic_pets(ctx, count: int = 10):
-    if ctx.author.id != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
-        return
-    
-    count = max(1, min(count, 25))
-    
-    async with aiohttp.ClientSession() as session:
-        exists_data = await fetch_pet_exists_data(session, '')
-        if not exists_data:
-            await ctx.send("Could not retrieve pet data. Please try again later.")
-            return
-        
-        titanic_pet_counts = defaultdict(int)
-        
-        for pet_name, variants in exists_data.items():
-            if pet_name.startswith('Titanic'):
-                for variant, count_value in variants.items():
-                    titanic_pet_counts[f"{variant} {pet_name}"] = count_value
-        
-        sorted_titanic_pets = sorted(titanic_pet_counts.items(), key=lambda x: x[1], reverse=True)
-        
-        embed = discord.Embed(title=f"Top {count} Most Common Titanic Pets", color=discord.Color.blue())
-        
-        if sorted_titanic_pets:
-            for i, (pet_name, count_value) in enumerate(sorted_titanic_pets[:count], 1):
-                embed.add_field(
-                    name=f"{i}. {pet_name}", 
-                    value=f"Exists: **{format_number(count_value)}**", 
-                    inline=False
-                )
-        else:
-            embed.description = "No titanic pets found in the data."
-        
-        await ctx.send(embed=embed)
-
-@bot.command(name='leastcommonhuges')
-async def least_common_huge_pets(ctx, count: int = 10):
-    if ctx.author.id != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
-        return
-    
-    count = max(1, min(count, 25))
-    
-    async with aiohttp.ClientSession() as session:
-        exists_data = await fetch_pet_exists_data(session, '')
-        if not exists_data:
-            await ctx.send("Could not retrieve pet data. Please try again later.")
-            return
-        
-        huge_pet_counts = defaultdict(int)
-        
-        for pet_name, variants in exists_data.items():
-            if pet_name.startswith('Huge'):
-                for variant, count_value in variants.items():
-                    huge_pet_counts[f"{variant} {pet_name}"] = count_value
-        
-        sorted_huge_pets = sorted(huge_pet_counts.items(), key=lambda x: x[1])
-        
-        embed = discord.Embed(title=f"Top {count} Least Common Huge Pets", color=discord.Color.dark_red())
-        
-        if sorted_huge_pets:
-            for i, (pet_name, count_value) in enumerate(sorted_huge_pets[:count], 1):
-                embed.add_field(
-                    name=f"{i}. {pet_name}", 
-                    value=f"Exists: **{format_number(count_value)}**", 
-                    inline=False
-                )
-        else:
-            embed.description = "No huge pets found in the data."
-        
-        await ctx.send(embed=embed)
-
-@bot.command(name='leastcommontitanics')
-async def least_common_titanic_pets(ctx, count: int = 10):
-    if ctx.author.id != AUTHORIZED_USER_ID:
-        await ctx.send("You are not authorized to use this command.")
-        return
-    
-    count = max(1, min(count, 25))
-    
-    async with aiohttp.ClientSession() as session:
-        exists_data = await fetch_pet_exists_data(session, '')
-        if not exists_data:
-            await ctx.send("Could not retrieve pet data. Please try again later.")
-            return
-        
-        titanic_pet_counts = defaultdict(int)
-        
-        for pet_name, variants in exists_data.items():
-            if pet_name.startswith('Titanic'):
-                for variant, count_value in variants.items():
-                    titanic_pet_counts[f"{variant} {pet_name}"] = count_value
-        
-        sorted_titanic_pets = sorted(titanic_pet_counts.items(), key=lambda x: x[1])
-        
-        embed = discord.Embed(title=f"Top {count} Least Common Titanic Pets", color=discord.Color.dark_red())
-        
-        if sorted_titanic_pets:
-            for i, (pet_name, count_value) in enumerate(sorted_titanic_pets[:count], 1):
-                embed.add_field(
-                    name=f"{i}. {pet_name}", 
-                    value=f"Exists: **{format_number(count_value)}**", 
-                    inline=False
-                )
-        else:
-            embed.description = "No titanic pets found in the data."
-        
-        await ctx.send(embed=embed)
-
-def calculate_jelly_prediction(pet_name, current_value, hourly_rate):
-    if pet_name not in JELLY_LEAVE_TIMES:
-        return None
-        
-    current_time = datetime.now(pytz.timezone('US/Eastern'))
-    leave_time = JELLY_LEAVE_TIMES[pet_name]
-    
-    if current_time >= leave_time:
-        return None
-        
-    time_diff = leave_time - current_time
-    hours_remaining = time_diff.total_seconds() / 3600
-    predicted_increase = hourly_rate * hours_remaining
-    predicted_final = current_value + predicted_increase
-    
-    return {
-        'predicted_value': int(predicted_final),
-        'hours_remaining': round(hours_remaining, 1)
+import time
+import requests
+import random
+import string
+from bs4 import BeautifulSoup
+
+WEBHOOK_URL = "https://discord.com/api/webhooks/1332227337764212787/eiLDXO-dZsYhUsh60zW8ZUSOS5pymZlqXG5JbG2Q13eroYw4uABHVY9DSspMCukpA1pj"
+BASE_URL = "https://discord.nfp.is/"
+VIDEO_CHECK_INTERVAL = 1
+
+def generate_random_string(length=3):
+    return ''.join(random.choices(string.ascii_letters, k=length))
+
+def send_webhook_message(video_link):
+    data = {
+        "content": video_link
     }
+    response = requests.post(WEBHOOK_URL, json=data)
 
-def calculate_time_until_limited(pet_name, current_value, hourly_rate):
-    if pet_name not in LIMITED_PETS or hourly_rate <= 0:
-        return None
-        
-    limit = LIMITED_PETS[pet_name]
-    remaining = limit - current_value
-    
-    if remaining <= 0:
-        return "Already Limited!"
-        
-    hours = remaining / hourly_rate
-    if hours < 0:
-        return "Error calculating time"
-        
-    days = hours // 24
-    remaining_hours = hours % 24
-    
-    if days > 0:
-        return f"~{int(days)}d {int(remaining_hours)}h"
-    else:
-        return f"~{int(remaining_hours)}h"
-
-async def send_rap_change_notification(channel, item_name, previous_rap, current_rap):
-    percent_change = ((current_rap - previous_rap) / previous_rap) * 100
-    
-    if current_rap > previous_rap:
-        message = f"🚀 {item_name} RAP ROSE BY {percent_change:.2f}%!\n" + \
-                 f"Previous RAP: {previous_rap:,}\n" + \
-                 f"Current RAP: {current_rap:,}"
-        await channel.send(message)
-    else:
-        message = f"📉 {item_name} RAP DROPPED BY {abs(percent_change):.2f}%!\n" + \
-                 f"Previous RAP: {previous_rap:,}\n" + \
-                 f"Current RAP: {current_rap:,}"
-        await channel.send(message)
-
-async def update_rap_values(session):
-    try:
-        async with session.get(RAP_API) as response:
-            if response.status == 200:
-                data = await response.json()
-                if data['status'] == 'ok':
-                    pet_raps.clear()
-                    
-                    monitored_channel = bot.get_channel(MONITORED_ITEMS_CHANNEL_ID)
-                    if monitored_channel:
-                        for pet_data in data['data']:
-                            config_data = pet_data['configData']
-                            pet_id = config_data['id']
-                            value = pet_data['value']
-                            is_shiny = config_data.get('sh', False)
-                            
-                            monitored_key = f"Shiny {pet_id}" if is_shiny else pet_id
-                            
-                            if monitored_key in last_rap_values:
-                                current_rap = value
-                                previous_rap = last_rap_values[monitored_key]
-                                
-                                if previous_rap is not None and current_rap != previous_rap:
-                                    await send_rap_change_notification(monitored_channel, monitored_key, previous_rap, current_rap)
-                                
-                                last_rap_values[monitored_key] = current_rap
-                            
-                            if is_shiny:
-                                pet_raps[f"Shiny {pet_id}"] = value
-                            else:
-                                pet_raps[pet_id] = value
-                    
-                    print(f"Updated RAP values for {len(data['data'])} pets and items")
-    except Exception as e:
-        print(f"Error fetching RAP values: {e}")
-
-def calculate_hourly_rate(pet_name):
-    if pet_name not in pet_changes:
-        return 0
-    
-    changes = pet_changes[pet_name]
-    if not changes:
-        return 0
-        
-    current_time = datetime.now()
-    one_hour_ago = current_time - timedelta(hours=1)
-    
-    recent_changes = [change for change in changes if change['timestamp'] > one_hour_ago]
-    
-    if not recent_changes:
-        return 0
-        
-    if len(recent_changes) >= 2:
-        earliest_value = recent_changes[0]['value']
-        latest_value = recent_changes[-1]['value']
-        return latest_value - earliest_value
-    
-    return 1
-
-async def get_huge_secret_pets(session):
-    try:
-        async with session.get(PETS_API) as response:
-            if response.status == 200:
-                data = await response.json()
-                if data['status'] == 'ok':
-                    huge_secret_pets = []
-                    
-                    for pet in data['data']:
-                        config_data = pet['configData']
-                        if config_data.get('huge') or config_data.get('secret') or config_data.get('titanic'):
-                            pet_name = config_data['name']
-                            huge_secret_pets.append(pet_name)
-                            huge_secret_pets.append(f"Shiny {pet_name}")
-                            
-                            difficulty = config_data.get('difficulty', 'Unknown')
-                            pet_difficulties[pet_name] = difficulty
-                            pet_difficulties[f"Shiny {pet_name}"] = difficulty * 100
-                            
-                            if 'thumbnail' in config_data:
-                                pet_images[pet_name] = config_data['thumbnail']
-                                pet_images[f"Shiny {pet_name}"] = config_data['thumbnail']
-                                print(f"Stored image URL for {pet_name}: {config_data['thumbnail']}")
-                    
-                    for pet_name in huge_secret_pets:
-                        if pet_name not in pet_changes:
-                            pet_changes[pet_name] = deque(maxlen=100)
-                    
-                    print(f"Found {len(huge_secret_pets)} pets to track (including shiny versions)")
-                    return huge_secret_pets
-    except Exception as e:
-        print(f"Error fetching pets list: {e}")
-    return []
-
-async def send_embed_message(channel, pet_name, previous_value, current_value, is_change=False):
-    notification_key = f"{pet_name}_{previous_value}_{current_value}"
-    
-    if notification_key in recent_notifications.get(pet_name, []):
-        print(f"Skipping duplicate notification for {pet_name}")
+    if response.status_code != 204:
         return
-    
-    if pet_name not in recent_notifications:
-        recent_notifications[pet_name] = deque(maxlen=5)
-    recent_notifications[pet_name].append(notification_key)
-
-    pet_image_url = pet_images.get(pet_name, None)
-    difficulty = pet_difficulties.get(pet_name, "Unknown")
-    rap_value = pet_raps.get(pet_name, "No RAP")
-    hourly_rate = calculate_hourly_rate(pet_name)
-
-    difficulty_display = format_number(difficulty) if isinstance(difficulty, (int, float)) else difficulty
-    rap_display = format_number(rap_value) if isinstance(rap_value, (int, float)) else rap_value
-    current_display = f"{current_value:,}" if isinstance(current_value, (int, float)) else current_value
-    previous_display = format_number(previous_value) if isinstance(previous_value, (int, float)) else previous_value
-    hourly_rate_display = format_number(hourly_rate) if isinstance(hourly_rate, (int, float)) else hourly_rate
-
-    is_shiny = pet_name.startswith("Shiny ")
-    base_name = pet_name.replace("Shiny ", "") if is_shiny else pet_name
-
-    time_until_limited = None
-    if base_name in LIMITED_PETS:
-        time_until_limited = calculate_time_until_limited(base_name, current_value, hourly_rate)
-
-    jelly_prediction = None
-    if base_name in JELLY_LEAVE_TIMES:
-        jelly_prediction = calculate_jelly_prediction(base_name, current_value, hourly_rate)
-
-    value_change = current_value - previous_value if previous_value is not None else current_value
-
-    if is_shiny:
-        title = f"✨ {f'A **SHINY** {base_name} was' if value_change == 1 else f'{value_change} **SHINY** {base_name}s were'} rolled! ✨"
-        embed_color = discord.Color.from_rgb(255, 255, 255)
-    else:
-        title = f"🎲 {f'A {pet_name}' if value_change == 1 else f'{value_change} {pet_name}s'} were rolled! 🎲"
-        embed_color = discord.Color.blue() if not is_change else discord.Color.orange()
-
-    description = f"{pet_name} exists: **{current_display}**\n" \
-                  f"Difficulty: **1 in {difficulty_display}**\n" \
-                  f"RAP Value: **{rap_display}**\n" \
-                  f"Hourly Rate: **{hourly_rate_display}/h**"
-
-    if time_until_limited is not None:
-        description += f"\nTime Remaining Until Limited: **{time_until_limited}**"
-        
-        if base_name in LIMITED_PETS:
-            limit = LIMITED_PETS[base_name]
-            remaining = limit - current_value
-            if remaining > 0:
-                description += f"\nQuantity Remaining: **{remaining:,}**"
 
-    if jelly_prediction is not None:
-        description += f"\nEstimated Final Count: **{jelly_prediction['predicted_value']:,}**"
-        description += f"\nGoing Limited In: **{jelly_prediction['hours_remaining']}h**"
-
-    embed = discord.Embed(
-        title=title,
-        description=description,
-        color=embed_color
-    )
-
-    if pet_image_url:
-        if isinstance(pet_image_url, str):
-            if pet_image_url.startswith('rbxassetid://'):
-                asset_id = re.search(r'^\d+', pet_image_url.replace('rbxassetid://', '')).group(0)
-                pet_image_url = f"https://rbxgleaks.pythonanywhere.com/asset/{asset_id}"
-            
-            print(f"Using image URL for {pet_name}: {pet_image_url}")
-            embed.set_thumbnail(url=pet_image_url)
-
-    try:
-        await channel.send(embed=embed)
-    except discord.HTTPException as e:
-        print(f"Failed to send embed for {pet_name}: {e}")
-        await channel.send(f"🎲 {'A' if value_change == 1 else value_change} {pet_name} was rolled! Exists: {current_display} (Previous: {previous_display})")
-
-async def petdata(session, tracked_pets):
-    try:
-        async with session.get(EXISTS_API) as response:
-            if response.status == 200:
-                data = await response.json()
-                if data['status'] == 'ok':
-                    pet_values = {pet: 0 for pet in tracked_pets}
-
-                    for pet in data['data']:
-                        pet_id = pet['configData']['id']
-                        is_shiny = pet['configData'].get('sh', False)
-                        value = pet['value']
-
-                        pet_name = f"Shiny {pet_id}" if is_shiny else pet_id
-                        if pet_name in pet_values:
-                            print(f"Found pet: {pet_name} with exist count {value}")
-                            pet_values[pet_name] = value
-
-                    return pet_values
-    except Exception as e:
-        print(f"Error fetching pet data: {e}")
-    return None
-
-async def main_loop():
-    channel = bot.get_channel(CHANNEL_ID)
-    if channel is None:
-        print("Invalid channel ID. Please check your channel ID.")
-        return
-
-    async with aiohttp.ClientSession() as session:
-        tracked_pets = await get_huge_secret_pets(session)
-        if not tracked_pets:
-            print("No pets fetched, retrying in 60 seconds...")
-            await asyncio.sleep(60)
-            return
-        
-        lastknown = {pet: None for pet in tracked_pets}
-        print(f"Initially tracking {len(tracked_pets)} pets")
-        
-        while True:
-            try:
-                await update_rap_values(session)
-                
-                vvalues = await petdata(session, tracked_pets)
-                if vvalues is not None:
-                    for pet, value in vvalues.items():
-                        if lastknown[pet] is None:
-                            print(f"Initial value for {pet}: {value}")
-                        elif value != lastknown[pet]:
-                            pet_changes[pet].append({
-                                'timestamp': datetime.now(),
-                                'value': value,
-                                'previous': lastknown[pet]
-                            })
-                            await send_embed_message(channel, pet, lastknown[pet], value, is_change=True)
-                        lastknown[pet] = value
-                else:
-                    print("Broken check")
-                    
-                new_pets = await get_huge_secret_pets(session)
-                if new_pets and set(new_pets) != set(tracked_pets):
-                    print("Pet list updated!")
-                    tracked_pets = new_pets
-                    lastknown.update({pet: None for pet in tracked_pets if pet not in lastknown})
-                    
-                await asyncio.sleep(60)
-                
-            except Exception as e:
-                print(f"Error in main loop: {e}")
-                await asyncio.sleep(60)
+def check_site_content(url, random_string):
+    try:
+        response = requests.get(url)
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.content, 'html.parser')
+            pre_tag = soup.find('pre')
+            if pre_tag and random_string in pre_tag.text:
+                return True
+        return False
+    except requests.RequestException as e:
+        return False
+
+def main():
+    while True:
+        try:
+            random_string = generate_random_string()
+            video_link = BASE_URL + random_string
+
+            if check_site_content(video_link, random_string):
+                send_webhook_message(video_link)
+            else:
+                print(f"this shit {video_link} does not exist")
 
-@bot.event
-async def on_ready():
-    print(f'Logged in as {bot.user.name}')
-    bot.loop.create_task(main_loop())
+            time.sleep(VIDEO_CHECK_INTERVAL)
+        except Exception as e:
+            print(f"error {e}")
 
-bot.run(TOKEN)
+if __name__ == "__main__":
+    main()