Update ccc.py

ccc.py

@@ -1,11 +1,10 @@
-import requests
+import aiohttp
 import discord
 from discord.ext import commands
 import asyncio
 import json
 import re
-from collections import defaultdict
-from collections import deque
+from collections import defaultdict, deque
 from datetime import datetime, timedelta
 import pytz
 import os
@@ -46,14 +45,15 @@ bot = commands.Bot(command_prefix='!', intents=intents)
 pet_images = {}
 pet_difficulties = {}
 pet_raps = {}
-pet_changes = {}
-recent_notifications = defaultdict(lambda: deque(maxlen=5))
+pet_changes = defaultdict(deque)
+recent_notifications = defaultdict(deque)
 
-async def fetch_exists_data():
+async def fetch_exists_data(session):
     try:
-        response = requests.get('https://biggamesexists.deno.dev')
-        if response.status_code == 200:
-            return response.json().get('data', [])
+        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 []
@@ -74,323 +74,327 @@ def format_number(number):
     else:
         return f"{number/1000000000000:.1f}t"
     
-async def fetch_pet_collection_data(pet_name):
+async def fetch_pet_collection_data(session, pet_name):
     try:
-        response = requests.get('https://collectionpet.deno.dev')
-        if response.status_code == 200:
-            data = response.json().get('data', [])
-            for pet in data:
-                if pet.get('configName', '').lower() == pet_name.lower():
-                    return pet
+        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(pet_name):
+async def fetch_pet_exists_data(session, pet_name):
     try:
-        response = requests.get('https://biggamesexists.deno.dev')
-        if response.status_code == 200:
-            data = response.json().get('data', [])
-            variants = {
-                'Normal': 0,
-                'Golden': 0,
-                'Rainbow': 0,
-                'Shiny': 0,
-                'Shiny Golden': 0,
-                'Shiny Rainbow': 0
-            }
-            
-            for pet_data in data:
-                config_data = pet_data.get('configData', {})
-                value = pet_data.get('value', 0)
+        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
+                }
                 
-                pet_id = config_data.get('id', '')
-                is_shiny = config_data.get('sh', False)
-                pt_value = config_data.get('pt', 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)
                 
-                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
+                return variants
     except Exception as e:
         print(f"Error fetching exists data: {e}")
     return None
 
 @bot.command(name='petdata')
 async def pet_data(ctx, *, pet_name):
-    collection_data = await fetch_pet_collection_data(pet_name)
-    
-    exists_data = await fetch_pet_exists_data(pet_name)
-    
-    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 += f"**Obtainable in Index:** {config_data.get('indexObtainable', 'N/A')}"
-    embed.description = description
-    
-    total_exists = sum(exists_data.values())
-    
-    exists_text = "\n".join([
-        f"{variant}: **{count:,}**"
-        for variant, count in exists_data.items() if count > 0
-    ])
-    exists_text += f"\n\n**Total Exist: {total_exists:,}**"
-    
-    embed.add_field(name="**Pet Exists:**", value=exists_text, inline=False)
-    
-    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}"
+    async with aiohttp.ClientSession() as session:
+        collection_data = await fetch_pet_collection_data(session, pet_name)
+        exists_data = await fetch_pet_exists_data(session, pet_name)
         
-        embed.set_image(url=thumbnail_url)
-    
-    await ctx.send(embed=embed)
+        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 += f"**Obtainable in Index:** {config_data.get('indexObtainable', 'N/A')}"
+        embed.description = description
+        
+        total_exists = sum(exists_data.values())
+        
+        exists_text = "\n".join([
+            f"{variant}: **{count:,}**"
+            for variant, count in exists_data.items() if count > 0
+        ])
+        exists_text += f"\n\n**Total Exist: {total_exists:,}**"
+        
+        embed.add_field(name="**Pet Exists:**", value=exists_text, inline=False)
+        
+        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)
+        
+        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))
-
-    exists_data = await fetch_exists_data()
-    if not exists_data:
-        await ctx.send("Could not retrieve pet data. Please try again later.")
-        return
-
-    huge_pet_counts = defaultdict(int)
     
-    for pet in exists_data:
-        config_data = pet.get('configData', {})
-        value = pet.get('value', 0)
+    async with aiohttp.ClientSession() as session:
+        exists_data = await fetch_exists_data(session)
+        if not exists_data:
+            await ctx.send("Could not retrieve pet data. Please try again later.")
+            return
         
-        if config_data.get('id', '').startswith('Huge'):
-            pet_name = config_data.get('id', 'Unknown')
-            
-            is_shiny = config_data.get('sh', False)
-            pt_value = config_data.get('pt', 0)
-            
-            if is_shiny and pt_value == 1:
-                variant_key = f"Shiny Golden {pet_name}"
-            elif is_shiny and pt_value == 2:
-                variant_key = f"Shiny Rainbow {pet_name}"
-            elif is_shiny:
-                variant_key = f"Shiny {pet_name}"
-            elif pt_value == 1:
-                variant_key = f"Golden {pet_name}"
-            elif pt_value == 2:
-                variant_key = f"Rainbow {pet_name}"
-            else:
-                variant_key = f"Normal {pet_name}"
+        huge_pet_counts = defaultdict(int)
+        
+        for pet in exists_data:
+            config_data = pet.get('configData', {})
+            value = pet.get('value', 0)
             
-            huge_pet_counts[variant_key] = max(huge_pet_counts[variant_key], 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)
+            if config_data.get('id', '').startswith('Huge'):
+                pet_name = config_data.get('id', 'Unknown')
+                
+                is_shiny = config_data.get('sh', False)
+                pt_value = config_data.get('pt', 0)
+                
+                if is_shiny and pt_value == 1:
+                    variant_key = f"Shiny Golden {pet_name}"
+                elif is_shiny and pt_value == 2:
+                    variant_key = f"Shiny Rainbow {pet_name}"
+                elif is_shiny:
+                    variant_key = f"Shiny {pet_name}"
+                elif pt_value == 1:
+                    variant_key = f"Golden {pet_name}"
+                elif pt_value == 2:
+                    variant_key = f"Rainbow {pet_name}"
+                else:
+                    variant_key = f"Normal {pet_name}"
+                
+                huge_pet_counts[variant_key] = max(huge_pet_counts[variant_key], 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))
-
-    exists_data = await fetch_exists_data()
-    if not exists_data:
-        await ctx.send("Could not retrieve pet data. Please try again later.")
-        return
-
-    huge_pet_counts = defaultdict(int)
     
-    for pet in exists_data:
-        config_data = pet.get('configData', {})
-        value = pet.get('value', 0)
+    async with aiohttp.ClientSession() as session:
+        exists_data = await fetch_exists_data(session)
+        if not exists_data:
+            await ctx.send("Could not retrieve pet data. Please try again later.")
+            return
         
-        if config_data.get('id', '').startswith('Titanic'):
-            pet_name = config_data.get('id', 'Unknown')
-            
-            is_shiny = config_data.get('sh', False)
-            pt_value = config_data.get('pt', 0)
-            
-            if is_shiny and pt_value == 1:
-                variant_key = f"Shiny Golden {pet_name}"
-            elif is_shiny and pt_value == 2:
-                variant_key = f"Shiny Rainbow {pet_name}"
-            elif is_shiny:
-                variant_key = f"Shiny {pet_name}"
-            elif pt_value == 1:
-                variant_key = f"Golden {pet_name}"
-            elif pt_value == 2:
-                variant_key = f"Rainbow {pet_name}"
-            else:
-                variant_key = f"Normal {pet_name}"
+        titanic_pet_counts = defaultdict(int)
+        
+        for pet in exists_data:
+            config_data = pet.get('configData', {})
+            value = pet.get('value', 0)
             
-            huge_pet_counts[variant_key] = max(huge_pet_counts[variant_key], 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 Titanic 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 titanic pets found in the data."
-
-    await ctx.send(embed=embed)
+            if config_data.get('id', '').startswith('Titanic'):
+                pet_name = config_data.get('id', 'Unknown')
+                
+                is_shiny = config_data.get('sh', False)
+                pt_value = config_data.get('pt', 0)
+                
+                if is_shiny and pt_value == 1:
+                    variant_key = f"Shiny Golden {pet_name}"
+                elif is_shiny and pt_value == 2:
+                    variant_key = f"Shiny Rainbow {pet_name}"
+                elif is_shiny:
+                    variant_key = f"Shiny {pet_name}"
+                elif pt_value == 1:
+                    variant_key = f"Golden {pet_name}"
+                elif pt_value == 2:
+                    variant_key = f"Rainbow {pet_name}"
+                else:
+                    variant_key = f"Normal {pet_name}"
+                
+                titanic_pet_counts[variant_key] = max(titanic_pet_counts[variant_key], 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))
-
-    exists_data = await fetch_exists_data()
-    if not exists_data:
-        await ctx.send("Could not retrieve pet data. Please try again later.")
-        return
-
-    huge_pet_counts = defaultdict(int)
     
-    for pet in exists_data:
-        config_data = pet.get('configData', {})
-        value = pet.get('value', 0)
+    async with aiohttp.ClientSession() as session:
+        exists_data = await fetch_exists_data(session)
+        if not exists_data:
+            await ctx.send("Could not retrieve pet data. Please try again later.")
+            return
         
-        if config_data.get('id', '').startswith('Huge'):
-            pet_name = config_data.get('id', 'Unknown')
-            
-            is_shiny = config_data.get('sh', False)
-            pt_value = config_data.get('pt', 0)
-            
-            if is_shiny and pt_value == 1:
-                variant_key = f"Shiny Golden {pet_name}"
-            elif is_shiny and pt_value == 2:
-                variant_key = f"Shiny Rainbow {pet_name}"
-            elif is_shiny:
-                variant_key = f"Shiny {pet_name}"
-            elif pt_value == 1:
-                variant_key = f"Golden {pet_name}"
-            elif pt_value == 2:
-                variant_key = f"Rainbow {pet_name}"
-            else:
-                variant_key = f"Normal {pet_name}"
+        huge_pet_counts = defaultdict(int)
+        
+        for pet in exists_data:
+            config_data = pet.get('configData', {})
+            value = pet.get('value', 0)
             
-            huge_pet_counts[variant_key] = max(huge_pet_counts[variant_key], 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)
+            if config_data.get('id', '').startswith('Huge'):
+                pet_name = config_data.get('id', 'Unknown')
+                
+                is_shiny = config_data.get('sh', False)
+                pt_value = config_data.get('pt', 0)
+                
+                if is_shiny and pt_value == 1:
+                    variant_key = f"Shiny Golden {pet_name}"
+                elif is_shiny and pt_value == 2:
+                    variant_key = f"Shiny Rainbow {pet_name}"
+                elif is_shiny:
+                    variant_key = f"Shiny {pet_name}"
+                elif pt_value == 1:
+                    variant_key = f"Golden {pet_name}"
+                elif pt_value == 2:
+                    variant_key = f"Rainbow {pet_name}"
+                else:
+                    variant_key = f"Normal {pet_name}"
+                
+                huge_pet_counts[variant_key] = max(huge_pet_counts[variant_key], 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))
-
-    exists_data = await fetch_exists_data()
-    if not exists_data:
-        await ctx.send("Could not retrieve pet data. Please try again later.")
-        return
-
-    titanic_pet_counts = defaultdict(int)
     
-    for pet in exists_data:
-        config_data = pet.get('configData', {})
-        value = pet.get('value', 0)
+    async with aiohttp.ClientSession() as session:
+        exists_data = await fetch_exists_data(session)
+        if not exists_data:
+            await ctx.send("Could not retrieve pet data. Please try again later.")
+            return
         
-        if config_data.get('id', '').startswith('Titanic'):
-            pet_name = config_data.get('id', 'Unknown')
-            
-            is_shiny = config_data.get('sh', False)
-            pt_value = config_data.get('pt', 0)
-            
-            if is_shiny and pt_value == 1:
-                variant_key = f"Shiny Golden {pet_name}"
-            elif is_shiny and pt_value == 2:
-                variant_key = f"Shiny Rainbow {pet_name}"
-            elif is_shiny:
-                variant_key = f"Shiny {pet_name}"
-            elif pt_value == 1:
-                variant_key = f"Golden {pet_name}"
-            elif pt_value == 2:
-                variant_key = f"Rainbow {pet_name}"
-            else:
-                variant_key = f"Normal {pet_name}"
+        titanic_pet_counts = defaultdict(int)
+        
+        for pet in exists_data:
+            config_data = pet.get('configData', {})
+            value = pet.get('value', 0)
             
-            titanic_pet_counts[variant_key] = max(titanic_pet_counts[variant_key], 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)
+            if config_data.get('id', '').startswith('Titanic'):
+                pet_name = config_data.get('id', 'Unknown')
+                
+                is_shiny = config_data.get('sh', False)
+                pt_value = config_data.get('pt', 0)
+                
+                if is_shiny and pt_value == 1:
+                    variant_key = f"Shiny Golden {pet_name}"
+                elif is_shiny and pt_value == 2:
+                    variant_key = f"Shiny Rainbow {pet_name}"
+                elif is_shiny:
+                    variant_key = f"Shiny {pet_name}"
+                elif pt_value == 1:
+                    variant_key = f"Golden {pet_name}"
+                elif pt_value == 2:
+                    variant_key = f"Rainbow {pet_name}"
+                else:
+                    variant_key = f"Normal {pet_name}"
+                
+                titanic_pet_counts[variant_key] = max(titanic_pet_counts[variant_key], 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:
@@ -448,39 +452,39 @@ async def send_rap_change_notification(channel, item_name, previous_rap, current
                  f"Current RAP: {current_rap:,}"
         await channel.send(message)
 
-async def update_rap_values():
+async def update_rap_values(session):
     try:
-        response = requests.get(RAP_API)
-        if response.status_code == 200:
-            data = 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]
+        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)
                             
-                            if previous_rap is not None and current_rap != previous_rap:
-                                await send_rap_change_notification(monitored_channel, monitored_key, previous_rap, current_rap)
+                            monitored_key = f"Shiny {pet_id}" if is_shiny else pet_id
                             
-                            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")
+                            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}")
 
@@ -507,36 +511,36 @@ def calculate_hourly_rate(pet_name):
     
     return 1
 
-async def get_huge_secret_pets():
+async def get_huge_secret_pets(session):
     try:
-        response = requests.get(PETS_API)
-        if response.status_code == 200:
-            data = 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'):
-                        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
+        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'):
+                            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 []
@@ -549,7 +553,7 @@ async def send_embed_message(channel, pet_name, previous_value, current_value, i
         return
     
     if pet_name not in recent_notifications:
-        recent_notifications[pet_name] = []
+        recent_notifications[pet_name] = deque(maxlen=5)
     recent_notifications[pet_name].append(notification_key)
 
     pet_image_url = pet_images.get(pet_name, None)
@@ -622,28 +626,27 @@ async def send_embed_message(channel, pet_name, previous_value, current_value, i
         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(tracked_pets):
+async def petdata(session, tracked_pets):
     try:
-        response = requests.get(EXISTS_API)
-        if response.status_code == 200:
-            data = 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
-        print(f"Error code: {response.status_code}")
+        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: {e}")
+        print(f"Error fetching pet data: {e}")
     return None
 
 async def main_loop():
@@ -652,54 +655,51 @@ async def main_loop():
         print("Invalid channel ID. Please check your channel ID.")
         return
 
-    tracked_pets = await get_huge_secret_pets()
-    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:
-            
-            if not tracked_pets:
-                tracked_pets = await get_huge_secret_pets() or []
-                lastknown.update({pet: None for pet in tracked_pets if pet not in lastknown})
-            
-            await update_rap_values()
-            
-            vvalues = await petdata(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")
+    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)
                 
-            new_pets = await get_huge_secret_pets() or []
-            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})
+                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)
                 
-            await asyncio.sleep(60)
-            
-        except Exception as e:
-            print(f"Error in main loop: {e}")
-            await asyncio.sleep(60)
+            except Exception as e:
+                print(f"Error in main loop: {e}")
+                await asyncio.sleep(60)
 
 @bot.event
 async def on_ready():
     print(f'Logged in as {bot.user.name}')
     bot.loop.create_task(main_loop())
-bot.run(TOKEN)
+
+bot.run(TOKEN)