ساخت یک ربات نظرسنجی ساده با Telebot و پایتون

مقدمه‌ای بر ربات‌های تلگرام و Telebot

در دنیای امروز که ارتباطات دیجیتال نقش محوری در زندگی ما ایفا می‌کند، تلگرام به عنوان یکی از پلتفرم‌های پیام‌رسان پیشرو، با قابلیت‌های گسترده خود، جایگاه ویژه‌ای یافته است. یکی از قدرتمندترین ویژگی‌های تلگرام، پشتیبانی از ربات‌ها است؛ برنامه‌های خودکاری که می‌توانند وظایف متنوعی از جمله ارسال پیام، بازی، ارائه اطلاعات، و البته، برگزاری نظرسنجی‌ها را انجام دهند. ربات‌های نظرسنجی ابزاری بی‌نظیر برای جمع‌آوری بازخورد، سازماندهی رای‌گیری‌ها، و سنجش افکار عمومی در گروه‌ها و کانال‌ها هستند.

برای توسعه این ربات‌ها، زبان برنامه‌نویسی پایتون به دلیل سادگی، خوانایی بالا و اکوسیستم غنی از کتابخانه‌ها، گزینه‌ای ایده‌آل محسوب می‌شود. در میان کتابخانه‌های مختلف پایتون برای تعامل با API تلگرام، PyTelegramBotAPI که معمولاً با نام مستعار Telebot شناخته می‌شود، یکی از محبوب‌ترین و کارآمدترین‌ها است. Telebot یک پوشش (wrapper) قدرتمند و آسان برای استفاده از Telegram Bot API را فراهم می‌کند که به توسعه‌دهندگان امکان می‌دهد تا با حداقل کدنویسی، ربات‌هایی با قابلیت‌های پیشرفته بسازند.

این پست آموزشی، به صورت جامع و گام به گام، شما را در فرآیند ساخت یک ربات نظرسنجی ساده با Telebot و پایتون راهنمایی می‌کند. ما از ابتدا با راه‌اندازی محیط توسعه، دریافت توکن API، و درک مفاهیم اساسی Telebot آغاز خواهیم کرد. سپس به پیاده‌سازی منطق نظرسنجی، مدیریت حالت کاربران، استفاده از کیبوردهای Inline برای گزینه‌های رای‌گیری، ذخیره‌سازی نتایج، و در نهایت نمایش آن‌ها خواهیم پرداخت. هدف ما ارائه یک راهنمای کامل و تخصصی است که نه تنها به شما کمک کند تا یک ربات نظرسنجی تلگرام کارآمد بسازید، بلکه درک عمیقی از معماری و چالش‌های توسعه ربات‌های تلگرام به شما ببخشد.

در این سفر آموزشی، ما به مفاهیمی همچون مدیریت حالت ربات (State Management)، پایداری داده‌ها (Data Persistence)، و مدیریت خطا (Error Handling) نیز خواهیم پرداخت که برای برنامه نویسی ربات‌های تلگرام مقیاس‌پذیر و قابل اعتماد ضروری هستند. آماده شوید تا با قدرتمندترین ابزارهای پایتون، ربات نظرسنجی خود را خلق کنید و آن را به دنیای تلگرام بیاورید.

پیش‌نیازها و راه‌اندازی اولیه محیط توسعه

قبل از اینکه بتوانیم شروع به ساخت ربات پایتون خود کنیم، لازم است که محیط توسعه مناسبی را فراهم آوریم. این بخش به تفصیل به پیش‌نیازها و مراحل راه‌اندازی اولیه محیط توسعه می‌پردازد.

پایتون (Python)

اولین و مهم‌ترین پیش‌نیاز، نصب پایتون است. توصیه می‌شود از نسخه‌های Python 3.8 به بالا استفاده کنید، زیرا این نسخه‌ها از قابلیت‌ها و بهینه‌سازی‌های جدیدتری بهره‌مند هستند. برای اطمینان از نصب بودن پایتون و نسخه آن، می‌توانید دستور زیر را در ترمینال یا Command Prompt خود اجرا کنید:

python --version

اگر پایتون نصب نیست، می‌توانید آن را از وب‌سایت رسمی python.org دانلود و نصب کنید. حتماً در زمان نصب، گزینه “Add Python to PATH” را انتخاب کنید تا بتوانید به راحتی از پایتون در هر مسیری از ترمینال خود استفاده کنید.

مدیر بسته pip

pip (Package Installer for Python) مدیر بسته استاندارد برای پایتون است و برای نصب کتابخانه‌های خارجی مانند Telebot ضروری است. pip معمولاً همراه با پایتون نصب می‌شود. برای بررسی نصب بودن pip:

pip --version

اگر pip نصب نبود، می‌توانید آن را با دانلود get-pip.py و اجرای python get-pip.py نصب کنید.

ایجاد محیط مجازی (Virtual Environment)

یک رویکرد بسیار حرفه‌ای و توصیه شده در توسعه پایتون، استفاده از محیط‌های مجازی است. محیط مجازی یک دایرکتوری ایزوله شده است که شامل یک نسخه از مفسر پایتون و مجموعه‌ای از بسته‌های خاص پروژه شما می‌شود. این کار از تداخل بسته‌ها بین پروژه‌های مختلف جلوگیری می‌کند. برای ساخت محیط مجازی:

1. یک پوشه برای پروژه خود ایجاد کنید و وارد آن شوید:

mkdir telegram_poll_bot
cd telegram_poll_bot

2. محیط مجازی را ایجاد کنید:

python -m venv venv

3. محیط مجازی را فعال کنید:
• در ویندوز:

.\venv\Scripts\activate

• در لینوکس/macOS:

source venv/bin/activate

پس از فعال‌سازی، نام محیط مجازی (معمولاً (venv)) در ابتدای خط فرمان شما نمایش داده می‌شود.

نصب Telebot

حالا که محیط مجازی فعال است، می‌توانیم کتابخانه Telebot را نصب کنیم. نصب Telebot بسیار ساده است:

pip install pyTelegramBotAPI

این دستور آخرین نسخه پایدار pyTelegramBotAPI را نصب می‌کند. همچنین، برای برخی قابلیت‌ها مانند درخواست‌های HTTP با طولانی‌مدت (long polling) و جلوگیری از بلاک شدن عملیات I/O، Telebot به کتابخانه‌های requests و pytz (برای مدیریت زمان) متکی است که معمولاً به صورت خودکار نصب می‌شوند، اما اگر مشکلی پیش آمد، می‌توانید آن‌ها را جداگانه نصب کنید.

ویرایشگر کد (IDE/Text Editor)

برای نوشتن کد، به یک ویرایشگر کد نیاز دارید. گزینه‌های محبوب شامل:

• VS Code: سبک، قدرتمند، و با قابلیت‌های فراوان برای پایتون.
• PyCharm: یک IDE کامل و حرفه‌ای برای توسعه پایتون.
• Sublime Text / Atom: ویرایشگرهای متن با قابلیت‌های افزونه‌پذیری خوب.

انتخاب ویرایشگر بستگی به ترجیح شخصی شما دارد. VS Code به دلیل سادگی راه‌اندازی و اکوسیستم غنی افزونه‌ها، گزینه بسیار خوبی برای اکثر توسعه‌دهندگان است.

با تکمیل این مراحل، شما محیط توسعه کاملاً آماده‌ای برای برنامه نویسی ربات تلگرام خود با پایتون و Telebot خواهید داشت. اکنون زمان آن است که به سراغ مهم‌ترین قدم، یعنی دریافت توکن API ربات برویم.

دریافت توکن API و آشنایی با BotFather

برای هر ربات تلگرام، یک توکن API منحصر به فرد لازم است که هویت ربات شما را در سرورهای تلگرام مشخص می‌کند و به آن اجازه می‌دهد تا با API تلگرام ارتباط برقرار کند. این توکن مانند کلید دسترسی به ربات شما عمل می‌کند و باید آن را محرمانه نگه دارید. فرآیند دریافت توکن API از طریق یک ربات رسمی تلگرام به نام BotFather انجام می‌شود.

BotFather چیست؟

BotFather رباتی است که توسط تلگرام توسعه یافته و برای مدیریت تمام جنبه‌های ربات‌های شما طراحی شده است. از ساخت ربات جدید گرفته تا تغییر نام، توضیحات، عکس پروفایل و البته دریافت توکن API، همه از طریق BotFather انجام می‌شود. BotFather نقش والد و مدیر تمامی ربات‌های شما را ایفا می‌کند.

مراحل دریافت توکن API:

1. یافتن BotFather:

   ابتدا تلگرام را باز کنید و در نوار جستجو عبارت “BotFather” را جستجو کنید. مطمئن شوید که ربات اصلی را انتخاب می‌کنید که یک تیک آبی کنار نامش دارد.

   لینک مستقیم: @BotFather

2. شروع مکالمه با BotFather:

   پس از ورود به چت با BotFather، دکمه “Start” را بزنید. لیستی از دستورات موجود را مشاهده خواهید کرد.

3. ایجاد یک ربات جدید:

   دستور /newbot را برای ایجاد یک ربات جدید ارسال کنید.

4. انتخاب نام برای ربات:

   BotFather از شما می‌خواهد که یک نام برای ربات خود انتخاب کنید. این نام همان چیزی است که کاربران در چت با ربات شما مشاهده می‌کنند و می‌تواند هر چیزی باشد، مثلاً “نظرسنجی‌گر پایتونی”.

   Please choose a name for your bot.

   پاسخ شما: PollMasterBot

5. انتخاب نام کاربری (Username) برای ربات:

   پس از نام، BotFather از شما می‌خواهد که یک نام کاربری برای ربات خود انتخاب کنید. این نام کاربری باید منحصر به فرد باشد و حتماً باید با کلمه “bot” به پایان برسد (مانند MyPollBot یا Poll_Wizard_Bot).

   Alright, a new bot. How are we going to call it? Please choose a username for your bot. It must end in 'bot'. For example: TetrisBot or tetris_bot.

   پاسخ شما: MySimplePollBot

6. دریافت توکن API:

   اگر نام کاربری با موفقیت ثبت شود، BotFather پیامی مشابه زیر به شما ارسال می‌کند:

   Done! Congratulations on your new bot. You will find it at t.me/MySimplePollBot. Use this token to access the HTTP API:
           
   <YOUR_API_TOKEN_HERE>
           
   For a description of the Telegram Bot API, see this page: https://core.telegram.org/bots/api

   رشته‌ای که پس از “Use this token to access the HTTP API:” نمایش داده می‌شود، همان توکن API تلگرام شماست. این توکن یک رشته طولانی و شامل اعداد و حروف است. آن را کپی کرده و در جایی امن نگه دارید.

نکات مهم در مورد توکن API:

• امنیت توکن: توکن API کلید دسترسی به ربات شماست. هر کسی که به آن دسترسی داشته باشد، می‌تواند ربات شما را کنترل کند. بنابراین، هرگز آن را به صورت عمومی به اشتراک نگذارید، در کد منبع خود آن را هاردکد نکنید (مگر در محیط‌های توسعه امن)، و به جای آن از متغیرهای محیطی یا فایل‌های پیکربندی استفاده کنید.
• بازسازی توکن: اگر توکن شما لو رفت یا به هر دلیلی نیاز به تغییر آن داشتید، می‌توانید با استفاده از دستور /revoke در BotFather، توکن قبلی را باطل و یک توکن جدید دریافت کنید.
• تنظیمات ربات: با BotFather می‌توانید تنظیمات دیگری را نیز برای ربات خود انجام دهید، از جمله:
  • /setname: تغییر نام نمایشی ربات.
  • /setdescription: تنظیم توضیحات ربات که در صفحه چت با ربات نمایش داده می‌شود.
  • /setabouttext: تنظیم متن “درباره” ربات.
  • /setuserpic: تنظیم عکس پروفایل ربات.
  • /setcommands: تعریف لیست دستورات قابل استفاده برای ربات، که با تایپ / در چت نمایش داده می‌شوند. این مورد برای بهبود تجربه کاربری ربات نظرسنجی ما بسیار مفید خواهد بود (مثلاً start - شروع ربات، create_poll - ایجاد نظرسنجی جدید).

حالا که توکن API خود را در اختیار دارید، آماده‌ایم تا آن را در کد پایتون خود استفاده کنیم و اولین ربات Telebot را بسازیم.

مبانی Telebot: ساختار کد و ارسال پیام

در این بخش، به مبانی Telebot، شامل ساختار کد یک ربات ساده و نحوه ارسال پیام به کاربران خواهیم پرداخت. این دانش، پایه و اساس توسعه ربات نظرسنجی تلگرام ما را تشکیل می‌دهد.

ساختار کلی یک ربات Telebot

هر ربات Telebot معمولاً شامل اجزای زیر است:

1. وارد کردن کتابخانه: وارد کردن telebot.
2. مقداردهی اولیه ربات: ایجاد یک نمونه از TeleBot با استفاده از توکن API.
3. هندلرها (Message Handlers): توابعی که به رویدادهای خاص (مانند دریافت پیام متنی، دستور، یا Callbacks) پاسخ می‌دهند. این توابع با دکوراتورهای @bot.message_handler() یا @bot.callback_query_handler() مشخص می‌شوند.
4. شروع پولینگ (Polling): دستوری که ربات را برای دریافت پیام‌های جدید به صورت پیوسته (Long Polling) فعال می‌کند.

بیایید با یک ربات “Echo” (پژواک) ساده شروع کنیم که هر پیامی را که دریافت می‌کند، به همان شکل به کاربر بازمی‌گرداند.

اولین ربات: ربات Echo

یک فایل با نام bot.py ایجاد کنید و کد زیر را در آن قرار دهید. حتماً 'YOUR_API_TOKEN_HERE' را با توکن API واقعی خود که از BotFather دریافت کرده‌اید، جایگزین کنید.

import telebot

# 1. مقداردهی اولیه ربات با توکن API
# توصیه می شود توکن را به جای هاردکد کردن، از متغیرهای محیطی یا فایل کانفیگ بخوانید.
# برای سادگی در این مثال، آن را مستقیم وارد می کنیم.
API_TOKEN = 'YOUR_API_TOKEN_HERE' 
bot = telebot.TeleBot(API_TOKEN)

# 2. تعریف یک هندلر برای دستور /start
@bot.message_handler(commands=['start'])
def send_welcome(message):
    """
    این تابع به دستور /start پاسخ می دهد.
    """
    bot.reply_to(message, "سلام! من ربات نظرسنجی شما هستم. چطور می توانم کمکتان کنم؟")

# 3. تعریف یک هندلر برای پیام های متنی عادی
@bot.message_handler(func=lambda message: True)
def echo_all(message):
    """
    این تابع به تمام پیام های متنی عادی پاسخ می دهد و متن پیام را باز می گرداند.
    """
    bot.reply_to(message, message.text)

# 4. شروع پولینگ
# این خط ربات را برای دریافت پیام های جدید به صورت بی نهایت اجرا می کند.
# اگر خطایی رخ دهد، ربات سعی می کند دوباره اتصال را برقرار کند.
print("ربات در حال اجرا است...")
bot.infinity_polling()

برای اجرای این کد، ترمینال را باز کنید، مطمئن شوید که در محیط مجازی فعال هستید، و دستور زیر را اجرا کنید:

python bot.py

پس از اجرای موفقیت‌آمیز، پیامی مانند “ربات در حال اجرا است…” را مشاهده خواهید کرد. حالا به تلگرام بروید، ربات خود را پیدا کنید و دستور /start را ارسال کنید. باید پیام خوش‌آمدگویی را دریافت کنید. سپس هر متن دیگری را ارسال کنید، و ربات همان متن را به شما بازمی‌گرداند.

توضیحات کد:

• import telebot: کتابخانه را وارد می‌کند.
• bot = telebot.TeleBot(API_TOKEN): یک شی TeleBot ایجاد می‌کند که برای تعامل با API تلگرام استفاده می‌شود. توکن API شما را به آن منتقل می‌کنیم.
• @bot.message_handler(commands=['start']): این یک دکوراتور است که تابع send_welcome را به عنوان هندلر برای دستور /start ثبت می‌کند. هر زمان که کاربری دستور /start را ارسال کند، این تابع اجرا می‌شود.
• @bot.message_handler(func=lambda message: True): این دکوراتور تابع echo_all را به عنوان هندلر برای تمام پیام‌هایی که توسط هندلرهای دیگر پردازش نشده‌اند، ثبت می‌کند. func=lambda message: True به این معنی است که این هندلر برای هر پیامی که به تابع شرطی (که در اینجا همیشه True است) برگردد، فعال می‌شود.
• bot.reply_to(message, "..."): این متد برای پاسخ دادن به یک پیام خاص استفاده می‌شود و پیام شما را به عنوان پاسخ به پیام کاربر ارسال می‌کند.
• bot.send_message(chat_id, "..."): این متد برای ارسال پیام به یک چت خاص (گروه، کاربر، کانال) استفاده می‌شود. chat_id شناسه منحصر به فرد چت است.
• bot.infinity_polling(): این متد ربات را در یک حلقه بی‌نهایت نگه می‌دارد تا پیام‌های جدید را از سرور تلگرام دریافت کند. این مهمترین بخش است که ربات شما را زنده نگه می‌دارد و به پیام‌ها گوش می‌دهد.

ارسال پیام‌های پیشرفته‌تر:

Telebot امکانات زیادی برای ارسال پیام‌های غنی ارائه می‌دهد:

• parse_mode: برای قالب‌بندی متن پیام (مثلاً Bold، Italic، لینک‌ها). می‌توانید از HTML یا Markdown استفاده کنید.

  bot.send_message(message.chat.id, "این یک پیام *بولد* است.", parse_mode="Markdown")
  bot.send_message(message.chat.id, "این یک پیام <b>بولد</b> است.", parse_mode="HTML")

• کیبوردها (Keyboards): برای ارائه گزینه‌های تعاملی به کاربر. دو نوع اصلی وجود دارد:
  • Reply Keyboard (کیبورد پاسخ): کیبوردی که در پایین صفحه چت نمایش داده می‌شود و دکمه‌های آن پیام‌های متنی را ارسال می‌کنند.
  • Inline Keyboard (کیبورد اینلاین): دکمه‌هایی که مستقیماً زیر پیام نمایش داده می‌شوند و با فشردن آن‌ها، یک “Callback Query” (درخواست بازخوانی) به ربات ارسال می‌شود که شامل داده‌های خاصی است. این نوع کیبورد برای نظرسنجی‌ها ایده‌آل است.

با درک این مفاهیم اولیه، شما آماده‌اید تا به سراغ طراحی منطق نظرسنجی و مدیریت حالت در ربات خود بروید، که از اجزای کلیدی برای ساخت یک ربات نظرسنجی کارآمد هستند.

طراحی منطق نظرسنجی: سوالات، گزینه‌ها و مدیریت حالت

هسته اصلی یک ربات نظرسنجی تلگرام، منطق آن برای مدیریت سوالات، گزینه‌ها و ثبت رای کاربران است. از آنجایی که فرآیند ایجاد و شرکت در نظرسنجی ممکن است چند مرحله‌ای باشد (مثلاً ابتدا سوال، سپس گزینه‌ها)، مدیریت حالت ربات (State Management) برای هر کاربر، بسیار حیاتی است. در این بخش، به طراحی منطق نظرسنجی و نحوه پیاده‌سازی مدیریت حالت با استفاده از پایتون و Telebot می‌پردازیم.

مدل‌سازی داده‌های نظرسنجی

برای شروع، باید نحوه ذخیره سازی اطلاعات مربوط به نظرسنجی را تعریف کنیم. یک نظرسنجی حداقل شامل موارد زیر است:

• poll_id: یک شناسه منحصر به فرد برای هر نظرسنجی.
• question: متن سوال نظرسنجی.
• options: لیستی از گزینه‌های قابل انتخاب برای نظرسنجی.
• votes: دیکشنری یا لیستی برای شمارش آرای هر گزینه.
• creator_id: شناسه کاربری که نظرسنجی را ایجاد کرده است.
• active: وضعیت نظرسنجی (فعال یا بسته شده).
• voted_users: مجموعه‌ای از شناسه‌های کاربرانی که قبلاً در این نظرسنجی شرکت کرده‌اند (برای جلوگیری از رای‌گیری مجدد).

برای سادگی در این مرحله، ما از دیکشنری‌های پایتون برای ذخیره‌سازی داده‌های نظرسنجی در حافظه (in-memory) استفاده خواهیم کرد. در بخش‌های بعدی به پایداری داده‌ها خواهیم پرداخت.

# یک دیکشنری برای ذخیره سازی نظرسنجی های فعال
# کلید: poll_id (یک عدد یا رشته منحصر به فرد)
# مقدار: یک دیکشنری شامل جزئیات نظرسنجی
active_polls = {}

# یک دیکشنری برای مدیریت حالت کاربران در فرآیند ایجاد نظرسنجی
# کلید: user_id
# مقدار: یک دیکشنری شامل وضعیت فعلی و داده های موقت نظرسنجی
user_states = {}

# مثال ساختار یک نظرسنجی:
# poll_id = "poll_1"
# active_polls[poll_id] = {
#     "question": "کدام زبان برنامه نویسی را ترجیح می دهید؟",
#     "options": ["پایتون", "جاوا", "جاوااسکریپت", "سی شارپ"],
#     "votes": {"پایتون": 0, "جاوا": 0, "جاوااسکریپت": 0, "سی شارپ": 0},
#     "creator_id": 123456789,
#     "active": True,
#     "voted_users": set() # مجموعه ای از user_id هایی که رای داده اند
# }

# مثال ساختار حالت کاربر:
# user_id = 123456789
# user_states[user_id] = {
#     "state": "awaiting_question", # می تواند "awaiting_options" یا "idle" باشد
#     "temp_poll_data": {} # داده های موقت برای نظرسنجی در حال ساخت
# }

مدیریت حالت کاربر (User State Management)

وقتی کاربر دستور /create_poll را ارسال می‌کند، ربات باید از او سوال نظرسنجی را بپرسد، سپس گزینه‌ها را دریافت کند. این فرآیند چند مرحله‌ای نیازمند پیگیری وضعیت هر کاربر است. Telebot قابلیت مدیریت حالت داخلی ندارد، بنابراین باید آن را خودمان پیاده‌سازی کنیم. یک روش متداول، استفاده از یک دیکشنری برای نگهداری حالت فعلی هر user_id است.

مراحل ایجاد نظرسنجی با مدیریت حالت:

1. شروع فرآیند: کاربر /create_poll را ارسال می‌کند. ربات حالت کاربر را به awaiting_question تغییر می‌دهد و از او می‌خواهد که سوال نظرسنجی را بفرستد.
2. دریافت سوال: کاربر سوال را ارسال می‌کند. ربات سوال را ذخیره کرده، حالت کاربر را به awaiting_options تغییر می‌دهد و از او می‌خواهد که گزینه‌ها را ارسال کند (مثلاً با کاما جدا شده).
3. دریافت گزینه‌ها: کاربر گزینه‌ها را ارسال می‌کند. ربات گزینه‌ها را تجزیه و ذخیره می‌کند، نظرسنجی جدید را ایجاد کرده، و حالت کاربر را به idle (بیکار) بازمی‌گرداند.

برای پیاده‌سازی این موضوع، از دکوراتورهای @bot.message_handler با یک تابع func شرطی استفاده می‌کنیم که بر اساس حالت کاربر تصمیم می‌گیرد آیا هندلر باید اجرا شود یا خیر.

import telebot
from telebot import types
import uuid # برای تولید شناسه منحصر به فرد برای نظرسنجی ها

API_TOKEN = 'YOUR_API_TOKEN_HERE'
bot = telebot.TeleBot(API_TOKEN)

# دیکشنری برای ذخیره سازی نظرسنجی ها
active_polls = {} # {poll_id: {"question": "", "options": [], "votes": {}, "creator_id": "", "active": True, "voted_users": set()}}

# دیکشنری برای مدیریت حالت کاربران
user_states = {} # {user_id: {"state": "", "temp_poll_data": {}}}

# وضعیت های ممکن
STATE_IDLE = "idle"
STATE_AWAITING_QUESTION = "awaiting_question"
STATE_AWAITING_OPTIONS = "awaiting_options"

# -------------------- هندلر دستور /start --------------------
@bot.message_handler(commands=['start'])
def send_welcome(message):
    user_states[message.from_user.id] = {"state": STATE_IDLE, "temp_poll_data": {}}
    bot.reply_to(message, "سلام! من ربات نظرسنجی شما هستم. برای ایجاد یک نظرسنجی جدید، /create_poll را ارسال کنید.")

# -------------------- هندلر دستور /create_poll --------------------
@bot.message_handler(commands=['create_poll'])
def create_poll_command(message):
    user_id = message.from_user.id
    user_states[user_id] = {"state": STATE_AWAITING_QUESTION, "temp_poll_data": {}}
    bot.send_message(user_id, "لطفا سوال نظرسنجی خود را بفرستید:")

# -------------------- هندلر دریافت سوال نظرسنجی --------------------
@bot.message_handler(func=lambda message: user_states.get(message.from_user.id, {}).get("state") == STATE_AWAITING_QUESTION)
def get_poll_question(message):
    user_id = message.from_user.id
    question = message.text

    user_states[user_id]["temp_poll_data"]["question"] = question
    user_states[user_id]["state"] = STATE_AWAITING_OPTIONS
    bot.send_message(user_id, "سوال نظرسنجی شما: " + question + "\n\n"
                               "حالا گزینه های نظرسنجی را بفرستید، هر گزینه را با کاما (,) از هم جدا کنید.")

# -------------------- هندلر دریافت گزینه های نظرسنجی --------------------
@bot.message_handler(func=lambda message: user_states.get(message.from_user.id, {}).get("state") == STATE_AWAITING_OPTIONS)
def get_poll_options(message):
    user_id = message.from_user.id
    options_text = message.text

    options = [opt.strip() for opt in options_text.split(',') if opt.strip()]
    if not options or len(options) < 2:
        bot.send_message(user_id, "لطفا حداقل دو گزینه برای نظرسنجی وارد کنید و آنها را با کاما جدا کنید.")
        return

    # ایجاد نظرسنجی جدید
    poll_id = str(uuid.uuid4()) # تولید یک شناسه منحصر به فرد
    question = user_states[user_id]["temp_poll_data"]["question"]
    
    initial_votes = {opt: 0 for opt in options}

    active_polls[poll_id] = {
        "question": question,
        "options": options,
        "votes": initial_votes,
        "creator_id": user_id,
        "active": True,
        "voted_users": set()
    }

    # بازنشانی حالت کاربر
    user_states[user_id] = {"state": STATE_IDLE, "temp_poll_data": {}}

    bot.send_message(user_id, "نظرسنجی با موفقیت ایجاد شد! "
                               "برای اشتراک گذاری آن، از دستور /publish_poll استفاده کنید و poll_id را پس از آن وارد نمایید. (مثلا: /publish_poll " + poll_id + ")")
    bot.send_message(user_id, f"شناسه نظرسنجی شما: `{poll_id}`", parse_mode="Markdown")


# -------------------- هندلر پیش فرض برای پیام هایی که در حالت idle دریافت می شوند --------------------
@bot.message_handler(func=lambda message: user_states.get(message.from_user.id, {}).get("state") == STATE_IDLE and not message.text.startswith('/'))
def handle_idle_messages(message):
    bot.reply_to(message, "من در حالت بیکار هستم. برای ایجاد نظرسنجی جدید، /create_poll را ارسال کنید.")

# شروع پولینگ
print("ربات در حال اجرا است...")
bot.infinity_polling()

توضیحات تکمیلی:

• uuid.uuid4(): از این ماژول برای تولید شناسه‌های منحصر به فرد جهانی (UUID) برای هر نظرسنجی استفاده می‌کنیم. این کار از تداخل شناسه‌ها جلوگیری می‌کند.
• user_states.get(user_id, {}).get("state"): این روش امنی برای دسترسی به حالت کاربر است. اگر user_id در user_states وجود نداشته باشد، یک دیکشنری خالی برمی‌گرداند، و سپس اگر "state" وجود نداشت، None برمی‌گرداند، که از خطاهای KeyError جلوگیری می‌کند.
• اعتبارسنجی ورودی: ما یک بررسی ساده برای اطمینان از وجود حداقل دو گزینه در نظرسنجی اضافه کرده‌ایم. در یک ربات واقعی، اعتبارسنجی ورودی باید بسیار کامل‌تر باشد.
• بازنشانی حالت: پس از تکمیل فرآیند ایجاد نظرسنجی، حالت کاربر به STATE_IDLE بازمی‌گردد تا برای تعاملات بعدی آماده باشد.

در این مرحله، ربات شما می‌تواند فرآیند ایجاد نظرسنجی را مدیریت کند. با این حال، هنوز راهی برای کاربران برای شرکت در نظرسنجی و رای‌گیری وجود ندارد. اینجاست که کیبوردهای Inline وارد عمل می‌شوند که در بخش بعدی به آن خواهیم پرداخت.

پیاده‌سازی کیبوردهای Inline برای گزینه‌های نظرسنجی

کیبوردهای Inline (InlineKeyboardMarkup) یکی از قدرتمندترین ویژگی‌های API تلگرام برای ایجاد رابط‌های کاربری تعاملی در ربات‌ها هستند. برخلاف Reply Keyboardها که پیام‌های متنی ارسال می‌کنند، Inline Keyboardها "Callback Query"ها را به ربات برمی‌گردانند که شامل داده‌های تعریف شده توسط توسعه‌دهنده هستند. این ویژگی، آن‌ها را برای ربات‌های نظرسنجی که نیاز به انتخاب یک گزینه از بین چندین گزینه دارند، ایده‌آل می‌سازد.

در این بخش، ما نحوه پیاده‌سازی کیبوردهای Inline برای گزینه‌های نظرسنجی را با Telebot یاد خواهیم گرفت و همچنین دستور /publish_poll را برای نمایش نظرسنجی به کاربران اضافه خواهیم کرد.

ساخت Inline Keyboard

telebot.types.InlineKeyboardMarkup برای ساخت کلی کیبورد و telebot.types.InlineKeyboardButton برای هر دکمه به کار می‌روند. هر دکمه نیاز به یک text (متنی که روی دکمه نمایش داده می‌شود) و یک callback_data (داده‌ای که هنگام فشار دادن دکمه به ربات ارسال می‌شود) دارد.

callback_data یک رشته است و حداکثر 64 بایت طول دارد. برای نظرسنجی ما، callback_data باید شامل poll_id و option_index یا option_text باشد تا ربات بتواند تشخیص دهد کاربر به کدام نظرسنجی و کدام گزینه رای داده است. ما از فرمت "vote_{poll_id}_{option_text}" استفاده خواهیم کرد (با رمزگذاری option_text در صورت لزوم).

دستور /publish_poll

پس از ایجاد نظرسنجی، کاربر باید بتواند آن را در یک چت یا گروه منتشر کند تا دیگران بتوانند در آن شرکت کنند. برای این کار، دستور /publish_poll <poll_id> را اضافه می‌کنیم.

# ادامه کد bot.py از بخش قبلی

# -------------------- هندلر دستور /publish_poll --------------------
@bot.message_handler(commands=['publish_poll'])
def publish_poll_command(message):
    args = message.text.split(maxsplit=1) # جدا کردن دستور از آرگومان ها
    if len(args) < 2:
        bot.reply_to(message, "لطفا شناسه نظرسنجی را پس از دستور وارد کنید. مثال: /publish_poll <poll_id>")
        return
    
    poll_id = args[1].strip()
    
    if poll_id not in active_polls:
        bot.reply_to(message, "نظرسنجی با این شناسه یافت نشد.")
        return
    
    poll = active_polls[poll_id]
    
    # ساخت Inline Keyboard
    markup = types.InlineKeyboardMarkup(row_width=1) # یک دکمه در هر سطر
    buttons = []
    for option_text in poll["options"]:
        # Callback data شامل 'vote', poll_id و گزینه انتخابی است.
        # برای سادگی، گزینه انتخابی را مستقیم در callback_data قرار می دهیم.
        # در ربات های پیچیده تر، شاید نیاز به رمزگذاری یا استفاده از ایندکس باشد.
        callback_data = f"vote_{poll_id}_{option_text}"
        button = types.InlineKeyboardButton(option_text, callback_data=callback_data)
        buttons.append(button)
    
    markup.add(*buttons) # اضافه کردن دکمه ها به markup

    question = poll["question"]
    bot.send_message(message.chat.id, f"**{question}**\n\nلطفا گزینه مورد نظر خود را انتخاب کنید:", 
                     reply_markup=markup, parse_mode="Markdown")
    bot.reply_to(message, f"نظرسنجی `{poll_id}` با موفقیت منتشر شد.", parse_mode="Markdown")

# -------------------- هندلر پیش فرض برای پیام هایی که در حالت idle دریافت می شوند --------------------
# این هندلر باید در انتهای همه هندلرهای دیگر باشد تا مطمئن شویم پیام های مهمتر ابتدا پردازش می شوند.
# @bot.message_handler(func=lambda message: user_states.get(message.from_user.id, {}).get("state") == STATE_IDLE and not message.text.startswith('/'))
# def handle_idle_messages(message):
#     bot.reply_to(message, "من در حالت بیکار هستم. برای ایجاد نظرسنجی جدید، /create_poll را ارسال کنید.")

# -------------------- هندلر کلی (در صورت نیاز) --------------------
# می توانید یک هندلر catch-all برای پیام های غیرمنتظره داشته باشید.
@bot.message_handler(func=lambda message: True)
def default_message_handler(message):
    user_id = message.from_user.id
    current_state = user_states.get(user_id, {}).get("state", STATE_IDLE)
    
    if current_state == STATE_IDLE and not message.text.startswith('/'):
        bot.reply_to(message, "من در حالت بیکار هستم. برای ایجاد نظرسنجی جدید، /create_poll را ارسال کنید."
                               "\nهمچنین می توانید با /publish_poll <poll_id> یک نظرسنجی را منتشر کنید.")
    elif current_state != STATE_IDLE:
        bot.reply_to(message, "لطفا منتظر بمانید یا دستور فعلی را دنبال کنید. یا برای شروع مجدد /start را بزنید.")

# ... bot.infinity_polling()

توضیحات و نکات:

• message.text.split(maxsplit=1): این تابع پیام را حداکثر به دو قسمت تقسیم می‌کند: دستور و بقیه متن. این کار به ما کمک می‌کند تا poll_id را به راحتی استخراج کنیم.
• types.InlineKeyboardMarkup(row_width=1): یک نمونه از Inline Keyboard ایجاد می‌کند. row_width=1 به این معنی است که هر دکمه در یک سطر جداگانه نمایش داده می‌شود. می‌توانید آن را به مقادیر دیگری (مثلاً 2 یا 3) تغییر دهید تا دکمه‌ها کنار هم قرار گیرند.
• types.InlineKeyboardButton(text, callback_data): هر دکمه را ایجاد می‌کند. text همان است که کاربر می‌بیند، و callback_data داده‌ای است که هنگام کلیک ارسال می‌شود.
• f"vote_{poll_id}_{option_text}": این یک f-string پایتون است که callback_data را فرمت می‌کند. ما سه بخش اصلی داریم:
  • vote_: یک پیشوند برای شناسایی نوع Callback (نشان می‌دهد که مربوط به رای‌گیری است).
  • {poll_id}: شناسه منحصر به فرد نظرسنجی.
  • {option_text}: متن گزینه‌ای که کاربر انتخاب کرده است.
• markup.add(*buttons): این تابع دکمه‌ها را به Inline Keyboard اضافه می‌کند. *buttons به این معنی است که آیتم‌های لیست buttons به عنوان آرگومان‌های جداگانه به add فرستاده می‌شوند.
• reply_markup=markup: این آرگومان در bot.send_message برای پیوست کردن Inline Keyboard به پیام استفاده می‌شود.

با این تغییرات، اکنون کاربران می‌توانند نظرسنجی‌ها را ایجاد و منتشر کنند. گام بعدی این است که به مدیریت پاسخ‌ها (Callbacks) از این کیبوردها و ذخیره‌سازی داده‌های نظرسنجی بپردازیم تا آرا ثبت شوند.

مدیریت پاسخ‌ها (Callbacks) و ذخیره‌سازی داده‌های نظرسنجی

پس از اینکه کاربران نظرسنجی را مشاهده کردند و روی یکی از گزینه‌ها در Inline Keyboard کلیک کردند، ربات یک Callback Query دریافت می‌کند. این Callback Query شامل chat_id، user_id و callback_data است که ما در دکمه‌ها تعریف کرده‌ایم. مدیریت پاسخ‌ها (Callbacks) و ذخیره‌سازی داده‌های نظرسنجی، گام‌های حیاتی برای ثبت آرا و به‌روزرسانی نتایج هستند.

هندلر Callback Query

برای پردازش Callback Queryها، از دکوراتور @bot.callback_query_handler() استفاده می‌کنیم. این هندلر یک آرگومان از نوع types.CallbackQuery دریافت می‌کند که شامل تمام اطلاعات مربوط به کلیک دکمه است.

# ادامه کد bot.py از بخش قبلی

# -------------------- هندلر Callback Query برای رای دادن --------------------
@bot.callback_query_handler(func=lambda call: call.data.startswith('vote_'))
def handle_vote_callback(call):
    user_id = call.from_user.id
    chat_id = call.message.chat.id
    
    # تجزیه callback_data
    # فرمت: "vote_{poll_id}_{option_text}"
    parts = call.data.split('_', 2) # split into 3 parts: 'vote', 'poll_id', 'option_text'
    if len(parts) != 3:
        bot.answer_callback_query(call.id, "خطا در پردازش رای شما. لطفا دوباره امتحان کنید.")
        return

    _, poll_id, option_text = parts
    
    if poll_id not in active_polls:
        bot.answer_callback_query(call.id, "این نظرسنجی منقضی شده یا حذف شده است.")
        return

    poll = active_polls[poll_id]

    # جلوگیری از رای دادن مجدد
    if user_id in poll["voted_users"]:
        bot.answer_callback_query(call.id, "شما قبلاً در این نظرسنجی شرکت کرده اید.")
        return
    
    # بررسی اینکه آیا گزینه انتخاب شده هنوز در نظرسنجی وجود دارد
    if option_text not in poll["options"]:
        bot.answer_callback_query(call.id, "گزینه انتخابی نامعتبر است.")
        return

    # ثبت رای و به روزرسانی داده های نظرسنجی
    poll["votes"][option_text] += 1
    poll["voted_users"].add(user_id) # اضافه کردن کاربر به لیست رای دهندگان

    bot.answer_callback_query(call.id, f"رای شما برای '{option_text}' ثبت شد.")
    
    # به روزرسانی پیام نظرسنجی برای نمایش نتایج جدید
    # این تابع در ادامه تعریف خواهد شد
    update_poll_message(chat_id, call.message.message_id, poll_id)

# -------------------- تابع کمکی برای به روزرسانی پیام نظرسنجی --------------------
def update_poll_message(chat_id, message_id, poll_id):
    if poll_id not in active_polls:
        return
    
    poll = active_polls[poll_id]
    question = poll["question"]
    
    # ساخت متن نتایج
    results_text = "نتایج فعلی:\n"
    total_votes = sum(poll["votes"].values())
    
    markup = types.InlineKeyboardMarkup(row_width=1)
    buttons = []
    
    for option_text in poll["options"]:
        votes = poll["votes"].get(option_text, 0)
        percentage = (votes / total_votes * 100) if total_votes > 0 else 0
        
        # نمایش گزینه و تعداد رای
        option_display = f"{option_text} ({votes} رای - {percentage:.1f}%)"
        
        # برای جلوگیری از رای مجدد، دکمه ها را در حالت به روزرسانی غیرفعال می کنیم
        # یا می توانیم دکمه ها را حذف کنیم و فقط نتایج را نشان دهیم.
        # برای این مثال، دکمه های قابل کلیک را نگه می داریم اما کاربر قبلاً تشخیص داده می شود
        # که رای داده است.
        callback_data = f"vote_{poll_id}_{option_text}"
        button = types.InlineKeyboardButton(option_display, callback_data=callback_data)
        buttons.append(button)
    
    markup.add(*buttons)

    # افزودن یک دکمه برای نمایش نتایج نهایی یا بستن نظرسنجی در صورت نیاز
    # markup.add(types.InlineKeyboardButton("مشاهده نتایج نهایی", callback_data=f"show_results_{poll_id}"))

    new_message_text = f"**{question}**\n\n{results_text}لطفا گزینه مورد نظر خود را انتخاب کنید:"
    
    try:
        # ویرایش پیام موجود به جای ارسال پیام جدید
        bot.edit_message_text(new_message_text, chat_id, message_id, 
                              reply_markup=markup, parse_mode="Markdown")
    except Exception as e:
        print(f"Error updating message: {e}")
        # این خطا ممکن است زمانی رخ دهد که پیامی خیلی قدیمی باشد یا تغییری نکرده باشد.
        # می توان آن را نادیده گرفت یا به کاربر اطلاع داد.


# ... bot.infinity_polling()

توضیحات کد و منطق:

• @bot.callback_query_handler(func=lambda call: call.data.startswith('vote_')): این هندلر هر Callback Query را که callback_data آن با 'vote_' شروع می‌شود، پردازش می‌کند. این یک روش عالی برای فیلتر کردن و گروه‌بندی Callbackها است.
• call.from_user.id و call.message.chat.id: اینها شناسه‌های کاربر و چتی هستند که Callback از آنجا ارسال شده است.
• call.data.split('_', 2): رشته callback_data را بر اساس کاراکتر '_' به حداکثر 3 قسمت تقسیم می‌کند. این به ما اجازه می‌دهد تا poll_id و option_text را به راحتی استخراج کنیم.
• جلوگیری از رای دادن مجدد: if user_id in poll["voted_users"]: این خط از ثبت آرای تکراری توسط یک کاربر در یک نظرسنجی جلوگیری می‌کند. پس از ثبت رای، user_id به مجموعه poll["voted_users"] اضافه می‌شود.
• bot.answer_callback_query(call.id, text): این یک پاسخ کوتاه (Popup یا Alert) را در بالای صفحه تلگرام کاربر نمایش می‌دهد. این تابع حتماً باید فراخوانی شود، حتی اگر پیامی نداشته باشد، در غیر این صورت تلگرام فکر می‌کند که Callback پردازش نشده و دکمه را در حالت بارگذاری نگه می‌دارد.
• update_poll_message(chat_id, message_id, poll_id): این یک تابع کمکی است که پس از هر رای، پیام اصلی نظرسنجی را ویرایش می‌کند تا نتایج به روز شده را نشان دهد. این کار تجربه کاربری بهتری را ارائه می‌دهد، زیرا کاربر نیازی به ارسال دستور جدید یا دریافت پیام جدید ندارد.
• bot.edit_message_text(...): این متد برای ویرایش محتوای یک پیام موجود در تلگرام استفاده می‌شود. به جای ارسال یک پیام جدید، پیام قبلی را به‌روزرسانی می‌کند. این برای نظرسنجی‌ها که باید نتایج را به صورت لحظه‌ای نمایش دهند، بسیار کارآمد است.
• نمایش درصد: ما یک محاسبه ساده برای نمایش درصد رای هر گزینه اضافه کرده‌ایم تا نتایج به صورت بصری جذاب‌تر باشند.

با این تغییرات، ربات نظرسنجی شما اکنون می‌تواند آرا را دریافت و ثبت کند و پیام نظرسنجی را به صورت پویا به‌روزرسانی کند. در بخش بعدی، به نمایش نتایج نظرسنجی به صورت جامع‌تر و افزودن قابلیت‌های تکمیلی برای مدیریت نظرسنجی‌ها خواهیم پرداخت.

نمایش نتایج نظرسنجی و افزودن قابلیت‌های تکمیلی

پس از اینکه کاربران در نظرسنجی شرکت کردند و آرا ثبت شد، نمایش نتایج نظرسنجی به شیوه‌ای خوانا و مفید از اهمیت بالایی برخوردار است. همچنین، برای اینکه ربات ما کاربردی‌تر باشد، نیاز به افزودن قابلیت‌های تکمیلی مانند لیست کردن نظرسنجی‌ها، بستن آن‌ها و حذفشان داریم. در این بخش، این جنبه‌ها را پوشش خواهیم داد.

نمایش نتایج نهایی نظرسنجی

تابع update_poll_message که قبلاً نوشتیم، نتایج لحظه‌ای را در پیام نظرسنجی نمایش می‌دهد. اما ممکن است بخواهیم یک دستور جداگانه برای مشاهده نتایج نهایی در هر زمان داشته باشیم. برای این کار، دستور /results_poll <poll_id> را اضافه می‌کنیم.

# ادامه کد bot.py از بخش قبلی

# -------------------- تابع کمکی برای فرمت کردن و نمایش نتایج نظرسنجی --------------------
def get_formatted_poll_results(poll_id):
    if poll_id not in active_polls:
        return "نظرسنجی یافت نشد."
    
    poll = active_polls[poll_id]
    question = poll["question"]
    
    results_text = f"**نتایج نظرسنجی: {question}**\n\n"
    total_votes = sum(poll["votes"].values())
    
    # مرتب سازی گزینه ها بر اساس تعداد رای (از زیاد به کم)
    sorted_options = sorted(poll["votes"].items(), key=lambda item: item[1], reverse=True)

    if total_votes == 0:
        results_text += "هنوز هیچ رایی ثبت نشده است."
    else:
        for option_text, votes in sorted_options:
            percentage = (votes / total_votes * 100)
            results_text += f"▪️ {option_text}: **{votes}** رای ({percentage:.1f}%)\n"
    
    results_text += f"\nمجموع رای‌ها: {total_votes}"
    results_text += f"\nوضعیت: {'فعال' if poll['active'] else 'بسته شده'}"
    
    return results_text

# -------------------- هندلر دستور /results_poll --------------------
@bot.message_handler(commands=['results_poll'])
def show_poll_results_command(message):
    args = message.text.split(maxsplit=1)
    if len(args) < 2:
        bot.reply_to(message, "لطفا شناسه نظرسنجی را پس از دستور وارد کنید. مثال: /results_poll <poll_id>")
        return
    
    poll_id = args[1].strip()
    
    results = get_formatted_poll_results(poll_id)
    bot.send_message(message.chat.id, results, parse_mode="Markdown")

# -------------------- هندلر دستور /list_polls (قابلیت تکمیلی) --------------------
@bot.message_handler(commands=['list_polls'])
def list_active_polls_command(message):
    user_id = message.from_user.id
    user_polls = {pid: p for pid, p in active_polls.items() if p["creator_id"] == user_id}

    if not user_polls:
        bot.send_message(user_id, "شما هیچ نظرسنجی فعالی ایجاد نکرده‌اید.")
        return

    list_message = "**نظرسنجی‌های شما:**\n\n"
    for poll_id, poll in user_polls.items():
        list_message += f"**ID:** `{poll_id}`\n"
        list_message += f"**سوال:** {poll['question']}\n"
        list_message += f"**وضعیت:** {'فعال' if poll['active'] else 'بسته شده'}\n"
        list_message += f"**تعداد رای‌ها:** {sum(poll['votes'].values())}\n"
        list_message += "--------------------\n"
    
    bot.send_message(user_id, list_message, parse_mode="Markdown")

# -------------------- هندلر دستور /close_poll (قابلیت تکمیلی) --------------------
@bot.message_handler(commands=['close_poll'])
def close_poll_command(message):
    user_id = message.from_user.id
    args = message.text.split(maxsplit=1)
    if len(args) < 2:
        bot.reply_to(message, "لطفا شناسه نظرسنجی را وارد کنید. مثال: /close_poll <poll_id>")
        return
    
    poll_id = args[1].strip()

    if poll_id not in active_polls:
        bot.reply_to(message, "نظرسنجی با این شناسه یافت نشد.")
        return
    
    poll = active_polls[poll_id]

    if poll["creator_id"] != user_id:
        bot.reply_to(message, "شما اجازه بستن این نظرسنجی را ندارید. فقط خالق نظرسنجی می‌تواند آن را ببندد.")
        return
    
    if not poll["active"]:
        bot.reply_to(message, "این نظرسنجی قبلاً بسته شده است.")
        return
    
    poll["active"] = False
    bot.reply_to(message, f"نظرسنجی `{poll_id}` با موفقیت بسته شد. دیگر کسی نمی‌تواند در آن رای دهد.")
    
    # optionally, send final results or update the message again
    results = get_formatted_poll_results(poll_id)
    bot.send_message(message.chat.id, "نتایج نهایی:\n" + results, parse_mode="Markdown")

# -------------------- هندلر Callback Query برای رای دادن (به روزرسانی شده برای بررسی فعال بودن نظرسنجی) --------------------
@bot.callback_query_handler(func=lambda call: call.data.startswith('vote_'))
def handle_vote_callback(call):
    user_id = call.from_user.id
    chat_id = call.message.chat.id
    
    parts = call.data.split('_', 2)
    if len(parts) != 3:
        bot.answer_callback_query(call.id, "خطا در پردازش رای شما. لطفا دوباره امتحان کنید.")
        return

    _, poll_id, option_text = parts
    
    if poll_id not in active_polls:
        bot.answer_callback_query(call.id, "این نظرسنجی منقضی شده یا حذف شده است.")
        return

    poll = active_polls[poll_id]

    if not poll["active"]: # بررسی فعال بودن نظرسنجی قبل از رای دادن
        bot.answer_callback_query(call.id, "این نظرسنجی بسته شده است و امکان رای دادن وجود ندارد.")
        return

    if user_id in poll["voted_users"]:
        bot.answer_callback_query(call.id, "شما قبلاً در این نظرسنجی شرکت کرده اید.")
        return
    
    if option_text not in poll["options"]:
        bot.answer_callback_query(call.id, "گزینه انتخابی نامعتبر است.")
        return

    poll["votes"][option_text] += 1
    poll["voted_users"].add(user_id)

    bot.answer_callback_query(call.id, f"رای شما برای '{option_text}' ثبت شد.")
    
    update_poll_message(chat_id, call.message.message_id, poll_id)

# ... bot.infinity_polling()

قابلیت‌های تکمیلی و توضیحات:

1. /results_poll <poll_id>:
   • این دستور به کاربر اجازه می‌دهد تا نتایج یک نظرسنجی خاص را در هر زمان مشاهده کند.
   • تابع get_formatted_poll_results برای ایجاد یک پیام متنی خوانا از نتایج نظرسنجی طراحی شده است.
   • نتایج بر اساس تعداد رای‌ها، از گزینه با بیشترین رای به گزینه با کمترین رای مرتب می‌شوند.
   • درصد هر رای و مجموع رای‌ها نیز نمایش داده می‌شود.
2. /list_polls:
   • این دستور لیستی از تمام نظرسنجی‌هایی که کاربر فعلی ایجاد کرده است را نمایش می‌دهد. این برای مدیریت نظرسنجی‌های خود کاربر بسیار مفید است.
   • اطلاعاتی مانند ID نظرسنجی، سوال، وضعیت (فعال/بسته شده) و مجموع رای‌ها را شامل می‌شود.
3. /close_poll <poll_id>:
   • این قابلیت به خالق نظرسنجی اجازه می‌دهد تا یک نظرسنجی فعال را ببندد.
   • پس از بسته شدن، poll["active"] به False تغییر می‌کند.
   • هندلر Callback Query نیز به روزرسانی شده است تا قبل از ثبت رای، وضعیت poll["active"] را بررسی کند و از رای‌گیری در نظرسنجی‌های بسته شده جلوگیری کند.
   • پس از بستن نظرسنجی، می‌توان نتایج نهایی را نیز به کاربر ارسال کرد.
   • یک بررسی امنیتی اضافه شده است تا فقط خالق نظرسنجی بتواند آن را ببندد.
4. به‌روزرسانی هندلر handle_vote_callback:
   • اکنون، قبل از اینکه ربات رایی را ثبت کند، ابتدا بررسی می‌کند که آیا poll["active"] برابر True است یا خیر. این اطمینان می‌دهد که در نظرسنجی‌های بسته شده، هیچ رای جدیدی ثبت نمی‌شود.

با افزودن این قابلیت‌ها، ربات نظرسنجی شما اکنون بسیار کامل‌تر و کاربردی‌تر شده است. کاربران می‌توانند نظرسنجی‌ها را ایجاد، منتشر، در آن‌ها شرکت، نتایج لحظه‌ای را مشاهده و حتی نظرسنجی‌های خود را مدیریت کنند. در بخش بعدی، به یکی از مهم‌ترین چالش‌های ربات‌های مبتنی بر حافظه، یعنی پایداری داده‌ها و مدیریت خطا، خواهیم پرداخت.

پایداری داده‌ها و مدیریت خطا در ربات نظرسنجی

تا اینجای کار، ربات نظرسنجی ما تمام داده‌ها (نظرسنجی‌ها و حالت‌های کاربران) را در حافظه اصلی (RAM) ذخیره می‌کند. این روش برای توسعه و تست‌های اولیه مناسب است، اما یک نقطه ضعف بزرگ دارد: با هر بار راه‌اندازی مجدد ربات، تمام داده‌ها از بین می‌روند. برای یک ربات تلگرام واقعی، پایداری داده‌ها (Data Persistence) یک ضرورت است. همچنین، برای اطمینان از عملکرد روان و قابل اعتماد ربات، مدیریت خطا (Error Handling) به درستی پیاده‌سازی شود.

پایداری داده‌ها: انتخاب و پیاده‌سازی

روش‌های مختلفی برای ذخیره‌سازی داده‌های ربات وجود دارد:

1. فایل‌های JSON/CSV: ساده‌ترین روش برای ذخیره داده‌های ساختاریافته. مناسب برای ربات‌های کوچک با حجم داده کم.
2. پایگاه داده SQLite: یک پایگاه داده رابطه‌ای سبک و مبتنی بر فایل که برای برنامه‌های کوچک تا متوسط بسیار مناسب است. نیاز به نصب سرور جداگانه ندارد و با ماژول sqlite3 پایتون به راحتی قابل استفاده است.
3. پایگاه داده‌های رابطه‌ای (PostgreSQL, MySQL): برای ربات‌های بزرگ‌تر و پیچیده‌تر با نیاز به مقیاس‌پذیری و تراکنش‌های پیچیده. نیاز به نصب و مدیریت سرور جداگانه دارند.
4. پایگاه داده‌های NoSQL (MongoDB, Redis): مناسب برای داده‌های بدون ساختار، حجم بالا و سرعت دسترسی بالا.

برای ربات نظرسنجی ساده ما، استفاده از فایل JSON برای ذخیره‌سازی نظرسنجی‌ها و حالت کاربران یک گزینه عملی و آسان است. (SQLite نیز یک گزینه عالی و کمی پیشرفته‌تر خواهد بود).

ذخیره‌سازی با فایل JSON

ما دو تابع برای بارگذاری و ذخیره‌سازی داده‌ها خواهیم نوشت:

• load_data(): داده‌ها را از فایل JSON می‌خواند.
• save_data(): داده‌های فعلی را در فایل JSON می‌نویسد.

نکات مهم:

• مجموعه set (برای voted_users) مستقیماً قابل سریالایز شدن به JSON نیست. باید آن را به list تبدیل کرده و هنگام بارگذاری دوباره به set تبدیل کنیم.
• این روش در محیط‌های چندنخی یا همزمان ممکن است با Race Condition مواجه شود. برای ربات‌های بزرگتر، نیاز به مکانیزم‌های قفل‌گذاری (locking) یا استفاده از پایگاه داده واقعی است.

import telebot
from telebot import types
import uuid
import json
import os
import time # برای مدیریت وقفه در infinity_polling

API_TOKEN = 'YOUR_API_TOKEN_HERE'
bot = telebot.TeleBot(API_TOKEN)

# فایل های ذخیره سازی داده ها
POLLS_FILE = "polls.json"
USER_STATES_FILE = "user_states.json"

active_polls = {}
user_states = {}

STATE_IDLE = "idle"
STATE_AWAITING_QUESTION = "awaiting_question"
STATE_AWAITING_OPTIONS = "awaiting_options"

# -------------------- توابع برای پایداری داده ها --------------------
def load_data():
    global active_polls, user_states
    if os.path.exists(POLLS_FILE):
        with open(POLLS_FILE, 'r', encoding='utf-8') as f:
            loaded_polls = json.load(f)
            # تبدیل لیست voted_users به set
            active_polls = {
                pid: {**p, "voted_users": set(p.get("voted_users", []))} 
                for pid, p in loaded_polls.items()
            }
    
    if os.path.exists(USER_STATES_FILE):
        with open(USER_STATES_FILE, 'r', encoding='utf-8') as f:
            user_states = json.load(f)
    print("داده ها بارگذاری شدند.")

def save_data():
    # تبدیل set voted_users به لیست قبل از ذخیره سازی
    serializable_polls = {
        pid: {**p, "voted_users": list(p["voted_users"])} 
        for pid, p in active_polls.items()
    }
    with open(POLLS_FILE, 'w', encoding='utf-8') as f:
        json.dump(serializable_polls, f, indent=4, ensure_ascii=False)
    
    with open(USER_STATES_FILE, 'w', encoding='utf-8') as f:
        json.dump(user_states, f, indent=4, ensure_ascii=False)
    print("داده ها ذخیره شدند.")

# -------------------- فراخوانی بارگذاری داده ها در ابتدای اجرا --------------------
load_data()

# -------------------- هندلر دستور /start (به روزرسانی شده برای اطمینان از مقداردهی اولیه حالت) --------------------
@bot.message_handler(commands=['start'])
def send_welcome(message):
    user_id = message.from_user.id
    if user_id not in user_states: # اطمینان از مقداردهی اولیه حالت برای کاربر جدید
        user_states[user_id] = {"state": STATE_IDLE, "temp_poll_data": {}}
        save_data() # ذخیره حالت جدید کاربر
    bot.reply_to(message, "سلام! من ربات نظرسنجی شما هستم. برای ایجاد یک نظرسنجی جدید، /create_poll را ارسال کنید.")

# -------------------- سایر هندلرها (get_poll_question, get_poll_options, publish_poll_command, 
#                                     show_poll_results_command, list_active_polls_command, 
#                                     close_poll_command, handle_vote_callback, default_message_handler)
#     باید هر جا که active_polls یا user_states تغییر می کنند، save_data() فراخوانی شود.
#     مثال برای get_poll_options:

@bot.message_handler(func=lambda message: user_states.get(message.from_user.id, {}).get("state") == STATE_AWAITING_OPTIONS)
def get_poll_options(message):
    user_id = message.from_user.id
    options_text = message.text

    options = [opt.strip() for opt in options_text.split(',') if opt.strip()]
    if not options or len(options) < 2:
        bot.send_message(user_id, "لطفا حداقل دو گزینه برای نظرسنجی وارد کنید و آنها را با کاما جدا کنید.")
        return

    poll_id = str(uuid.uuid4())
    question = user_states[user_id]["temp_poll_data"]["question"]
    initial_votes = {opt: 0 for opt in options}

    active_polls[poll_id] = {
        "question": question,
        "options": options,
        "votes": initial_votes,
        "creator_id": user_id,
        "active": True,
        "voted_users": set()
    }

    user_states[user_id] = {"state": STATE_IDLE, "temp_poll_data": {}}
    save_data() # مهم: داده ها را پس از تغییر ذخیره کنید.

    bot.send_message(user_id, "نظرسنجی با موفقیت ایجاد شد! "
                               "برای اشتراک گذاری آن، از دستور /publish_poll استفاده کنید و poll_id را پس از آن وارد نمایید. (مثلا: /publish_poll " + poll_id + ")")
    bot.send_message(user_id, f"شناسه نظرسنجی شما: `{poll_id}`", parse_mode="Markdown")

# ... (همین کار را برای handle_vote_callback و close_poll_command انجام دهید)
@bot.callback_query_handler(func=lambda call: call.data.startswith('vote_'))
def handle_vote_callback(call):
    # ... (کد قبلی)
    poll["votes"][option_text] += 1
    poll["voted_users"].add(user_id)
    save_data() # ذخیره داده ها پس از ثبت رای

    bot.answer_callback_query(call.id, f"رای شما برای '{option_text}' ثبت شد.")
    update_poll_message(chat_id, call.message.message_id, poll_id)

@bot.message_handler(commands=['close_poll'])
def close_poll_command(message):
    # ... (کد قبلی)
    poll["active"] = False
    save_data() # ذخیره داده ها پس از بستن نظرسنجی
    bot.reply_to(message, f"نظرسنجی `{poll_id}` با موفقیت بسته شد. دیگر کسی نمی‌تواند در آن رای دهد.")
    results = get_formatted_poll_results(poll_id)
    bot.send_message(message.chat.id, "نتایج نهایی:\n" + results, parse_mode="Markdown")


# -------------------- مدیریت خطا --------------------
# استفاده از try-except در هندلرها و infinity_polling
# Telebot infinity_polling() خودش مدیریت خطای داخلی دارد و در صورت بروز خطا، سعی می کند دوباره وصل شود.
# اما می توانید یک بلاک try-except کلی برای کنترل دقیق تر اضافه کنید.

try:
    print("ربات در حال اجرا است...")
    bot.infinity_polling(timeout=10, long_polling_timeout=5) # اضافه کردن timeout برای کنترل بهتر
except Exception as e:
    print(f"یک خطای کلی در ربات رخ داد: {e}")
    # می توانید اینجا گزارش خطا را به یک سرویس لاگینگ ارسال کنید.
    time.sleep(5) # وقفه قبل از تلاش مجدد یا خروج

# می توان برای هر هندلر نیز try-except جداگانه اضافه کرد.
# مثال:
# @bot.message_handler(commands=['start'])
# def send_welcome(message):
#     try:
#         user_id = message.from_user.id
#         if user_id not in user_states:
#             user_states[user_id] = {"state": STATE_IDLE, "temp_poll_data": {}}
#             save_data()
#         bot.reply_to(message, "سلام! ...")
#     except Exception as e:
#         print(f"Error in send_welcome: {e}")
#         bot.send_message(message.chat.id, "متاسفم، مشکلی پیش آمد. لطفا دوباره امتحان کنید.")

توضیحات پایداری داده‌ها:

• load_data() و save_data(): این توابع مسئول بارگذاری و ذخیره داده‌ها هستند. load_data() در ابتدای اجرای ربات فراخوانی می‌شود و save_data() هر زمان که active_polls یا user_states تغییر می‌کنند، باید فراخوانی شود.
• سریالایز کردن set: برای ذخیره set از voted_users، قبل از ذخیره آن را به list تبدیل می‌کنیم و هنگام بارگذاری، دوباره به set بازمی‌گردانیم.
• فرمت JSON: از json.dump با indent=4 برای خوانایی بهتر فایل JSON و ensure_ascii=False برای ذخیره کاراکترهای فارسی استفاده می‌کنیم.
• نحوه فراخوانی save_data(): هر جا که داده‌های نظرسنجی (مانند active_polls) یا حالت کاربران (مانند user_states) تغییر می‌کنند، باید save_data() را فراخوانی کنید. این شامل هندلرهای get_poll_options (پس از ایجاد نظرسنجی)، handle_vote_callback (پس از ثبت رای) و close_poll_command (پس از تغییر وضعیت نظرسنجی) می‌شود.

مدیریت خطا:

• bot.infinity_polling(timeout=10, long_polling_timeout=5): متد infinity_polling خود try-except داخلی برای مدیریت خطاهای شبکه دارد و در صورت قطع ارتباط، سعی می‌کند مجدداً وصل شود. پارامترهای timeout و long_polling_timeout به ترتیب برای تعیین زمان انقضای درخواست‌های HTTP و مدت زمان انتظار برای دریافت پیام‌های جدید استفاده می‌شوند.
• try-except در سطح بالاتر: قرار دادن infinity_polling درون یک بلاک try-except کلی به شما امکان می‌دهد تا هر خطای پیش‌بینی نشده‌ای را که ممکن است به طور کامل باعث از کار افتادن ربات شود، ثبت و مدیریت کنید. در این بلاک می‌توانید لاگ‌برداری انجام دهید یا حتی ربات را پس از یک وقفه کوتاه مجدداً راه‌اندازی کنید.
• try-except در سطح هندلر: برای کنترل دقیق‌تر و جلوگیری از اینکه یک خطا در یک هندلر خاص کل ربات را از کار بیندازد، می‌توانید یک بلاک try-except را درون هر تابع هندلر نیز قرار دهید. این کار به شما امکان می‌دهد تا به کاربر اطلاع دهید که مشکلی پیش آمده است و همچنین جزئیات خطا را لاگ کنید.
• گزارش‌گیری (Logging): در یک ربات تلگرام واقعی، به جای print()، از ماژول logging پایتون استفاده کنید تا لاگ‌ها را به صورت سازماندهی شده در فایل‌ها یا سرویس‌های لاگ‌گیری خارجی ذخیره کنید.

با پیاده‌سازی پایداری داده‌ها و مدیریت خطا، ربات نظرسنجی شما اکنون بسیار مقاوم‌تر و قابل اعتمادتر شده است. می‌تواند در برابر راه‌اندازی مجدد مقاومت کند و خطاهای پیش‌بینی نشده را بهتر مدیریت کند. در بخش نهایی، به استقرار ربات نظرسنجی در سرور و ملاحظات امنیتی خواهیم پرداخت.

استقرار ربات نظرسنجی در سرور و ملاحظات امنیتی

تا این مرحله، ربات نظرسنجی پایتون ما بر روی سیستم لوکال شما اجرا می‌شود. برای اینکه ربات به صورت 24/7 در دسترس کاربران باشد، باید آن را بر روی یک سرور استقرار (Deployment) دهید. استقرار ربات در یک محیط تولیدی همچنین نیازمند رعایت ملاحظات امنیتی خاصی است. این بخش به تفصیل به این موضوعات می‌پردازد.

روش‌های استقرار ربات

گزینه‌های مختلفی برای استقرار ربات تلگرام وجود دارد:

1. سرویس‌های هاستینگ ابری (PaaS) مانند Heroku, PythonAnywhere:
   • مزایا: راه‌اندازی سریع و آسان، مدیریت زیرساخت توسط ارائه‌دهنده، معمولاً دارای یک پلن رایگان یا ارزان برای شروع.
   • معایب: کنترل کمتر بر روی سرور، ممکن است در پلن‌های رایگان محدودیت‌هایی مانند Sleep Time (خواب رفتن برنامه بعد از عدم فعالیت) وجود داشته باشد. Heroku Free Tier دیگر موجود نیست، اما PythonAnywhere هنوز یک گزینه رایگان دارد.
   • نحوه استقرار (مثال Heroku):
     • ایجاد یک فایل requirements.txt با pip freeze > requirements.txt.
     • ایجاد یک فایل Procfile (بدون پسوند) با محتوای worker: python bot.py.
     • تنظیم توکن API به عنوان متغیر محیطی در Heroku (heroku config:set API_TOKEN=YOUR_TOKEN).
     • استفاده از Git برای push کردن کد به Heroku.
2. سرورهای خصوصی مجازی (VPS) مانند Vultr, DigitalOcean, Linode:
   • مزایا: کنترل کامل بر روی سیستم عامل و محیط، مقیاس‌پذیری بالا، مناسب برای ربات‌های بزرگتر و پیچیده‌تر.
   • معایب: نیاز به دانش مدیریت سرور (لینوکس)، راه‌اندازی دستی‌تر.
   • نحوه استقرار:
     • یک سرور لینوکس (مثلاً اوبونتو) تهیه کنید.
     • پایتون، pip، و git را نصب کنید.
     • کد ربات را با git clone به سرور منتقل کنید.
     • محیط مجازی را ایجاد و فعال کنید.
     • وابستگی‌ها را با pip install -r requirements.txt نصب کنید.
     • برای اجرای دائمی ربات، از ابزارهایی مانند systemd یا supervisor استفاده کنید تا ربات حتی پس از راه‌اندازی مجدد سرور نیز به طور خودکار شروع به کار کند و در صورت crash شدن، دوباره راه‌اندازی شود.
     • توکن API را به عنوان متغیر محیطی تنظیم کنید (مثلاً در .bashrc یا فایل سرویس systemd).
3. Docker:
   • مزایا: قابلیت حمل بالا، ایزوله‌سازی، آسان‌سازی محیط توسعه و تولید.
   • معایب: نیاز به یادگیری مفاهیم داکر.
   • نحوه استقرار: ایجاد یک Dockerfile برای ساخت ایمیج داکر، سپس استقرار کانتینر در هر محیطی که داکر پشتیبانی می‌کند.

استفاده از متغیرهای محیطی برای توکن API

یکی از مهمترین ملاحظات امنیتی، عدم هاردکد کردن توکن API در کد است. به جای آن، توکن را به عنوان یک متغیر محیطی (Environment Variable) در سیستم عامل یا سرویس هاستینگ خود تنظیم کنید و در کد پایتون آن را بخوانید.

import os
import telebot
# ... (بقیه وارد کردن ها و کد)

# به جای:
# API_TOKEN = 'YOUR_API_TOKEN_HERE'

# از:
API_TOKEN = os.environ.get('TELEGRAM_BOT_TOKEN') # TELEGRAM_BOT_TOKEN نام متغیر محیطی است
if not API_TOKEN:
    raise ValueError("توکن API ربات تلگرام یافت نشد. لطفا متغیر محیطی TELEGRAM_BOT_TOKEN را تنظیم کنید.")

bot = telebot.TeleBot(API_TOKEN)

# ... (بقیه کد ربات)

برای تنظیم متغیر محیطی TELEGRAM_BOT_TOKEN:

• در لینوکس/macOS (فقط برای ترمینال فعلی): export TELEGRAM_BOT_TOKEN="YOUR_API_TOKEN_HERE"
• در ویندوز (فقط برای Command Prompt فعلی): set TELEGRAM_BOT_TOKEN="YOUR_API_TOKEN_HERE"
• برای دائمی کردن در لینوکس، آن را به ~/.bashrc یا ~/.profile اضافه کنید.
• در سرویس‌های ابری مانند Heroku یا DigitalOcean، معمولاً بخش خاصی برای تنظیم متغیرهای محیطی وجود دارد.

سایر ملاحظات امنیتی:

1. اعتبارسنجی ورودی کاربر:

   همیشه ورودی‌های کاربر را اعتبارسنجی کنید. از عبارات منظم (Regex) برای بررسی فرمت‌ها، محدودیت طول رشته‌ها، و جلوگیری از حملات Injection (مانند SQL Injection اگر از پایگاه داده استفاده می‌کنید) استفاده کنید. در ربات ما، ما ورودی‌ها را برای تعداد گزینه‌ها بررسی کردیم، اما می‌توانیم آن را بیشتر تقویت کنیم.

2. محدودیت نرخ (Rate Limiting):

   برای جلوگیری از سوءاستفاده یا حملات DDoS کوچک، تعداد پیام‌هایی که یک کاربر می‌تواند در یک بازه زمانی ارسال کند را محدود کنید. Telebot دارای ویژگی @bot.throttled_message_handler برای این منظور است، اما نیاز به نصب کتابخانه pyTelegramBotAPI[rate_limiting] دارد.

3. کنترل دسترسی (Access Control):

   اگر برخی دستورات (مانند /close_poll) فقط برای مدیران یا خالقان نظرسنجی هستند، حتماً user_id کاربر را بررسی کنید تا فقط کاربران مجاز بتوانند از آن‌ها استفاده کنند. ما این را برای /close_poll پیاده‌سازی کردیم.

4. لاگ‌برداری امن:

   در فایل‌های لاگ خود، اطلاعات حساس (مانند توکن‌ها یا اطلاعات شخصی کاربران) را ثبت نکنید. از ماژول logging پایتون استفاده کنید و سطح لاگ‌برداری را به درستی تنظیم کنید.

5. به‌روزرسانی کتابخانه‌ها:

   همیشه کتابخانه‌های پایتون و به ویژه Telebot را به آخرین نسخه پایدار به‌روز نگه دارید تا از پچ‌های امنیتی و رفع باگ‌ها بهره‌مند شوید.

6. Long Polling در مقابل Webhooks:

   در حالی که ما از Long Polling با bot.infinity_polling() استفاده می‌کنیم، تلگرام همچنین از Webhooks پشتیبانی می‌کند. Webhooks معمولاً برای ربات‌هایی با مقیاس بزرگتر ترجیح داده می‌شوند، زیرا سرور تلگرام به جای اینکه ربات شما به صورت دوره‌ای پیام‌ها را درخواست کند، به ربات شما پیام ارسال می‌کند. این کار بار سرور شما را کاهش می‌دهد و پاسخگویی را افزایش می‌دهد، اما نیاز به یک سرور با گواهی SSL و آدرس IP عمومی دارد.

با رعایت این ملاحظات امنیتی و انتخاب روش استقرار ربات مناسب، می‌توانید اطمینان حاصل کنید که ربات نظرسنجی شما به صورت امن و پایدار در خدمت کاربران قرار می‌گیرد.

جمع‌بندی و چشم‌اندازهای آتی

در طول این پست آموزشی جامع، ما یک سفر کامل را در ساخت یک ربات نظرسنجی ساده با Telebot و پایتون طی کردیم. از مراحل ابتدایی راه‌اندازی محیط توسعه و دریافت توکن API از BotFather گرفته تا درک مبانی Telebot و ساختار کد، همه جنبه‌های اساسی را پوشش دادیم.

مهمترین بخش‌های این آموزش شامل طراحی منطق نظرسنجی، پیاده‌سازی مدیریت حالت کاربر برای فرآیندهای چند مرحله‌ای، و استفاده هوشمندانه از کیبوردهای Inline برای جمع‌آوری آرای کاربران بود. ما همچنین نحوه مدیریت پاسخ‌ها (Callbacks)، ذخیره‌سازی داده‌های نظرسنجی، نمایش نتایج به صورت لحظه‌ای و نهایی، و افزودن قابلیت‌های تکمیلی مانند لیست کردن و بستن نظرسنجی‌ها را فرا گرفتیم. در نهایت، با بحث در مورد پایداری داده‌ها با فایل JSON و ملاحظات امنیتی و استقرار ربات، اصول لازم برای آوردن ربات خود به محیط تولید را بررسی کردیم.

این ربات نظرسنجی تلگرام که ساختیم، یک پایه قوی و کاربردی است. اما دنیای توسعه ربات‌های تلگرام بسیار وسیع‌تر است و همیشه جای برای بهبود و افزودن قابلیت‌های پیشرفته‌تر وجود دارد. در ادامه، به برخی چشم‌اندازهای آتی و ایده‌هایی برای گسترش این ربات می‌پردازیم:

چشم‌اندازهای آتی و ایده‌های توسعه:

1. پایگاه داده پیشرفته‌تر:

   به جای فایل‌های JSON، می‌توانید از پایگاه‌های داده رابطه‌ای مانند SQLite (برای سادگی) یا PostgreSQL (برای مقیاس‌پذیری و پروژه‌های بزرگ‌تر) استفاده کنید. این کار به شما امکان می‌دهد تا داده‌ها را به شکل کارآمدتر و امن‌تری مدیریت کنید و از مشکلاتی مانند Race Condition در عملیات فایل‌نویسی جلوگیری کنید.

2. پشتیبانی از چندین نظرسنجی همزمان در یک گروه:

   ربات فعلی می‌تواند نظرسنجی‌های متعدد را مدیریت کند، اما برای انتشار در یک گروه، باید poll_id را بدانید. می‌توان قابلیتی اضافه کرد تا در یک گروه، نظرسنجی‌های فعال فهرست شوند و کاربران بتوانند راحت‌تر در آن‌ها شرکت کنند.

3. انواع نظرسنجی‌های مختلف:

   می‌توانید قابلیت ایجاد نظرسنجی‌های چند گزینه‌ای (Multiple Choice)، نظرسنجی با ورودی متنی آزاد، یا حتی نظرسنجی‌های ناشناس (Anonymous Polls) را اضافه کنید. نظرسنجی‌های ناشناس نیازمند منطق پیچیده‌تری برای ثبت آرا بدون افشای هویت کاربر هستند.

4. زمان‌بندی نظرسنجی‌ها:

   امکان تعیین زمان شروع و پایان برای نظرسنجی‌ها، که به صورت خودکار فعال و غیرفعال شوند.

5. قابلیت‌های مدیریتی پیشرفته:

   اضافه کردن قابلیت‌هایی برای ویرایش سوال یا گزینه‌ها، حذف رای‌ها (توسط مدیر)، ارسال یادآوری برای شرکت در نظرسنجی، یا اشتراک‌گذاری نتایج نظرسنجی به صورت گرافیکی (مثلاً با نمودار).

6. اینتگریشن با پلتفرم‌های دیگر:

   اگر نظرسنجی شما مربوط به یک رویداد یا سرویس خاص است، می‌توانید ربات را با تقویم‌ها، سیستم‌های CRM، یا سایر پلتفرم‌ها یکپارچه کنید.

7. استفاده از Webhooks:

   برای ربات‌های با ترافیک بالا، پیاده‌سازی Webhooks به جای Long Polling می‌تواند عملکرد و پاسخگویی ربات را بهبود بخشد، هرچند که نیاز به یک سرور با تنظیمات SSL دارد.

8. تست خودکار:

   نوشتن تست‌های واحد (Unit Tests) و تست‌های یکپارچه‌سازی (Integration Tests) برای اطمینان از صحت عملکرد ربات و جلوگیری از رگرسیون‌ها در زمان توسعه قابلیت‌های جدید.

9. بهبود تجربه کاربری:

   اضافه کردن دکمه‌های "لغو" در هر مرحله از ایجاد نظرسنجی، پیام‌های خطای کاربرپسندتر، و راهنمایی‌های واضح‌تر برای استفاده از ربات.

با این آموزش، شما نه تنها مهارت‌های لازم برای ساخت یک ربات تلگرام با پایتون و Telebot را به دست آوردید، بلکه درکی عمیق از چالش‌ها و راه‌حل‌های رایج در برنامه نویسی ربات پیدا کردید. این دانش، دروازه‌ای برای ساخت هر نوع ربات دیگری است که تصور کنید. امیدواریم این راهنما برای شما مفید بوده باشد و الهام‌بخش پروژه‌های آینده شما در دنیای Telebot و پایتون باشد. به یاد داشته باشید، بهترین راه برای یادگیری، تمرین و آزمایش است. موفق باشید!