Initial commit: Discord bot with hybrid commands, Flask keep-alive, and Docker support

.dockerignore

@@ -0,0 +1,22 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.env
+.venv
+venv/
+ENV/
+.git/
+.gitignore
+.vscode/
+.idea/
+*.log
+.DS_Store
+README.md
+.env.example

.env.example

@@ -0,0 +1,18 @@
+# Discord Bot Token - Get from Discord Developer Portal
+DISCORD_TOKEN=your_discord_bot_token_here
+
+# API Keys for various services
+TIMEZONE_API_KEY=your_timezone_api_key
+NASA_API_KEY=your_nasa_api_key
+EXTREME_IP_API_KEY=your_extreme_ip_api_key
+
+# Recipe API (Edamam)
+EDAMAM_API_RECIPE_APP_ID=your_edamam_app_id
+EDAMAM_API_RECIPE_APP_KEY=your_edamam_app_key
+
+# Optional API Keys (if using additional features)
+ATRS_MUSIC_TOKEN=your_music_token
+BITLY_KEY=your_bitly_key
+CAT_KEY=your_cat_api_key
+WEATHER_KEY=your_weather_api_key
+CUTTLY_KEY=your_cuttly_key

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+.venv/
+.env

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:system",
+    "python-envs.pythonProjects": []
+}

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "main.py"]

README.md

@@ -0,0 +1,57 @@
+---
+title: Chitanda V2 Discord Bot
+emoji: 🤖
+colorFrom: purple
+colorTo: pink
+sdk: docker
+pinned: false
+---
+
+# Chitanda V2 Discord Bot
+
+A feature-rich Discord bot with hybrid command support (both prefix and slash commands).
+
+## Features
+
+- 🎮 Fun commands (roll, flip)
+- 💕 Roleplay commands (pat, kiss, highfive)
+- 🛠️ Utility commands (crypto prices, weather, recipes, Wikipedia, etc.)
+- 🔨 Moderation commands (purge, kick, delete)
+- ✨ Hybrid commands (works with both `lu` prefix and `/` slash commands)
+- 🌐 Flask keep-alive server for 24/7 uptime
+
+## Deployment on Hugging Face Spaces
+
+This bot is ready to deploy on Hugging Face Spaces using Docker.
+
+### Steps to Deploy
+
+1. Create a new Space on Hugging Face
+2. Choose "Docker" as the SDK
+3. Upload all files from this repository
+4. In Space settings, add your bot token and API keys as secrets
+5. The bot will automatically start!
+
+### Environment Configuration
+
+The bot reads configuration from `config.json`. Make sure your token and API keys are properly set.
+
+## Local Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+python main.py
+```
+
+## Commands
+
+**Total: 23 commands across 4 categories**
+
+Use `lu help` or `/help` to see all available commands!
+
+- Utilities: 16 commands (ping, crypto, weather, recipes, etc.)
+- Fun: 2 commands (roll, flip)
+- Roleplay: 3 commands (pat, kiss, highfive)
+- Moderation: 3 commands (purge, kick, delete)

cogs/fun.py

@@ -0,0 +1,27 @@
+import random
+from discord.ext import commands
+
+
+class Fun(commands.Cog):
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.hybrid_command(name="roll")
+    async def roll(self, ctx: commands.Context, dice: str = "1d6"):
+        """Roll dice in NdM format (e.g., 2d6)."""
+        try:
+            rolls, faces = map(int, dice.lower().split("d"))
+        except Exception:
+            return await ctx.send("Format has to be NdM, e.g. 2d6.")
+
+        results = [random.randint(1, faces) for _ in range(rolls)]
+        await ctx.send(f"Rolled {dice}: {results} (total {sum(results)})")
+
+    @commands.hybrid_command(name="flip")
+    async def flip(self, ctx: commands.Context):
+        """Flip a coin."""
+        await ctx.send(random.choice(["Heads", "Tails"]))
+
+
+async def setup(bot: commands.Bot):
+    await bot.add_cog(Fun(bot))

cogs/functions.py

@@ -0,0 +1,96 @@
+import asyncio
+from unittest import result
+import yt_dlp
+import os
+from shazamio import Shazam
+import aiohttp
+import base64
+from functools import partial
+
+CLIENT_ID = "550edc8d6d294381a0f4dac9c8c9fea5"
+CLIENT_SECRET = "fade5c01cc8b40acb79ad1f598074b4c"
+
+async def music_recognition(filepath):
+    shazam = Shazam()
+    out = await shazam.recognize(filepath)
+    songname = out['track']['title']
+    artist = out["track"]["subtitle"]
+    ydl_opts = {
+        "quiet": True,
+        "skip_download": True,
+    }
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(f"ytsearch1:{songname} {artist}", download=False)
+        video = info["entries"][0]
+        title = video["title"]
+        yturl = video["webpage_url"]
+        thumbnail = video["thumbnail"]
+        duration = video["duration"]
+        spotifyshit = await spotify_search(f"{songname} {artist}")
+        spotifylink = spotifyshit["tracks"]["items"][0]["external_urls"]["spotify"]
+        return {
+            "songname": songname,
+            "artist": artist,
+            "title": title,
+            "yturl": yturl,
+            "thumbnail": thumbnail,
+            "duration": duration,
+            "spotifylink": spotifylink
+        }
+
+
+async def spotify_auth():
+    auth_url = "https://accounts.spotify.com/api/token"
+    auth_string = f"{CLIENT_ID}:{CLIENT_SECRET}"
+    auth_header = base64.b64encode(auth_string.encode()).decode()
+
+    headers = {
+        "Authorization": f"Basic {auth_header}",
+        "Content-Type": "application/x-www-form-urlencoded"
+    }
+
+    data = {
+        "grant_type": "client_credentials"
+    }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(auth_url, headers=headers, data=data) as resp:
+            response = await resp.json()
+            return response["access_token"]
+  
+async def spotify_search(query: str, search_type="track"):
+    token = await spotify_auth()
+
+    url = "https://api.spotify.com/v1/search"
+    params = {
+        "q": query,
+        "type": search_type,
+        "limit": 1
+    }
+
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers, params=params) as resp:
+            data = await resp.json()
+            return data
+
+
+async def download_mp3(query: str):
+    def _download():
+        ydl_opts = {
+            "quiet": True,
+            "format": "bestaudio/best",
+            "outtmpl": "./assets/audio.%(ext)s",
+            "postprocessors": [{
+                "key": "FFmpegExtractAudio",
+                "preferredcodec": "mp3",
+                "preferredquality": "192",
+            }],
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.extract_info(f"ytsearch1:{query}", download=True)
+        return "./assets/audio.mp3"
+    return await asyncio.to_thread(_download)

cogs/moderation.py

@@ -0,0 +1,79 @@
+import discord
+from discord.ext import commands
+
+
+class Moderation(commands.Cog):
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.hybrid_command(name="purge")
+    @commands.has_permissions(manage_messages=True)
+    async def purge(self, ctx: commands.Context, limit: int):
+        """Delete a number of messages from the current channel."""
+        deleted = await ctx.channel.purge(limit=limit + 1)
+        await ctx.send(f"Deleted {len(deleted) - 1} messages.", delete_after=5)
+
+    @commands.hybrid_command(name="kick")
+    @commands.has_permissions(kick_members=True)
+    async def kick(self, ctx: commands.Context, member: discord.Member, *, reason: str | None = None):
+        """Kick a member from the server."""
+        await member.kick(reason=reason)
+        await ctx.send(f"Kicked {member} " + (f"for: {reason}" if reason else ""))
+
+    @commands.hybrid_command(name="delete")
+    async def delete(self, ctx: commands.Context, amount: int, user: discord.Member = None):
+        """Delete messages in this channel (only works in specific server)"""
+        if ctx.guild.id != 811634680302010449:
+            await ctx.send("This command can only be used in the authorized server.")
+            return
+        
+        if amount < 1:
+            await ctx.send("Please specify a valid number of messages to delete (at least 1).")
+            return
+        
+        is_slash = ctx.interaction is not None
+        
+        if user:
+            if is_slash:
+                await ctx.defer(ephemeral=True)
+            
+            deleted_count = 0
+            def check(m):
+                nonlocal deleted_count
+                if m.author.id == user.id and deleted_count < amount:
+                    deleted_count += 1
+                    return True
+                return False
+            
+            await ctx.channel.purge(limit=100, check=check)
+            success_msg = f"Deleted {deleted_count} message(s) from {user.mention}."
+            
+            if is_slash:
+                await ctx.send(success_msg, ephemeral=True)
+            else:
+                await ctx.send(success_msg, delete_after=10)
+        else:
+            limit = amount if is_slash else amount + 1
+            deleted = await ctx.channel.purge(limit=limit)
+            actual_deleted = len(deleted) if is_slash else len(deleted) - 1
+            success_msg = f"Deleted {actual_deleted} message(s)."
+            
+            if is_slash:
+                await ctx.send(success_msg, ephemeral=True)
+            else:
+                await ctx.send(success_msg, delete_after=10)
+
+
+    @purge.error
+    async def purge_error(self, ctx: commands.Context, error: Exception):
+        if isinstance(error, commands.MissingPermissions):
+            await ctx.send("You lack the manage_messages permission.")
+
+    @kick.error
+    async def kick_error(self, ctx: commands.Context, error: Exception):
+        if isinstance(error, commands.MissingPermissions):
+            await ctx.send("You lack the kick_members permission.")
+
+
+async def setup(bot: commands.Bot):
+    await bot.add_cog(Moderation(bot))

cogs/roleplay.py

@@ -0,0 +1,65 @@
+import discord
+from discord.ext import commands
+import aiohttp
+
+bot_embed_color = 0x4548A8
+
+
+class Roleplay(commands.Cog):
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    async def _fetch_waifu(self, endpoint: str) -> str | None:
+        """Fetch an image URL from waifu.pics for the given endpoint."""
+        url = f"https://api.waifu.pics/sfw/{endpoint}"
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, timeout=10) as resp:
+                    if resp.status != 200:
+                        return None
+                    data = await resp.json()
+                    return data.get("url")
+        except Exception:
+            return None
+
+    @commands.hybrid_command(name="pat", aliases=["patting"])
+    async def pat(self, ctx: commands.Context, mentioned_member: discord.Member):
+        """Pat someone"""
+        image_url = await self._fetch_waifu("pat")
+        em = discord.Embed(
+            description=f"**{ctx.author.mention} _pats_ {mentioned_member.mention}**",
+            color=bot_embed_color,
+        )
+        if image_url:
+            em.set_image(url=image_url)
+        await ctx.reply(embed=em)
+
+    @commands.hybrid_command(name="kiss", aliases=["kissing", "kisss"])
+    async def kiss(self, ctx: commands.Context, mentioned_member: discord.Member):
+        """Kiss someone"""
+        image_url = await self._fetch_waifu("kiss")
+        em = discord.Embed(
+            description=f"**{ctx.author.mention} _kisses_ {mentioned_member.mention}**",
+            color=bot_embed_color,
+        )
+        if image_url:
+            em.set_image(url=image_url)
+        await ctx.reply(embed=em)
+
+    @commands.hybrid_command(name="highfive", aliases=["hfive", "hfv"])
+    async def highfive(self, ctx: commands.Context, mentioned_member: discord.Member):
+        """Give someone a high five"""
+        image_url = await self._fetch_waifu("highfive")
+        if not image_url:
+            image_url = await self._fetch_waifu("hug")
+        em = discord.Embed(
+            description=f"**{ctx.author.mention} _gives a high five to_ {mentioned_member.mention}**",
+            color=bot_embed_color,
+        )
+        if image_url:
+            em.set_image(url=image_url)
+        await ctx.reply(embed=em)
+
+
+async def setup(bot: commands.Bot):
+    await bot.add_cog(Roleplay(bot))

cogs/utilities.py

@@ -0,0 +1,316 @@
+import discord
+from discord.ext import commands
+import random
+import requests
+from datetime import timedelta
+import re
+import json
+import asyncio
+import os
+from datetime import datetime
+from dateutil.relativedelta import relativedelta
+import bs4
+import wikipedia
+import html
+import aiohttp
+from cogs.functions import *
+bot_embed_color = 0x4548a8
+
+with open('config.json') as f:
+    config = json.load(f)
+
+UNITS = {'s':'seconds', 'm':'minutes', 'h':'hours', 'd':'days', 'w':'weeks'}
+
+def convert_to_seconds(s):
+    return int(timedelta(**{
+        UNITS.get(m.group('unit').lower(), 'seconds'): float(m.group('val'))
+        for m in re.finditer(r'(?P<val>\d+(\.\d+)?)(?P<unit>[smhdw]?)', s, flags=re.I)
+    }).total_seconds())
+
+extreme_ip_api_key = os.getenv('EXTREME_IP_API_KEY')
+timezone_api_key = os.getenv('TIMEZONE_API_KEY')
+edamam_api_recipe_app_id = os.getenv('EDAMAM_API_RECIPE_APP_ID')
+edamam_api_recipe_app_key = os.getenv('EDAMAM_API_RECIPE_APP_KEY')
+
+class Utilities(commands.Cog):
+
+  def __init__(self, bot):
+    self.bot = bot
+
+  @commands.hybrid_command()
+  async def ping(self, ctx):
+      """Check the bot's latency"""
+      latency = round(self.bot.latency * 1000)
+      embed = discord.Embed(
+          title="🏓 Pong!",
+          description=f"Latency: `{latency}ms`",
+          color=bot_embed_color
+      )
+      await ctx.reply(embed=embed)
+
+  @commands.hybrid_command(aliases=['ethereum'])
+  async def eth(self, ctx):
+      """Get current Ethereum price"""
+      r = requests.get('https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD,EUR')
+      r = r.json()
+      usd = r['USD']
+      eur = r['EUR']
+      em = discord.Embed(description=f'USD: `{str(usd)}$`\nEUR: `{str(eur)}€`')
+      em.set_author(name='Ethereum', icon_url='https://cdn.disnakeapp.com/attachments/271256875205525504/374282740218200064/2000px-Ethereum_logo.png')
+      await ctx.reply(embed=em)
+
+
+
+  @commands.hybrid_command(aliases=['bitcoin'])
+  async def btc(self, ctx):
+      """Get current Bitcoin price"""
+      r = requests.get('https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD,EUR')
+      r = r.json()
+      usd = r['USD']
+      eur = r['EUR']
+      em = discord.Embed(description=f'USD: `{str(usd)}$`\nEUR: `{str(eur)}€`')
+      em.set_author(name='Bitcoin', icon_url='https://cdn.discordapp.com/attachments/271256875205525504/374282740218200064/2000px-Ethereum_logo.png')
+      await ctx.reply(embed=em)
+
+
+  @commands.hybrid_command()
+  async def pingweb(self, ctx, website: str):
+      """Check if a website is up"""
+      if website is None: 
+          embed=discord.Embed(title="Error!", description="You didn't enter a website to ping for ;-;", color=0x243e7b)
+          await ctx.send(embed=embed)
+      else:
+          try:
+              r = requests.get(website).status_code
+          except Exception as e:
+              await ctx.send(f'''Error raised :- ```{e}```''')
+          if r == 404:
+              await ctx.send(f'Site is down, responded with a status code of {r}')
+          else:
+              await ctx.send(f'Site is up, responded with a status code of {r}')
+
+
+  @commands.hybrid_command(aliases=['pfp', 'avatar'])
+  async def av(self, ctx, *, user: discord.Member):
+      """Get a user's avatar""" 
+      av = user.display_avatar.url
+      embed = discord.Embed(title="{}'s pfp".format(user.name), description="Here it is!", color=bot_embed_color)
+      embed.set_image(url=av)
+      await ctx.send(embed=embed)
+
+
+  @commands.hybrid_command(aliases=['server', 'serverinfo'])
+  async def sinfo(self, ctx):
+      """Get server information"""
+      embed = discord.Embed(title=f"{ctx.guild.name}", description="Here is the server info :-", color=bot_embed_color)
+      embed.add_field(name="Server created at", value=f"{ctx.guild.created_at}")
+      embed.add_field(name="Server Owner", value=f"{ctx.guild.owner}")
+      embed.add_field(name="Member Count", value=f"{ctx.guild.member_count}")
+      embed.add_field(name="Server ID", value=f"{ctx.guild.id}")
+      embed.set_thumbnail(url=ctx.guild.icon.url if ctx.guild.icon else None)
+      await ctx.reply(embed=embed)
+
+  @commands.hybrid_command(aliases = ["timezone", "timing"])
+  async def time(self, ctx, * , location: str):
+    """Get current time for a location"""
+    details = location.replace(" ", "+")
+    r = requests.get(f"https://timezone.abstractapi.com/v1/current_time/?api_key={timezone_api_key}&location={details}")
+    res = r.json()
+    timezone_location = str(res['timezone_location'])
+    raw_time = str(res['datetime'])
+    datetime_time = datetime.strptime(raw_time, "%Y-%m-%d %H:%M:%S")
+    time = str(datetime_time.strftime("%I:%M %p"))
+    date = str(datetime_time.strftime("%d %B %Y"))
+    embedVar = discord.Embed(title=f"Time in {location} is {time}", description=f'''{date}\nTimezone - {timezone_location}''', color=bot_embed_color)
+    embedVar.set_thumbnail(url="https://i.pinimg.com/originals/26/be/b0/26beb09153b8df233d82e66bef3edfbb.jpg")
+    await ctx.reply(embed=embedVar)
+
+  @commands.hybrid_command()
+  async def recipe(self, ctx, *, food_name: str):
+    """Search for a recipe"""
+    food = food_name.replace(" ", "+")
+    api_url = f"https://api.edamam.com/api/recipes/v2?type=public&q={food}&app_id={edamam_api_recipe_app_id}&app_key={edamam_api_recipe_app_key}"
+    async with aiohttp.ClientSession() as session:
+        async with session.get(api_url) as resp:
+            res = await resp.json()
+    ing = res['hits'][0]['recipe']['ingredients']
+    naam = res["hits"][0]["recipe"]["label"]
+    url = res["hits"][0]["recipe"]["url"]
+    image = res["hits"][0]["recipe"]["image"]
+    inge = ""
+    for ingredient in ing:
+        inge += f"{ingredient['text']}\n-------\n"
+    embed = discord.Embed(title=naam, url=url, description=inge, color=bot_embed_color)
+    embed.set_thumbnail(url=image)
+    await ctx.reply(embed=embed)
+
+
+  @commands.hybrid_command(aliases=['geolocate', 'iptogeo', 'iptolocation', 'ip2geo', 'ip'])
+  async def geoip(self, ctx, *, ipaddr: str = '1.3.3.7'):
+      """Get geolocation info for an IP address""" 
+      r = requests.get(f'http://extreme-ip-lookup.com/json/{ipaddr}?key={extreme_ip_api_key}')
+      geo = r.json()
+      em = discord.Embed()
+      fields = [
+          {'name': 'IP', 'value': geo['query']},
+          {'name': 'ipType', 'value': geo['ipType']},
+          {'name': 'Country', 'value': geo['country']},
+          {'name': 'City', 'value': geo['city']},
+          {'name': 'Continent', 'value': geo['continent']},
+          {'name': 'Country', 'value': geo['country']},
+          {'name': 'IPName', 'value': geo['ipName']},
+          {'name': 'ISP', 'value': geo['isp']},
+          {'name': 'Latitute', 'value': geo['lat']},
+          {'name': 'Longitude', 'value': geo['lon']},
+          {'name': 'Org', 'value': geo['org']},
+          {'name': 'Region', 'value': geo['region']},
+          {'name': 'Status', 'value': geo['status']},
+      ]
+      for field in fields:
+          if field['value']:
+              em.add_field(name=field['name'], value=field['value'], inline=True)
+      return await ctx.send(embed=em)
+
+  @commands.hybrid_command(aliases=['wikiped', 'wikipedia'])
+  async def wiki(self, ctx, *, query: str):
+      """Search Wikipedia"""
+      global wikipedia_language
+      wikipedia_language = "en"
+      try:
+          page=wikipedia.page(wikipedia.search(query)[0])
+      except wikipedia.exceptions.DisambiguationError as e:
+          counter=0
+          while page is None:
+              try:
+                  page=wikipedia.page(e.options[counter])
+              except:
+                  counter+=1
+      except IndexError as e:
+          await ctx.send(languages[guild_language.setdefault(str(ctx.guild.id), "en")]["wikipedia_page_error"])
+          print(e)
+          return
+      summary=page.summary.split("\n")[0]
+      if len(summary)>2048:
+          summary=summary[:2045]+"..."
+      embed=discord.Embed(colour=0xfefefe,
+                          title=page.title,
+                          description=summary,
+                          url=page.url,)
+      embed.set_author(name="Wikipedia",
+                      icon_url="https://upload.wikimedia.org/wikipedia/commons/d/de/Wikipedia_Logo_1.0.png",
+                      url="https://www.wikipedia.org/")
+      if page.images:
+          embed.set_thumbnail(url=page.images[0])
+      await ctx.send(embed=embed)
+
+  @commands.hybrid_command()
+  async def truth(self, ctx, rating: str = None):
+    """Get a truth question (ratings: pg, pg13, r)"""
+    if rating is None:
+      r = requests.get(f"https://api.truthordarebot.xyz/api/truth")
+      res = r.json()
+      Tile = f"Here is a truth for you"
+      Desc = res['question']
+      embed=discord.Embed(title=Tile, description=Desc, color=bot_embed_color)
+      await ctx.reply(embed=embed)
+    else:
+      try: 
+        r = requests.get(f"https://api.truthordarebot.xyz/api/truth/?rating={rating}")
+        res = r.json()
+        Tile = f"Here is a {rating} rated question for you"
+        Desc = res['question']
+        embed=discord.Embed(title=Tile, description=Desc, color=bot_embed_color)
+        await ctx.reply(embed=embed)
+      except:
+        await ctx.reply("Please send a valid rating!! Valid parameters are `pg`,`pg13`,`r`")
+
+
+  @commands.hybrid_command()
+  async def question(self, ctx):
+    """Get a random trivia question"""
+    r = requests.get('https://opentdb.com/api.php?amount=1')
+    res = json.loads(r.text)
+    question1 = res['results'][0]['question']
+    question = html.unescape(question1)
+    correct_answer = res['results'][0]['correct_answer']
+    category = res['results'][0]['category']
+    difficulty = res['results'][0]['difficulty']
+    em = discord.Embed(title=category, description=question,colour=bot_embed_color)
+    em.add_field(name="Correct Answer :-", value=f"||{correct_answer}||")
+    em.set_footer(text=f"Difficulty : {difficulty}")
+    await ctx.reply(embed=em)
+
+
+  @commands.hybrid_command()
+  async def dare(self, ctx, rating: str = None):
+    """Get a dare (ratings: pg, pg13, r)"""
+    if rating is None:
+      r = requests.get(f"https://api.truthordarebot.xyz/api/dare")
+      res = r.json()
+      Tile = f"Here is a dare for you"
+      Desc = res['question']
+      embed=discord.Embed(title=Tile, description=Desc, color=bot_embed_color)
+      await ctx.reply(embed=embed)
+    else:
+      try: 
+        r = requests.get(f"https://api.truthordarebot.xyz/api/dare/?rating={rating}")
+        res = r.json()
+        Tile = f"Here is a {rating} rated question for you"
+        Desc = res['question']
+        embed=discord.Embed(title=Tile, description=Desc, color=bot_embed_color)
+        await ctx.reply(embed=embed)
+      except:
+        await ctx.reply("Please send a valid rating!! Valid parameters are `pg`,`pg13`,`r`")
+
+  @commands.hybrid_command()
+  async def pypi(self, ctx, package: str):
+    """Search for a Python package on PyPI"""
+    r = requests.get(f"https://pypi.org/pypi/{package}/json")
+    try:
+        res = r.json()
+        author = res['info']['author']
+        embed = discord.Embed(title=res['info']['name'], url = f"https://pypi.org/project/{package}/", description=f"{res['info']['summary']}\n\n\n", color=bot_embed_color)
+        embed.set_author(name="PyPI", url="https://pypi.org/", icon_url="https://thumbs.dreamstime.com/b/python-icon-filled-python-icon-website-design-mobile-app-development-python-icon-filled-development-collection-155362649.jpg")
+        embed.add_field(name="More Details :- \n\n", value=res['info']['home_page'], inline=False)
+        embed.set_thumbnail(url=f"https://pypi.org/static/images/twitter.6fecba6f.jpg")
+        await ctx.reply(embed=embed)
+    except:
+        embed = discord.Embed(title="Package Not Found!", description="Please check the spelling of the package name and try again!", color=bot_embed_color)
+        await ctx.reply(embed=embed)
+
+  @commands.hybrid_command()
+  async def remind(self, ctx, time: str = None, *, reminder: str = None):
+    """Set a reminder"""
+    time = convert_to_seconds(s=time)
+    if time > 0:
+      embedVar = discord.Embed(title=f"Reminding in {time} seconds!", description=f"Reason: {reminder}", color=bot_embed_color)
+      await ctx.reply(embed=embedVar)
+      await asyncio.sleep(time)
+      embed = discord.Embed(title=f"Reminder!", description=f"Reason: {reminder}", color=bot_embed_color)
+      await ctx.reply(f"{ctx.author.mention}", embed=embed)
+    else:
+      embed = discord.Embed(title="Invalid Time!", description="Please enter a valid time!", color=bot_embed_color)
+      await ctx.reply(embed=embed)
+  
+
+  @commands.hybrid_command(aliases=['gni', 'gno', 'recognise', 'recognize'])
+  async def musicrecognise(self, ctx, *, musicurl: str = None):
+      """Recognize a song from audio file or URL"""
+      if musicurl is None:
+        if not ctx.message.attachments:
+          await ctx.reply("Please provide a music file or a link to a music file!")
+          return
+        attachment = ctx.message.attachments[0]
+        musicurl = attachment.url
+
+      await download_mp3(musicurl)
+        
+      data = await music_recognition("./assets/audio.mp3")
+      em = discord.Embed(title=data['songname'], url=data['yturl'], color=bot_embed_color)
+      em.description = data['artist']
+      em.set_thumbnail(url=data['thumbnail'])
+      await ctx.reply(embed=em)
+     
+
+async def setup(bot):
+  await bot.add_cog(Utilities(bot))

config.json

@@ -0,0 +1,7 @@
+{
+    "prefix": "lu",
+    "embed_color": "0x4548a8",
+    "stream_url": "https://www.twitch.tv/lonelyguy523",
+    "tts_language": "en",
+    "common_footer": "Send me a hello in DMs"
+}

keep_alive.py

@@ -0,0 +1,20 @@
+from flask import Flask
+from threading import Thread
+
+app = Flask(__name__)
+
+@app.route('/')
+def home():
+    return "Bot is alive!"
+
+@app.route('/health')
+def health():
+    return {"status": "healthy", "bot": "Chitanda V2"}
+
+def run():
+    app.run(host='0.0.0.0', port=7860)
+
+def keep_alive():
+    t = Thread(target=run)
+    t.daemon = True
+    t.start()

main.py

@@ -0,0 +1,97 @@
+import os
+import pathlib
+import discord
+from discord.ext import commands
+import json
+import asyncio
+import traceback
+from keep_alive import keep_alive
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except Exception:
+    pass
+
+
+with open('config.json') as f:
+    config = json.load(f)
+
+TOKEN = os.getenv("DISCORD_TOKEN")
+PREFIX = config.get("prefix", "!")
+
+intents = discord.Intents.all()
+intents.message_content = True 
+bot = commands.Bot(
+    command_prefix=PREFIX,
+    intents=intents,
+    case_insensitive=True,
+    strip_after_prefix = True,
+)
+
+
+@bot.event
+async def on_ready():
+    print(f"Logged in as {bot.user} (ID: {bot.user.id})")
+    try:
+        synced = await bot.tree.sync()
+        print(f"Synced {len(synced)} slash command(s)")
+    except Exception as e:
+        print(f"Failed to sync commands: {e}")
+
+
+@bot.event
+async def on_command_error(ctx: commands.Context, error: commands.CommandError):
+    error = getattr(error, 'original', error)
+    
+    error_msg = ''.join(traceback.format_exception(type(error), error, error.__traceback__))
+    
+    if len(error_msg) > 1000:
+        error_msg = error_msg[-1000:]
+        error_msg = "..." + error_msg
+    
+    embed = discord.Embed(
+        title="❌ Error Log",
+        description=f"An error occurred while executing the command.",
+        color=0xff0000
+    )
+    
+    embed.add_field(
+        name="Error Details",
+        value=f"```py\n{error_msg}\n```",
+        inline=False
+    )
+    
+    embed.set_footer(text=f"Command: {ctx.command.name if ctx.command else 'Unknown'}")
+    
+    try:
+        await ctx.send(embed=embed)
+    except:
+        await ctx.send(f"```py\n{error_msg}\n```")
+
+
+async def load_cogs():
+    cogs_dir = pathlib.Path(__file__).parent / "cogs"
+    for file in cogs_dir.glob("*.py"):
+        if file.stem.startswith("_"):
+            continue
+        ext = f"cogs.{file.stem}"
+        try:
+            await bot.load_extension(ext)
+            print(f"Loaded extension: {ext}")
+        except Exception as e:
+            print(f"Failed to load {ext}: {e}")
+
+
+async def main():
+    keep_alive()
+    try:
+        await bot.load_extension('jishaku')
+        print("Loaded extension: jishaku")
+    except Exception as e:
+        print(f"Failed to load jishaku: {e}")
+    await load_cogs()
+    await bot.start(TOKEN)
+
+if __name__ == "__main__":
+    asyncio.run(main())

requirements.txt

@@ -0,0 +1,10 @@
+discord.py>=2.3.2
+python-dotenv>=1.0.1
+jishaku
+requests
+wikipedia
+python-dateutil
+beautifulsoup4
+shazamio
+flask
+aiohttp