discord.errors.PrivilegedIntentsRequired: Shard ID None is requesting privileged intents that have not been explicitly enabled in the developer portal. It is recommended to go to https://discord.com/developers/applications/ and explicitly enable the privileged intents within your application's page. If this is not possible, then consider disabling the privileged intents instead.

pip install discord.py

import discord
from discord.ext import commands

# 봇의 접두사 설정 (명령어 앞에 사용할 문자열)
intents = discord.Intents.default()
intents.messages = True # 메시지 접근 권한
intents.message_content = True  # 메시지 내용 접근 권한
intents.members = True # 멤버 정보 접근 권한
bot = commands.Bot(command_prefix='/', intents=intents)

# 봇이 준비되었을 때 실행되는 이벤트
@bot.event
async def on_ready() -> None:
    print(f'봇이 실행되었습니다. 이름: {bot.user}')

# 메시지 명령어 처리
@bot.command()
async def hello(ctx) -> None:
    await ctx.send(f'안녕하세요, {ctx.author.name}님!')

# 에코 기능 (입력한 메시지를 그대로 반환)
@bot.command()
async def echo(ctx, *, content: str) -> None:
    await ctx.send(content)

# 봇 실행
bot.run('YOUR_BOT_TOKEN')

project/
│
├── bot.py           # 메인 봇 실행 파일
├── cogs/            # 기능별 Cog 모듈 폴더
│   ├── __init__.py  # 패키지 초기화 파일 (비워둬도 됨)
│   ├── general.py   # 일반 명령어를 관리하는 Cog
│   └── ...          # 다른 기능별 Cog 파일 추가 가능
└── requirements.txt # 설치할 패키지 리스트 (선택사항)

import discord
from discord.ext import commands

class General(commands.Cog):
    def __init__(self, bot) -> None:
        self.bot = bot

    # General Cog 실행
    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print("General is going ...")

    # hello 명령어
    @commands.command()
    async def hello(self, ctx) -> None:
        await ctx.send(f'안녕하세요, {ctx.author.name}님!')

    # echo 명령어
    @commands.command()
    async def echo(self, ctx, *, content: str) -> None:
        await ctx.send(content)

# Cog를 등록하는 함수
async def setup(bot) -> None:
    await bot.add_cog(General(bot))

import os
import discord
import sys
import asyncio
from discord.ext import commands

# 봇의 접두사 설정 (명령어 앞에 사용할 문자열)
intents = discord.Intents.default()
intents.messages = True
intents.message_content = True  # 메시지 내용 접근 권한
bot: commands.Bot = commands.Bot(command_prefix="/", intents=intents)

# 봇 준비 이벤트
@bot.event
async def on_ready() -> None:
    print(f"봇이 실행되었음: {bot.user}")

# Cog 로드 함수
async def load_cogs() -> None:
    if not os.path.exists("./cogs"):
        print(f"cogs/ 디렉토리가 존재하지 않습니다!")
        sys.exit()

    for filename in os.listdir("./cogs"):
        if filename.endswith(".py"):
            no_ext_filename, ext = os.path.splitext(filename)
            await bot.load_extension(
                name=f"cogs.{no_ext_filename}"
            )  # 확장자 제외하고 로드

# 토큰 지정
_TOKEN: str = ""

# 봇 실행
async def main() -> None:
    async with bot:
        await load_cogs()  # cog 로드
        await bot.start(token=_TOKEN)

if __name__ == "__main__":
    # 비동기 메인 실행
    asyncio.run(main=main())

import discord
from discord.ext import commands
from discord import app_commands

class SlashCommand(commands.Cog):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

    @app_commands.command(
        name="sayhello", description="사용자에게 인사를 건네는 명령어입니다!"
    )
    async def say_hello(self, interaction: discord.Interaction):
        await interaction.response.send_message(f"Hello, {interaction.user.name}!")

# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(SlashCommand(bot=bot))

import discord
from discord.ext import commands
from discord import app_commands

class SlashCommand(commands.Cog):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__()
        self.bot = bot
        self.channel_id: int = 000000 # 명령어 사용이 가능한 채널의 채널 ID 입력

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

    @app_commands.command(
        name="sayhello", description="사용자에게 인사를 건네는 명령어입니다!"
    )
    async def say_hello(self, interaction: discord.Interaction):
        # 특정 채널인지 확인
        if interaction.channel.id != self.channel_id:
            await interaction.response.send_message(f"이 명령어는 <#{self.channel_id}> 채널에서만 사용 가능합니다!")
            return
        await interaction.response.send_message(f"Hello, {interaction.user.name}!")

# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(SlashCommand(bot=bot))

import discord
from discord.ext import commands
from discord import app_commands

class SlashCommand(commands.Cog):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

    @app_commands.command(
        name="sayhello", description="사용자에게 인사를 건네는 명령어입니다!"
    )
    async def say_hello(self, interaction: discord.Interaction):
        # 어드민 권한 확인
        if not interaction.user.guild_permissions.administrator:
            await interaction.response.send_message(f"{interaction.user.name} 님은 이 명령어를 사용할 권한이 없습니다!")
            return
        await interaction.response.send_message(f"Hello, {interaction.user.name}!")

# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(SlashCommand(bot=bot))

import discord
from discord.ext import commands
from discord import app_commands

class SlashCommand(commands.Cog):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

    @app_commands.command(
        name="sayhello", description="사용자에게 인사를 건네는 명령어입니다!"
    )
    @app_commands.describe(content="공지할 점검 내용을 입력하세요.")
    async def say_hello(self, interaction: discord.Interaction, content: str):
        # 어드민 권한 확인
        if not interaction.user.guild_permissions.administrator:
            await interaction.response.send_message(f"{interaction.user.name} 님은 이 명령어를 사용할 권한이 없습니다!")
            return
        await interaction.response.send_message(f"Hello, {interaction.user.name}!\nyour content is: {content}")

# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(SlashCommand(bot=bot))

...
# 봇 준비 이벤트
@bot.event
async def on_ready() -> None:
    print(f"봇이 실행되었음: {bot.user}")
    await bot.tree.sync()  # tree 동기화
...

import discord
from discord.ext import commands
from discord import app_commands

class EmbedCommand(commands.Cog):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

    @app_commands.command(
        name="embed", description="embed를 테스트하기 위한 명령어입니다."
    )
    async def pretty_embed(self, interaction: discord.Interaction):
        embed = discord.Embed(
            title="봇 정보",
            description="이 봇은 다양한 기능을 제공합니다",
            color=discord.Color.blue(),
        )
        embed.add_field(name="버전", value="1.0", inline=True)
        embed.add_field(name="개발자", value="Jaehyo Lee", inline=True)
        embed.set_footer(text="이 메시지는 임베드로 작성되었습니다")
        await interaction.response.send_message(embed=embed)


# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(EmbedCommand(bot=bot))

import discord
from discord.ext import commands, tasks
from discord import app_commands


class TaskCommand(commands.Cog):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__()
        self.bot = bot
        self.test_task.start()  # task 시작

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

    @tasks.loop(seconds=10)
    async def test_task(self) -> None:
        channel_id: int = 0
        channel = self.bot.get_channel(channel_id)
        if channel:
            await channel.send("10초마다 실행되는 작업이에요~")

    @test_task.before_loop
    async def before_test_task(self) -> None:
        await self.bot.wait_until_ready()


# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(TaskCommand(bot=bot))

# 봇 준비 이벤트
@bot.event
async def on_ready() -> None:
    ...
    activity = discord.Game(name="게임") # 또는 discord.Activity(type=discord.ActivityType.watching, name="YouTube")
    await bot.change_presence(status=discord.Status.online, activity=activity)

import discord
from discord.ext import commands
from discord import app_commands, ButtonStyle
from discord.ui import Button, View


class ButtonView(View):
    def __init__(self) -> None:
        super().__init__()

    @discord.ui.button(label="button1", style=ButtonStyle.green, custom_id="button1")
    async def button_callback1(
        self, interaction: discord.Interaction, button: discord.ui.Button
    ) -> None:
        button.callback = self.button_callback1
        await interaction.response.send_message(content="버튼1 클릭됨")

    @discord.ui.button(label="button2", style=ButtonStyle.green, custom_id="button2")
    async def button_callback2(
        self, interaction: discord.Interaction, button: discord.ui.Button
    ) -> None:
        button.callback = self.button_callback2
        await interaction.response.send_message(content="버튼2 클릭됨")


class ButtonSet(commands.Cog):
    def __init__(self, bot: commands.Bot):
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

        channel_id: int = 0
        channel = self.bot.get_channel(channel_id)
        if channel:
            await channel.send("버튼을 클릭해보세요.", view=ButtonView())


# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(ButtonSet(bot=bot))

import discord
from discord.ui import Modal, TextInput
from discord.ext import commands
from discord import app_commands


class MyModal(Modal):
    def __init__(self) -> None:
        super().__init__(title="Form Test")
        self.name = TextInput(label="이름", placeholder="당신의 이름을 입력하시오.")
        self.age = TextInput(label="나이", placeholder="당신의 나이를 입력하시오.")
        self.add_item(self.name)
        self.add_item(self.age)

    async def on_submit(self, interaction: discord.Interaction) -> None:
        await interaction.response.send_message(
            f"이름: {self.name.value}, 나이: {self.age.value}"
        )

class FormCommand(commands.Cog):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

    @app_commands.command(
        name="form", description="Form를 테스트하기 위한 명령어입니다."
    )
    async def test_form(self, interaction: discord.Interaction):
        await interaction.response.send_modal(MyModal())


# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(FormCommand(bot=bot))

....
class MyModal(Modal):
    def __init__(self) -> None:
        super().__init__(title="Form Test")
        self.name = TextInput(label="이름", placeholder="당신의 이름을 입력하시오.", style=discord.TextStyle.paragraph)
        self.age = TextInput(label="나이", placeholder="당신의 나이를 입력하시오.", style=discord.TextStyle.paragraph)
        self.add_item(self.name)
        self.add_item(self.age)
....

@discord.app_commands.command(name="secret")
async def secret_message(interaction: discord.Interaction):
    await interaction.response.send_message("이 메시지는 당신에게만 보입니다.", ephemeral=True)

@commands.command(name="tempmsg")
async def temp_message(ctx):
    await ctx.send("이 메시지는 5초 후에 삭제됩니다.", delete_after=5)

class Button(commands.Cog):
    def __init__(self, bot: commands.Bot):
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")
        channel_id: int = 0

        # 체널 가져오기
        channel = self.bot.get_channel(channel_id)

        # 채널 메시지 전송하기
        if channel:
            # 채널의 최근 메시지 삭제하기
            try:
                async for message in channel.history(limit=3):
                    await message.delete()
            except discord.Forbidden:
                print("Bot lacks permission to delete message.")
            except discord.HTTPException as e:
                print(f"Failed to delete message: {e}")

            # 메시지 전송
            await channel.send("거래소 관련 채널입니다.", view=MarketButtonView())
        else:
            print(f"{self.__class__.__name__}: Channel Error")

# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(Button(bot=bot))

import discord
from discord.ext import commands
from discord import app_commands

class SlashCommand(commands.Cog):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"{self.__class__.__name__} Cog is ready.")

    @app_commands.command(
        name="longtask", description="defer 테스트를 위한 명령어입니다."
    )
    async def long_task(self, interaction: discord.Interaction):
        # 응답 지연
        await interaction.response.defer()

        # 시간이 걸리는 작업 수행
        import time
        time.sleep(5)

        # 최종 결과 응답
        await interaction.followup.send("작업 완료!")

# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(SlashCommand(bot=bot))

import discord
from discord.ext import commands

class General(commands.Cog):
    def __init__(self, bot) -> None:
        self.bot = bot

    # ctx 매개변수 타입 확인을 위해 /hello 입력 시 타입이 출력되도록 코드 수정
    @commands.command()
    async def hello(self, ctx) -> None:
        print(f"ctx -> {type(ctx)})

    # echo 명령어
    @commands.command()
    async def echo(self, ctx, *, content: str) -> None:
        await ctx.send(content)

# Cog를 등록하는 함수
async def setup(bot) -> None:
    await bot.add_cog(General(bot))

봇이 실행되었음: DevBot#0737
General is going ...
<discord.ext.commands.context.Context object at 0x000001D175995040> # 출력된 ctx 매개변수의 타입

import discord
from discord.ext import commands


class General(commands.Cog):
    ...
    @commands.command()
    async def hello(self, ctx: commands.Context) -> None:
        ctx.send(f"안녕하세요, {ctx.author.name}님!")
    ...

import os
import discord
import sys
import asyncio
from discord.ext import commands
from dotenv import load_dotenv

# 봇의 접두사 설정 (명령어 앞에 사용할 문자열)
intents = discord.Intents.default()
intents.messages = True
intents.message_content = True  # 메시지 내용 접근 권한
bot: commands.Bot = commands.Bot(command_prefix="/", intents=intents)


# 봇 준비 이벤트
@bot.event
async def on_ready() -> None:
    activity = discord.Activity(type=discord.ActivityType.playing, name="Game")
    await bot.change_presence(status=discord.Status.online, activity=activity)
    await bot.tree.sync()  # tree 동기화


# Cog 로드 함수
async def load_cogs() -> None:
    for filename in os.listdir("./cogs"):
        if filename.endswith(".py"):
            no_ext_filename, ext = os.path.splitext(filename)
            await bot.load_extension(
                name=f"cogs.{no_ext_filename}"
            )  # 확장자 제외하고 로드


# 봇 실행
load_dotenv(dotenv_path=".env")
_TOKEN: str = os.getenv("TOKEN")


async def main() -> None:
    async with bot:
        await load_cogs()  # cog 로드
        await bot.start(token=_TOKEN)


if __name__ == "__main__":
    # 비동기 메인 실행
    asyncio.run(main=main())

class TicketView(View):
    def __init__(self, bot: commands.Bot) -> None:
        super().__init__(timeout=None)  # 타임아웃 제거
        self.bot = bot
        
    @discord.ui.button(
        label="문의하기", style=ButtonStyle.blurple, custom_id="create_ticket"
    )
    async def create_ticket(
        self,
        interaction: discord.Interaction,
        button: discord.ui.Button,
    ) -> None:
        guild = interaction.guild
        user = interaction.user
        
        # 카테고리 추출
        category = discord.utils.get(guild.categories, name="고객센터")
        
        # 카테고리가 없는 경우 새롭게 생성
        if not category:
            category = await guild.create_category("고객센터")
            
        # 카테고리에 있는 채널 목록 추출
        for category_channel in category.channels:
            # 요청 유저에 대한 티켓이 생성되었는지 분기 작성
            check_ticket_channel = f"문의-{user.name}"
            if check_ticket_channel == category_channel.name:
                await interaction.response.send_message("이미 티켓이 열려 있습니다!", ephemeral=True)
                return 
        
        # 티켓 채널 생성
        overwirtes = {
            guild.default_role: discord.PermissionOverwrite(read_messages=False),
            user: discord.PermissionOverwrite(read_messages=True, send_messages=True),
        }
        channel = await guild.create_text_channel(
            name=f"문의-{user.name}", category=category, overwrites=overwirtes
        )

        # 티켓 생성 문구 사용자에게 출력해주기
        await interaction.response.send_message(
            f"티켓이 생성되었습니다: {channel.mention}", ephemeral=True
        )

        # 임베드 작성하기
        problem_embed = discord.Embed(
            title=f"{user.name} 님의 Ticket이 활성화 되었습니다.",
            description=(
                f"**{user.name}님! 안녕하세요, 저희 디스코드 채널에 문의할 내용이 있으신가요?**\n\n"
            ),
        )
        
        # 임베드 메시지 생성된 채널로 전송하기
        await channel.send(embed=problem_embed)

        # 자동종료 타이머
        await self.start_inactivity_timer(channel=channel, user=user)
        await interaction.response.defer()

    async def start_inactivity_timer(
        self, channel: discord.channel.TextChannel, user: discord.member.Member
    ) -> None:
        try:
            def check(m):
                return m.channel == channel and m.author == user

            await self.bot.wait_for("message", check=check, timeout=180.0)
        except asyncio.TimeoutError:
            await channel.delete()

@bot.event
async def on_message(message):
    if message.content == "!start":
        await message.channel.send("숫자를 입력해주세요.")

        def check(msg):
            return msg.author == message.author and msg.channel == message.channel and msg.content.isdigit()

        try:
            response = await bot.wait_for("message", check=check, timeout=30.0)
            await message.channel.send(f"입력된 숫자는 {response.content}입니다.")
        except asyncio.TimeoutError:
            await message.channel.send("시간 초과되었습니다. 다시 시도해주세요.")

class Ticket(commands.Cog):
    def __init__(self, bot: commands.Bot):
        super().__init__()
        self.bot = bot

    @commands.Cog.listener()
    async def on_ready(self) -> None:
        print(f"Ticket Command is running ...")
        channel_id: int = 0000
        channel = self.bot.get_channel(channel_id)
        if channel:
            embed = discord.Embed(
                title="고객센터 안내",
                description=(
                    "- 고객센터 운영 시간은 정해져 있지 않습니다\n"
                    "- 생성된 채널은 3분 동안 아무런 문의가 없는 경우 무통보 종료됩니다.\n"
                    "- 문의와 건의가 아닌 폭언과 비아냥은 무통보 차단됩니다.\n"
                ),
                color=discord.Color.blue(),
            )
            view = TicketView(bot=self.bot)
            await channel.send(embed=embed, view=view)


# Cog 등록 함수
async def setup(bot: commands.Bot):
    await bot.add_cog(Ticket(bot=bot))

import discord
from discord.ext import commands

class MyView(discord.ui.View):
    def __init__(self, timeout=600):  # 10분 (600초)으로 설정
        super().__init__(timeout=timeout)

bot = commands.Bot(command_prefix="!")

@bot.command()
async def button(ctx):
    view = MyView()
    button = discord.ui.Button(label="클릭!", style=discord.ButtonStyle.green)

    async def button_callback(interaction):
        await interaction.response.send_message("버튼 눌렀음!")

    button.callback = button_callback
    view.add_item(button)
    await ctx.send("버튼1", view=view)

bot.run("디스코드봇토큰입력")

@bot.command()
async def persistent_button(ctx):
    view = MyView()

    async def update_view():
        while True:
            await asyncio.sleep(300)  # 5분마다 View를 새로고침
            await ctx.edit(view=MyView())

    button = discord.ui.Button(label="지속 버튼", style=discord.ButtonStyle.blurple)

    async def button_callback(interaction):
        await interaction.response.send_message("지속 버튼이 눌렸습니다!")

    button.callback = button_callback
    view.add_item(button)
    await ctx.send("이 버튼은 지속적으로 작동합니다!", view=view)

    bot.loop.create_task(update_view())

class PersistentView(discord.ui.View):
    def __init__(self):
        super().__init__(timeout=None)  # 타임아웃 없음

    @discord.ui.button(label="Persistent Button", style=discord.ButtonStyle.green, custom_id="persistent_button")
    async def persistent_button(self, button: discord.ui.Button, interaction: discord.Interaction):
        await interaction.response.send_message("이 버튼은 재시작 후에도 유지됩니다!", ephemeral=True)

@bot.event
async def on_ready():
    # 봇이 시작되면 View를 등록
    bot.add_view(PersistentView())
    print(f"Logged in as {bot.user}!")