Сегодня мы научимся работать с API сайта 365sms.org (Новый домен 365sms.ru)

Давайте попробуем понять зачем нам это.

1. Это для того что-бы мы в бота смогли пихать любые сервисы которые дают нам API для связи с ними (и не только в ботов)
2. Для автоматизации процессов

Использовать будем такую библиотеку как requests

pip install requests

Переходим на сайт "https://365sms.ru/api365"

и читаем документацию...

Что нам это дало?

Есть несколько разделов в api документации
Давайте разберём каждый по порядку:

1. Описание протокола API - это нам не особо интересно, разве что строка описывающая какие запросы нам нужны "Все запросы (только GET) должны идти на данный адрес"
2. Запрос количества доступных номеров getNumbersStatus - описан примерный запрос к сайту для получения кол-во доступных номеров
   https://365sms.org/stubs/handler_api.php?api_key=APIKEY&action=getNumbersStatus&country=COUNTRY&operator=OPERATOR
   
   А так же предоставлены переменные которые нужно будет заменить:
   APIKEY - ключ обеспечивает доступ к оплаченным услугам
   COUNTRY - Страна номера
   OPERATOR - Оператор номера. Если параметр не задан, будет задействован случайный оператор
   
   Ну и ответ от сервиса после сделанного запроса в формате json (позже к нему перейдём)
   {"vk_0":890,"ok_0":192,"wa_0":146,"vi_0":199,"tg_0":101,"wb_0":103,"go_0":467,"av_0":177,"fb_0":132,"tw_0":479}
3. Запрос баланса getBalance - Получаем текущий баланс аккаунта на сайте
4. Заказ номера getNumber - с помощью этого метода будем запрашивать номер
5. Изменить статус setStatus - этот метод нам позволит менять статус номера
   Статусы:
1. 3 - необходимо повторно смс
2. 6 - активация успешно завершена
3. 8 - отменить активацию
6. Получить статус getStatus - с помощью данного метода мы получим статус номера (Статусы описаны выше)
7. Запросить все цены getPrices - этот метод вернёт нам json объект со всеми ценами сервисов по ID страны
   

Давайте перейдём к методам запросов модуля requests

Метод POST:

Используется для отправки данных на сервер

Метод GET:

Используется для получения данных с сервера

Использовать будем метод GET

Создаём папку bot_requests_365

В папке создаём файлы:

1. main.py - В нём будем писать весь код бота
2. class_db.py - Скопируем в него модуль из предыдущих уроков
3. test.py - В нём будут клавиатуры
4. config.py - В него будем записывать все данные (токены, id админов и т.п.)

И так у нас получилась папка с содержанием:

Код для файла class_db.py:

import pymysql #Импортируем модуль pymysql который установили в первом уроке

class work_db:
	def __init__(self, host, port, user, password, database): #Функция для иницилизирования переменных в класс, запускать её не надо
		self.host = host
		self.port = port
		self.user = user
		self.password = password
		self.database = database

	def connect_db(self): #Функция для конекта к базе данных
		try:
			connection = pymysql.connect(
				host = self.host,
				port = self.port,
				user = self.user,
				password = self.password,
				database = self.database,
				cursorclass = pymysql.cursors.DictCursor
			)
			return connection #Если конект прошёл успешно, возвращаем переменную connection, для дальнейшей работы
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def connect_close(self, connection): #Передаём переменную connection если в коде подключились, после каждого подключения к базе данных и выполнения какого-либо когда, нужно закрывать подключение
		try:
			connection.close() #Закрываем подключение к базе данных
			return True #Если успешно закрыли подключение к базе, возвращаем True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def create_table(self, connection, creat): #Функция для создания таблице в базе данных, в creat будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(creat)
			connection.commit()
			return True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def edit_table(self, connection, zapros, values):
		try:
			with connection.cursor() as cursor:
				cursor.execute(zapros, values)
			connection.commit()
			return True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def info_table(self, connection, info, values): #Функция для получения данных из таблицы, в info будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(info, values)
			return cursor.fetchall() #Возвращаем всё что нашли
		except Exception as eror:
			print(str(eror)+'\n\n') #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def insert_table(self, connection, zapros, values):
		try:
			with connection.cursor() as cursor:
				a = cursor.execute(zapros, values)
			connection.commit()
			return a
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def delete_from_table(self, connection, delete_, values): #Функция для редактирования данных в таблице, в delete_ будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(delete_, values)
			connection.commit()
			return True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

И так создадим ещё 1 файл для удобно работы с api сайта 365sms.ru

Название файла: module_sms.py

Напишем для этого файла следующий код:

import requests

class main_sms:
	def __init__(self, token):
		self.token = token #Токен будем передавать в класс
		self.link = 'https://365sms.ru/stubs/handler_api.php' #Ссылка для работы с api берём с сайта


	def get_balanse(self): #Функция для получения текущего баланса на сайте
		balans = requests.get(f'{self.link}?api_key={self.token}&action=getBalance') #Делаем get апрос для получения данных
		if 'ACCESS_BALANCE' in balans.text: #если мы успешно получили баланс то возращаем его
			spisok = balans.text.split(':') #Сплитуем(разделяем) текст по : который получили в ответе от сайта
			return spisok[1] #Возращаем баланс
		else:
			return balans.text #В ином случае возращаем весь текст который получили, для дальнейшей обработки


	def new_number(self, servis, strana, operator=None): #Функия для получения номера телефона
		if operator == None: #Если мы не передали оператор, то сайт нам выдаст рандомного оператора
			number = requests.get(f'{self.link}?api_key={self.token}&action=getNumber&service={servis}&country={strana}') #Делаем гет запрос без учёта оператора
		else: #В ином случае мы передаём в запрос ещё и оператора
			number = requests.get(f'{self.link}?api_key={self.token}&action=getNumber&service={servis}&operator={operator}&country={strana}')#Делаем гет запрос с учётом оператора
		return number.text #Возращаем всё что получили в ответ от сайта

	def new_status(self, idi, status): #Функция для изменения статуса номера
		stat = requests.get(f'{self.link}?api_key={self.token}&action=setStatus&status={status}&id={idi}') #Делаем гет запрос
		return stat.text #Возращаем всё что получили в ответ от сайта

	def get_status(self, idi): #Получаем статус номера по его id
		stat = requests.get(f'{self.link}?api_key={self.token}&action=getStatus&id={idi}') #Делаем гет запрос
		return stat.text #Возращаем всё что получили в ответ от сайта

	def get_all_price(self, strana, servis=None):
		if servis == None: #Если не передали сервис
			spisok = requests.get(f'{self.link}?api_key={self.token}&action=getPrices&country={strana}') #Делаем гет запрос без учёта сервиса
		else: #В ином случае при передаче сервиса
			spisok = requests.get(f'{self.link}?api_key={self.token}&action=getPrices&service={servis}&country={strana}') #Делаем гет запрос с учётом сервиса
		return spisok.json() #Возращаем всё что получили в ответ от сайта в формате json

Давайте перейдём к файлу test.py:

И напишем в него код с клавиатурой (для начала напишем 1 текстовую кнопку):

from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton, KeyboardButton, ReplyKeyboardMarkup


mainy = [['Получить баланс']]
mark_menu = ReplyKeyboardMarkup(mainy, resize_keyboard=True)

Клавиатура создана, перейдём к файлу config.py:

token_bot = 'Токен вашего бота'
admin = Ваш id телеграма в формате 123
token_sms = 'Токен с сайта 365sms.ru/account'
#Данные для подключения к базе данных
host = 'localhost'
port = 8080
user = 'root'
password = 'password'
database = 'database_sms'

Токен бота берём в @BotFather

ID берём из @Bsc_Black_Secret_Club_bot -> Профиль

Токен смс берём с 365sms.ru/account

Перейдём к самому интересному, к файлу main.py:

Импортируем нужные нам модули:

from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton, KeyboardButton, ReplyKeyboardMarkup, BotCommand, WebAppInfo
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
import config as c
import test as bb
import asyncio
import pymysql
from class_db import work_db
from module_sms import main_sms

Давайте напишем все экземпляры классов которые нам понадобятся:

bot = Bot(token=c.token_bot, parse_mode=types.ParseMode.HTML) #Берём токен бота из файла config.py который импортировали ранее в переменную c
dp = Dispatcher(bot, storage=MemoryStorage())
db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига
work_sms = main_sms(c.token_sms) #Создаём экземпляр класса для работы с сервисом смс

Напишем обработчик всего текста, в который напишем обработку команды /start и текстовой кнопки "Получить баланс":

@dp.message_handler(content_types=['text'])
async def text(message: types.Message):
    id_user = message.from_user.id #Записываем id пользователя (Ранее писали message.chat.id)
    if message.text == '/start':
    	await bot.send_message(id_user, 'Хай, вы попали в смс бота для работы с сайтом 365sms.ru', reply_markup=bb.mark_menu) #При команде старт отправляем приветственное сообщение и рассказываем о себе, и выводим клавиатуру
    elif message.text == 'Получить баланс':
    	balanse_sms = work_sms.get_balanse() #Запрашиваем баланс с сайта по api
    	await bot.send_message(id_user, f'Текущий баланс: {balanse_sms}₽') #Пока выводим то что получили от сайта

У нас получился такой код:

from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton, KeyboardButton, ReplyKeyboardMarkup, BotCommand, WebAppInfo
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
import config as c
import test as bb
import asyncio
import pymysql
from class_db import work_db
from module_sms import main_sms



bot = Bot(token=c.token_bot, parse_mode=types.ParseMode.HTML) #Берём токен бота из файла config.py который импортировали ранее в переменную c
dp = Dispatcher(bot, storage=MemoryStorage())
db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига
work_sms = main_sms(c.token_sms) #Создаём экземпляр класса для работы с сервисом смс



@dp.message_handler(content_types=['text'])
async def text(message: types.Message):
    id_user = message.from_user.id #Записываем id пользователя (Ранее писали message.chat.id)
    if message.text == '/start':
    	await bot.send_message(id_user, 'Хай, вы попали в смс бота для работы с сайтом 365sms.ru', reply_markup=bb.mark_menu) #При команде старт отправляем приветственное сообщение и рассказываем о себе, и выводим клавиатуру
    elif message.text == 'Получить баланс':
    	balanse_sms = work_sms.get_balanse() #Запрашиваем баланс с сайта по api
    	await bot.send_message(id_user, f'Текущий баланс: {balanse_sms}₽') #Пока выводим то что получили от сайта



if __name__ == "__main__":
    executor.start_polling(dp, skip_updates=True)

Запускаем и проверяем работоспособность:

Работает, отлично, теперь давайте сделаем обработчик ошибок:

Возможные ошибки у метода гет баланс:

И так у нас получился такой код:

elif message.text == 'Получить баланс':
    	balanse_sms = work_sms.get_balanse() #Запрашиваем баланс с сайта по api
    	try:
    		await bot.send_message(id_user, f'Текущий баланс: {float(balanse_sms):.2f}₽') #Пока выводим то что получили от сайта
    	except:
    		if 'BAD_KEY' in balanse_sms:
    			await bot.send_message(id_user, 'Не правильный токен для запроса, проверьте и обновите его!') #Если указали не верный токен
    		elif 'ERROR_SQL' in balanse_sms:
    			await bot.send_message(id_user, 'Ошибка на стороне сайта поопробуйте позже!') #Если на сайте произошла ошибка
    		else:
    			await bot.send_message(id_user, 'Ваш запрос был составлен не правильно!') #Если мы не правильно составили запрос (в уроке такого не будет)

Давайте впишем не правильный токен в конфиг -> токен смс

Запускаем и проверяем обработку ошибок:

Всё работает, мы молодцы!

Давайте добавим инлайн кнопку к сообщению с балансом (обновить)

Сделаем интересную систему и добавим время к сообщению:

Добавим импорты модулей для работы со временем:

from datetime import datetime
import pytz

Создадим функцию которая поможет нам получать время в Москве (в формате Часы:Минуты:Секунды):

def time_Moscow():
	# Устанавливаем часовой пояс Москвы
	moscow_tz = pytz.timezone('Europe/Moscow')

	# Получаем текущее время в часовом поясе Москвы
	moscow_time = datetime.now(moscow_tz)

	# Форматируем время в часы:минуты:секунды
	formatted_time = moscow_time.strftime('%H:%M:%S')
	return str(formatted_time) #Возвращаем строку с временем

Обновим обработчик кнопки получить баланс:

elif message.text == 'Получить баланс':
    	balanse_sms = work_sms.get_balanse() #Запрашиваем баланс с сайта по api
    	time_msk = time_Moscow() #Получаем время мск
    	try:
    		await bot.send_message(id_user, f'<b>[{time_msk}]</b> Текущий баланс: {float(balanse_sms):.2f}₽', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    		InlineKeyboardButton(text='Обновить', callback_data='new_balance'))) #Пока выводим то что получили от сайта
    	except:
    		if 'BAD_KEY' in balanse_sms:
    			await bot.send_message(id_user, 'Не правильный токен для запроса, проверьте и обновите его!') #Если указали не верный токен
    		elif 'ERROR_SQL' in balanse_sms:
    			await bot.send_message(id_user, 'Ошибка на стороне сайта поопробуйте позже!') #Если на сайте произошла ошибка
    		else:
    			await bot.send_message(id_user, 'Ваш запрос был составлен не правильно!') #Если мы не правильно составили запрос (в уроке такого не будет)

Добавлено:

1. Получение времени в Москве
2. Вывод времени и баланса c кнопкой обновить

await bot.send_message(id_user, f'<b>[{time_msk}]</b> Текущий баланс: {float(balanse_sms):.2f}₽', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    		InlineKeyboardButton(text='Обновить', callback_data='new_balance'))) #Пока выводим то что получили от сайта

Давайте напишем обработчик инлайн кнопок и напишем обработку нажатия кнопки обновить:

@dp.callback_query_handler(lambda call: True, state='*')
async def callback_inline(call, state: FSMContext):
    id_user = call.from_user.id
    if call.data == 'new_balance':
    	time_msk = time_Moscow() #Получаем время мск
    	balanse_sms = work_sms.get_balanse() #Запрашиваем баланс с сайта по api
    	await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=f'{call.message.html_text}\n<b>[{time_msk}]</b> Текущий баланс: {float(balanse_sms):.2f}₽', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    		InlineKeyboardButton(text='Обновить', callback_data='new_balance')))

1. edit_message_text - с помощью этого метода у бота, мы будем редактировать сообщение

Давайте проверим как это работает:

Время работает, а что на счёт кнопки обновить?

Тоже работает, отлично!

Давайте добавим кнопку получить номер?

Конечно давайте, я вас не буду спрашивать а просто напишу)

Признайся, улыбнулся?)

В файл test.py меняем код на:

mainy = [['Получить баланс', 'Получить номер']]
mark_menu = ReplyKeyboardMarkup(mainy, resize_keyboard=True)

Напишем обработчик новой кнопки:

elif message.text == 'Получить номер':
    	#Будем получать номер для вк без оператора и регистрироваться через бота (Страну возьмём индонезию потому что дёшево ID: 6)
    	number = work_sms.new_number(servis='vk', strana=6)
    	#Обработаем ошибки:
    	if number == 'NO_NUMBERS': #Если пришёл ответ что нет номеров
    		await bot.send_message(id_user, 'Нет номеров с заданными параметрами, попробуйте позже, или поменяйте оператора, страну', reply_markup=bb.mark_menu)
    	elif number == 'NO_BALANCE': #Если на балансе не хватает денег на номер телефона
    		await bot.send_message(id_user, 'Закончились деньги на аккаунте', reply_markup=bb.mark_menu)
    	elif number == 'WRONG_SERVICE': #Если не правильно указали "servis"
    		await bot.send_message(id_user, 'Неверный идентификатор сервиса', reply_markup=bb.mark_menu)
    	else: #Если номер упешно получен
    		#В ответе будет такой формат: ACCESS_NUMBER:ID:NUMBER - Пример: ACCESS_NUMBER:234242:79123456789
    		#Делим ответ на список:
    		info_number = number.split(':')
    		#Итоговый список будет выглядеть так: ['ACCESS_NUMBER', 'ID', 'NUMBER'] - Пример: ['ACCESS_NUMBER', '234242', '79123456789']
    		#Индексы списка начинаються с 0
    		#т.е с индексом 0 - 'ACCESS_NUMBER', c индексом 1 - 'ID', c индексом 2 - 'NUMBER'
    		#Отправляем данные пользователю:
    		await bot.send_message(id_user, f'ID номера: {info_number[1]}\nНомер: <code>{info_number[2]}</code>', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    			InlineKeyboardButton(text='Изменить статус', callback_data=f'new_status_{info_number[1]}'))) #Передаём id номера в callback_data

Давайте добавим кнопки к последнему сообщению для работы с номером, например сделаем кнопку для обновления статуса:

await bot.send_message(f'ID номера: {info_number[1]}\nНомер: <code>{info_number[2]}</code>', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    			InlineKeyboardButton(text='Изменить статус', callback_data=f'new_status_{info_number[1]}'))) #Передаём id номера в callback_data

Давайте напишем обработчик нажатия этой кнопки:

elif 'new_status_' in call.data: #В call.data содержиться callback_data
    	id_number = int(call.data.replace('new_status_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
		#Грубыми словами с помощью replace мы заменяем new_status_ на ничего
		#Отправим клавиатуру с дальнейшими статусами, перед этим проверив текущий статус номера

Сейчас нам нужно проверить текущий статус номера:

elif 'new_status_' in call.data: #В call.data содержиться callback_data
    	id_number = int(call.data.replace('new_status_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
    	#Грубыми словами с помощью replace мы заменяем new_status_ на ничего
    	#Отправим клавиатуру с дальнейшими статусами, перед этим проверив текущий статус номера
    	status_number = work_sms.get_status(idi=id_number)
    	#Давайте в зависимости от статуса выведем клавиатуру:
    	if status_number == 'STATUS_WAIT_CODE': #Данный статус будет после получения номера он означает "Ожидание смс"
    		await call.answer('Текущий статус: Ожидает смс', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	elif status_number == 'STATUS_CANCEL': #Данный статус будет после отмены номера он означает "Активация отменена"
    		await call.answer('Текущий статус: Активация отменена', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	else: #Т.к. больше статусов которые может вернуть сайт нет, будем обабатывать успешное получение смс
    		#Делим полученное сообение на список с помощью split
    		kode_aktivate = status_number.split(':') #Получили список ["STATUS_OK", "CODE"]
    		await call.answer(f'Текущий статус: Смс получено\nКод: {kode_aktivate[1]}', show_alert=True)

Давайте обозначим каждый статус своей цифрой:

elif 'new_status_' in call.data: #В call.data содержиться callback_data
    	id_number = int(call.data.replace('new_status_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
    	#Грубыми словами с помощью replace мы заменяем new_status_ на ничего
    	#Отправим клавиатуру с дальнейшими статусами, перед этим проверив текущий статус номера
    	status_number = work_sms.get_status(idi=id_number)
    	#Давайте в зависимости от статуса выведем клавиатуру:
    	if status_number == 'STATUS_WAIT_CODE': #Данный статус будет после получения номера он означает "Ожидание смс"
    		int_status = 0 #Поставим 0 будет означать что номер только что получен
    		await call.answer('Текущий статус: Ожидает смс', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	elif status_number == 'STATUS_CANCEL': #Данный статус будет после отмены номера он означает "Активация отменена"
    		int_status = 1 #Поставим 1 будет означать что номер больше не активен (отменён)
    		await call.answer('Текущий статус: Активация отменена', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	else: #Т.к. больше статусов которые может вернуть сайт нет, будем обабатывать успешное получение смс
    		#Делим полученное сообение на список с помощью split
    		kode_aktivate = status_number.split(':') #Получили список ["STATUS_OK", "CODE"]
    		int_status = 2 #Поставим 2 будет означать что смс получен
    		await call.answer(f'Текущий статус: Смс получено\nКод: {kode_aktivate[1]}', show_alert=True)

Статусы обозначили, теперь давайте под каждый статус сделаем свою клавиатуру:

elif 'new_status_' in call.data: #В call.data содержиться callback_data
    	id_number = int(call.data.replace('new_status_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
    	#Грубыми словами с помощью replace мы заменяем new_status_ на ничего
    	#Отправим клавиатуру с дальнейшими статусами, перед этим проверив текущий статус номера
    	status_number = work_sms.get_status(idi=id_number)
    	#Давайте в зависимости от статуса выведем клавиатуру:
    	if status_number == 'STATUS_WAIT_CODE': #Данный статус будет после получения номера он означает "Ожидание смс"
    		int_status = 0 #Поставим 0 будет означать что номер только что получен
    		await call.answer('Текущий статус: Ожидает смс', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	elif status_number == 'STATUS_CANCEL': #Данный статус будет после отмены номера он означает "Активация отменена"
    		int_status = 1 #Поставим 1 будет означать что номер больше не активен (отменён)
    		await call.answer('Текущий статус: Активация отменена', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	else: #Т.к. больше статусов которые может вернуть сайт нет, будем обабатывать успешное получение смс
    		#Делим полученное сообение на список с помощью split
    		kode_aktivate = status_number.split(':') #Получили список ["STATUS_OK", "CODE"]
    		int_status = 2 #Поставим 2 будет означать что смс получен
    		await call.answer(f'Текущий статус: Смс получено\nКод: {kode_aktivate[1]}', show_alert=True)
    	#Сделаем стандартную клавиатуру с дефолтной нопкой:
    	klawa = InlineKeyboardMarkup(row_width=1).add(InlineKeyboardButton(text='Узнать статус', callback_data=f'new_status_{id_number}'))
    	if int_status == 0:
    		klawa.add(InlineKeyboardButton(text='Отменить активацию', callback_data=f'cancel_akt_{id_number}'))
    	elif int_status == 1:
    		klawa.add(InlineKeyboardButton(text='Получить новый номер', callback_data='new_number'))
    	else:
    		klawa.add(InlineKeyboardButton(text='Подтвердить SMS-код и завершить активацию', callback_data=f'true_aktiv_{id_number}'),
    			InlineKeyboardButton(text='Запросить еще одну смс', callback_data=f'dop_sms_{id_number}'))
    	await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=call.message.html_text, reply_markup=klawa)

Создали и отредактировали сообщение, теперь сделаем проверку try except, т.к. aiogram не позволяет редактировать сообщение на тот же самый текст что и был (что и с кнопками):

elif 'new_status_' in call.data: #В call.data содержиться callback_data
    	id_number = int(call.data.replace('new_status_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
    	#Грубыми словами с помощью replace мы заменяем new_status_ на ничего
    	#Отправим клавиатуру с дальнейшими статусами, перед этим проверив текущий статус номера
    	status_number = work_sms.get_status(idi=id_number)
    	#Давайте в зависимости от статуса выведем клавиатуру:
    	if status_number == 'STATUS_WAIT_CODE': #Данный статус будет после получения номера он означает "Ожидание смс"
    		int_status = 0 #Поставим 0 будет означать что номер только что получен
    		await call.answer('Текущий статус: Ожидает смс', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	elif status_number == 'STATUS_CANCEL': #Данный статус будет после отмены номера он означает "Активация отменена"
    		int_status = 1 #Поставим 1 будет означать что номер больше не активен (отменён)
    		await call.answer('Текущий статус: Активация отменена', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	else: #Т.к. больше статусов которые может вернуть сайт нет, будем обабатывать успешное получение смс
    		#Делим полученное сообение на список с помощью split
    		kode_aktivate = status_number.split(':') #Получили список ["STATUS_OK", "CODE"]
    		int_status = 2 #Поставим 2 будет означать что смс получен
    		await call.answer(f'Текущий статус: Смс получено\nКод: {kode_aktivate[1]}', show_alert=True)
    	#Сделаем стандартную клавиатуру с дефолтной нопкой:
    	klawa = InlineKeyboardMarkup(row_width=1).add(InlineKeyboardButton(text='Узнать статус', callback_data=f'new_status_{id_number}'))
    	if int_status == 0:
    		klawa.add(InlineKeyboardButton(text='Отменить активацию', callback_data=f'cancel_akt_{id_number}'))
    	elif int_status == 1:
    		klawa.add(InlineKeyboardButton(text='Получить новый номер', callback_data='new_number'))
    	else:
    		klawa.add(InlineKeyboardButton(text='Подтвердить SMS-код и завершить активацию', callback_data=f'true_aktiv_{id_number}'),
    			InlineKeyboardButton(text='Запросить еще одну смс', callback_data=f'dop_sms_{id_number}'))
    	try: #Если смогли отредактировать сообщение
    		await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=call.message.html_text, reply_markup=klawa)
    	except: #Если произошла любая ошибка
    		pass

Давайте проверим что мы с вами написали:

Всё работает, а что на счёт кнопки?
Давайте проверять:

Работает и даже кнопки поменялись)

Дальше проверим получение статуса путём нажатия на кнопку:

И она работает, давайте начнём регистрировать аккаунт в вк на этот номер

И так я отправил смс на номер, давайте проверим статус

Зарегать вк не получилось, смс на номер индонезии не приходит (отменил номер на сайте), решил поменять на рф озон, меняем код:

elif message.text == 'Получить номер':
    	#Будем получать номер для вк без оператора и регистрироваться через бота (Страну возьмём индонезию потому что дёшево ID: 6)
    	number = work_sms.new_number(servis='sg', strana=0)

У рф код страны 0
У озона код sg

Получаем новый номер через бота:

Нажимаем на кнопку изменить статус

Далее отправляем смс с озона:

Ждём, нажимаем на кнопку получить смс код

Смс опять не приходит...

Решил попробовать Qiwi, и наконец то получилось, ну ладно не суть

number = work_sms.new_number(servis='qw', strana=0)

На сайте есть код из смс:

Проверим статус через бота:

Работает, и опять же кнопки поменялись

Давайте напишем обработчик кнопки "Запросить ещё одну смс"

elif 'dop_sms_' in call.data:
    	id_number = call.data.replace('dop_sms_', '')
    	await call.answer('Новый статус установлен', show_alert=True)
    	work_sms.new_status(idi=id_number, status=3) #Устанавливаем статус 3 - нужна повторная смс
    	klawa = InlineKeyboardMarkup(row_width=1).add(InlineKeyboardButton(text='Узнать статус', callback_data=f'new_status_{id_number}'),
    		InlineKeyboardButton(text='Подтвердить SMS-код и завершить активацию', callback_data=f'true_aktiv_{id_number}'))
    	await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=call.message.html_text, reply_markup=klawa)

Теперь проверим как она работает

Запросил код для отключения смс оповещений:

Ждём...
Пришёл

Проверяем в боте

Хорошо, работает)

Напишем обработчик кнопки "Подтвердить SMS-код и завершить активацию":

elif 'true_aktiv_' in call.data:
    	id_number = call.data.replace('true_aktiv_', '')
    	await call.answer('Новый статус установлен', show_alert=True)
    	work_sms.new_status(idi=id_number, status=6) #Устанавливаем статус 6 - Подтвердить SMS-код и завершить активацию
    	klawa = InlineKeyboardMarkup(row_width=1).add(InlineKeyboardButton(text='Получить новый номер', callback_data='new_number'))
    	await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=f'{call.message.html_text}\nАктивация завершена', reply_markup=klawa)

Проверяем в боте

Теперь напишем обработчик кнопки "Отменить активацию":

elif 'cancel_akt_' in call.data:
    	id_number = call.data.replace('cancel_akt_', '')
    	status_number = work_sms.new_status(idi=id_number, status=8) #Устанавливаем статус 8 - Отменить активацию
    	await call.answer('Активация отменена', show_alert=True)
    	await bot.send_message(id_user, 'Хай, вы попали в смс бота для работы с сайтом 365sms.ru', reply_markup=bb.mark_menu)

Проверить не могу, поэтому в дз будет проверить на сколько это работает, в лс пришлёте отчёт)

Давайте напишем ещё обработчик кнопки "Получить новый номер":

Кароч решил просто скопировать код из текстовой кнопки "Получить номер", а собственно почему нет?

elif call.data == 'new_number':
    	await bot.delete_message(id_user, call.message.message_id) #Удаляем сообщение
    	#Будем получать номер для вк без оператора и регистрироваться через бота (Страну возьмём индонезию потому что дёшево ID: 6)
    	number = work_sms.new_number(servis='qw', strana=0)
    	#Обработаем ошибки:
    	if number == 'NO_NUMBERS': #Если пришёл ответ что нет номеров
    		await bot.send_message(id_user, 'Нет номеров с заданными параметрами, попробуйте позже, или поменяйте оператора, страну', reply_markup=bb.mark_menu)
    	elif number == 'NO_BALANCE': #Если на балансе не хватает денег на номер телефона
    		await bot.send_message(id_user, 'Закончились деньги на аккаунте', reply_markup=bb.mark_menu)
    	elif number == 'WRONG_SERVICE': #Если не правильно указали "servis"
    		await bot.send_message(id_user, 'Неверный идентификатор сервиса', reply_markup=bb.mark_menu)
    	else: #Если номер упешно получен
    		#В ответе будет такой формат: ACCESS_NUMBER:ID:NUMBER - Пример: ACCESS_NUMBER:234242:79123456789
    		#Делим ответ на список:
    		info_number = number.split(':')
    		#Итоговый список будет выглядеть так: ['ACCESS_NUMBER', 'ID', 'NUMBER'] - Пример: ['ACCESS_NUMBER', '234242', '79123456789']
    		#Индексы списка начинаються с 0
    		#т.е с индексом 0 - 'ACCESS_NUMBER', c индексом 1 - 'ID', c индексом 2 - 'NUMBER'
    		#Отправляем данные пользователю:
    		await bot.send_message(id_user, f'ID номера: {info_number[1]}\nНомер: <code>{info_number[2]}</code>', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    			InlineKeyboardButton(text='Изменить статус', callback_data=f'new_status_{info_number[1]}'))) #Передаём id номера в callback_data

Основные методы я с вами разобрал, сможете ли вы написать текстовую кнопку которая будет красиво выводить данные из метода getPrices?

Итоговый код:

from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton, KeyboardButton, ReplyKeyboardMarkup, BotCommand, WebAppInfo
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
import config as c
import test as bb
import asyncio
import pymysql
from class_db import work_db
from module_sms import main_sms
from datetime import datetime
import pytz


bot = Bot(token=c.token_bot, parse_mode=types.ParseMode.HTML) #Берём токен бота из файла config.py который импортировали ранее в переменную c
dp = Dispatcher(bot, storage=MemoryStorage())
db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига
work_sms = main_sms(c.token_sms) #Создаём экземпляр класса для работы с сервисом смс


def time_Moscow():
	# Устанавливаем часовой пояс Москвы
	moscow_tz = pytz.timezone('Europe/Moscow')

	# Получаем текущее время в часовом поясе Москвы
	moscow_time = datetime.now(moscow_tz)

	# Форматируем время в часы:минуты:секунды
	formatted_time = moscow_time.strftime('%H:%M:%S')
	return str(formatted_time) #Возвращаем строку с временем


@dp.message_handler(content_types=['text'])
async def text(message: types.Message):
    id_user = message.from_user.id #Записываем id пользователя (Ранее писали message.chat.id)
    if message.text == '/start':
    	await bot.send_message(id_user, 'Хай, вы попали в смс бота для работы с сайтом 365sms.ru', reply_markup=bb.mark_menu) #При команде старт отправляем приветственное сообщение и рассказываем о себе, и выводим клавиатуру
    elif message.text == 'Получить баланс':
    	balanse_sms = work_sms.get_balanse() #Запрашиваем баланс с сайта по api
    	time_msk = time_Moscow() #Получаем время мск
    	try:
    		await bot.send_message(id_user, f'<b>[{time_msk}]</b> Текущий баланс: {float(balanse_sms):.2f}₽', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    		InlineKeyboardButton(text='Обновить', callback_data='new_balance'))) #Пока выводим то что получили от сайта
    	except:
    		if 'BAD_KEY' in balanse_sms:
    			await bot.send_message(id_user, 'Не правильный токен для запроса, проверьте и обновите его!') #Если указали не верный токен
    		elif 'ERROR_SQL' in balanse_sms:
    			await bot.send_message(id_user, 'Ошибка на стороне сайта поопробуйте позже!') #Если на сайте произошла ошибка
    		else:
    			await bot.send_message(id_user, 'Ваш запрос был составлен не правильно!') #Если мы не правильно составили запрос (в уроке такого не будет)
    elif message.text == 'Получить номер':
    	#Будем получать номер для вк без оператора и регистрироваться через бота (Страну возьмём индонезию потому что дёшево ID: 6)
    	number = work_sms.new_number(servis='qw', strana=0)
    	#Обработаем ошибки:
    	if number == 'NO_NUMBERS': #Если пришёл ответ что нет номеров
    		await bot.send_message(id_user, 'Нет номеров с заданными параметрами, попробуйте позже, или поменяйте оператора, страну', reply_markup=bb.mark_menu)
    	elif number == 'NO_BALANCE': #Если на балансе не хватает денег на номер телефона
    		await bot.send_message(id_user, 'Закончились деньги на аккаунте', reply_markup=bb.mark_menu)
    	elif number == 'WRONG_SERVICE': #Если не правильно указали "servis"
    		await bot.send_message(id_user, 'Неверный идентификатор сервиса', reply_markup=bb.mark_menu)
    	else: #Если номер упешно получен
    		#В ответе будет такой формат: ACCESS_NUMBER:ID:NUMBER - Пример: ACCESS_NUMBER:234242:79123456789
    		#Делим ответ на список:
    		info_number = number.split(':')
    		#Итоговый список будет выглядеть так: ['ACCESS_NUMBER', 'ID', 'NUMBER'] - Пример: ['ACCESS_NUMBER', '234242', '79123456789']
    		#Индексы списка начинаються с 0
    		#т.е с индексом 0 - 'ACCESS_NUMBER', c индексом 1 - 'ID', c индексом 2 - 'NUMBER'
    		#Отправляем данные пользователю:
    		await bot.send_message(id_user, f'ID номера: {info_number[1]}\nНомер: <code>{info_number[2]}</code>', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    			InlineKeyboardButton(text='Изменить статус', callback_data=f'new_status_{info_number[1]}'))) #Передаём id номера в callback_data


@dp.callback_query_handler(lambda call: True, state='*')
async def callback_inline(call, state: FSMContext):
    id_user = call.from_user.id
    if call.data == 'new_balance':
    	time_msk = time_Moscow() #Получаем время мск
    	balanse_sms = work_sms.get_balanse() #Запрашиваем баланс с сайта по api
    	await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=f'{call.message.html_text}\n<b>[{time_msk}]</b> Текущий баланс: {float(balanse_sms):.2f}₽', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    		InlineKeyboardButton(text='Обновить', callback_data='new_balance')))
    elif 'new_status_' in call.data: #В call.data содержиться callback_data
    	id_number = int(call.data.replace('new_status_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
    	#Грубыми словами с помощью replace мы заменяем new_status_ на ничего
    	#Отправим клавиатуру с дальнейшими статусами, перед этим проверив текущий статус номера
    	status_number = work_sms.get_status(idi=id_number)
    	#Давайте в зависимости от статуса выведем клавиатуру:
    	if status_number == 'STATUS_WAIT_CODE': #Данный статус будет после получения номера он означает "Ожидание смс"
    		int_status = 0 #Поставим 0 будет означать что номер только что получен
    		await call.answer('Текущий статус: Ожидает смс', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	elif status_number == 'STATUS_CANCEL': #Данный статус будет после отмены номера он означает "Активация отменена"
    		int_status = 1 #Поставим 1 будет означать что номер больше не активен (отменён)
    		await call.answer('Текущий статус: Активация отменена', show_alert=True) #Выводим табличку с текущим статусом (show_alert позваляет вывести табличку с кнопко "ОК")
    	else: #Т.к. больше статусов которые может вернуть сайт нет, будем обабатывать успешное получение смс
    		#Делим полученное сообение на список с помощью split
    		kode_aktivate = status_number.split(':') #Получили список ["STATUS_OK", "CODE"]
    		int_status = 2 #Поставим 2 будет означать что смс получен
    		await call.answer(f'Текущий статус: Смс получено\nКод: {kode_aktivate[1]}', show_alert=True)
    	#Сделаем стандартную клавиатуру с дефолтной нопкой:
    	klawa = InlineKeyboardMarkup(row_width=1).add(InlineKeyboardButton(text='Узнать статус', callback_data=f'new_status_{id_number}'))
    	if int_status == 0:
    		klawa.add(InlineKeyboardButton(text='Отменить активацию', callback_data=f'cancel_akt_{id_number}'))
    	elif int_status == 1:
    		klawa.add(InlineKeyboardButton(text='Получить новый номер', callback_data='new_number'))
    	else:
    		klawa.add(InlineKeyboardButton(text='Подтвердить SMS-код и завершить активацию', callback_data=f'true_aktiv_{id_number}'),
    			InlineKeyboardButton(text='Запросить еще одну смс', callback_data=f'dop_sms_{id_number}'))
    	try: #Если смогли отредактировать сообщение
    		await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=call.message.html_text, reply_markup=klawa)
    	except: #Если произошла любая ошибка
    		pass
    elif 'dop_sms_' in call.data:
    	id_number = call.data.replace('dop_sms_', '')
    	await call.answer('Новый статус установлен', show_alert=True)
    	work_sms.new_status(idi=id_number, status=3) #Устанавливаем статус 3 - нужна повторная смс
    	klawa = InlineKeyboardMarkup(row_width=1).add(InlineKeyboardButton(text='Узнать статус', callback_data=f'new_status_{id_number}'),
    		InlineKeyboardButton(text='Подтвердить SMS-код и завершить активацию', callback_data=f'true_aktiv_{id_number}'))
    	await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=call.message.html_text, reply_markup=klawa)
    elif 'true_aktiv_' in call.data:
    	id_number = call.data.replace('true_aktiv_', '')
    	await call.answer('Новый статус установлен', show_alert=True)
    	work_sms.new_status(idi=id_number, status=6) #Устанавливаем статус 6 - Подтвердить SMS-код и завершить активацию
    	klawa = InlineKeyboardMarkup(row_width=1).add(InlineKeyboardButton(text='Получить новый номер', callback_data='new_number'))
    	await bot.edit_message_text(chat_id=id_user, message_id=call.message.message_id, text=f'{call.message.html_text}\nАктивация завершена', reply_markup=klawa)
    elif 'cancel_akt_' in call.data:
    	id_number = call.data.replace('cancel_akt_', '')
    	status_number = work_sms.new_status(idi=id_number, status=8) #Устанавливаем статус 8 - Отменить активацию
    	await call.answer('Активация отменена', show_alert=True)
    	await bot.send_message(id_user, 'Хай, вы попали в смс бота для работы с сайтом 365sms.ru', reply_markup=bb.mark_menu)
    elif call.data == 'new_number':
    	await bot.delete_message(id_user, call.message.message_id) #Удаляем сообщение
    	#Будем получать номер для вк без оператора и регистрироваться через бота (Страну возьмём индонезию потому что дёшево ID: 6)
    	number = work_sms.new_number(servis='qw', strana=0)
    	#Обработаем ошибки:
    	if number == 'NO_NUMBERS': #Если пришёл ответ что нет номеров
    		await bot.send_message(id_user, 'Нет номеров с заданными параметрами, попробуйте позже, или поменяйте оператора, страну', reply_markup=bb.mark_menu)
    	elif number == 'NO_BALANCE': #Если на балансе не хватает денег на номер телефона
    		await bot.send_message(id_user, 'Закончились деньги на аккаунте', reply_markup=bb.mark_menu)
    	elif number == 'WRONG_SERVICE': #Если не правильно указали "servis"
    		await bot.send_message(id_user, 'Неверный идентификатор сервиса', reply_markup=bb.mark_menu)
    	else: #Если номер упешно получен
    		#В ответе будет такой формат: ACCESS_NUMBER:ID:NUMBER - Пример: ACCESS_NUMBER:234242:79123456789
    		#Делим ответ на список:
    		info_number = number.split(':')
    		#Итоговый список будет выглядеть так: ['ACCESS_NUMBER', 'ID', 'NUMBER'] - Пример: ['ACCESS_NUMBER', '234242', '79123456789']
    		#Индексы списка начинаються с 0
    		#т.е с индексом 0 - 'ACCESS_NUMBER', c индексом 1 - 'ID', c индексом 2 - 'NUMBER'
    		#Отправляем данные пользователю:
    		await bot.send_message(id_user, f'ID номера: {info_number[1]}\nНомер: <code>{info_number[2]}</code>', reply_markup=InlineKeyboardMarkup(row_width=1).add(
    			InlineKeyboardButton(text='Изменить статус', callback_data=f'new_status_{info_number[1]}'))) #Передаём id номера в callback_data

if __name__ == "__main__":
    executor.start_polling(dp, skip_updates=True)

Вот и дз сформировалось:

1. Проверить работу кода (если есть ошибки исправить)
2. Написать текстовую кнопку которая будет красиво выводить данные метода getPrices
3. Подключить базу данных

1. Регистрировать пользователей
2. Считать номера которые они взяли в аренду
3. Считать номера которые успешно завершили
4. Записывать номера в отдельную таблицу
1. ID номера
2. Сам номер
3. Пользователь который взял этот номер

ДЗ выполнить в течении 4х дней, так же в канале проходит голосование, что будем изучать дальше!

Спасибо за внимание

С вами был @Xacker_Name_new

Поддержка: @Bsc_Black_Secret_Club_bot

Канал: @education_python_aiogram

Давайте возьмём готовый код из предыдущего урока

from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
from aiogram.types import ReplyKeyboardRemove, InlineKeyboardMarkup, InlineKeyboardButton
from class_db import work_db #Импорируем класс для работы с базой данных из файла class_db.py
import test as bb #Импортируем файл test.py в переменную bb (мне так удобнее работать с ним)
import config as c #Импортируем файл config.py в переменную с (опять же мне так удобнее)



#Создаём класс бота и дистпетчера
bot = Bot(token=c.token, parse_mode=types.ParseMode.HTML) #Берём токен бота из файла config.py который импортировали ранее в переменную c
dp = Dispatcher(bot, storage=MemoryStorage())
db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига


class anketa(StatesGroup):
	name = State()
	floor = State()
	age = State()


class new_values(StatesGroup):
	new_value = State()


def creat_table(): #Данную функцию будем запускать при каждом запуске кода, параметры функция не принимает
	#Для начала конектимся к базе данных:
	connection = db_work.connect_db()
	if connection: #Если класс вернул конект, а не False
		#Напишем сам запрос
		creat_table_request = 'CREATE TABLE IF NOT EXISTS `ankets`(id int AUTO_INCREMENT, name varchar(32), floor varchar(10), age int, PRIMARY KEY (id));' #И так мы написали запрос, но для чего он нам?
		#Он нам для того что-бы создать таблицу для анкет где будут следующие данные: id - это будет id анкеты (число), оно будет прописываться само (из-за AUTO_INCREMENT)
		#name типа сроки длинной не более 32 символов, floor типа строки не более 10 символов и age типа числа без ограничения
		#Первичный ключ (PRIMARY KEY) — особенное поле в таблице, которое позволяет однозначно идентифицировать каждую запись в ней
		#Запрос написан, давайте его выполним:
		status = db_work.create_table(connection, creat_table_request) #Предаём необходимые данные (Конект и сам запрос)
		#Проверяем статус создания базы данных:
		if status: #Если вернуло True значит всё хорошо (выведем в консоль что запрос выполнен)
			print('Таблица успешно создана')
			#Закрываем конект
			if db_work.connect_close(connection):
				print('Конект закрыт!')
			else: #Если нам вернуло False, значит произошла ошибка, в вспомогательном классе мы прописали вывод ошибки
				print('Ошибка указана выше')
		else: #Если вернуло False, значит не удалось создать таблицу, ошибку мы так же вывели в классе
			print('Ошибка указана выше')
	else: #Если мы не смогли подключиться к базе данных, то опять же ошибка была выведена в классе
		print('Ошибка указана выше')


def insert_table(name_, floor_, age_): #Данная функция принимает имя таблицы в которую надо записать данные (Сразу скажу т.к. мы записывать будет в ankets ропишем получение данных)
	#Для начала конектимся к базе данных:
	connection = db_work.connect_db()
	if connection: #Если класс вернул конект, а не False
		#Напишем сам запрос
		insert_table_request = 'INSERT INTO ankets (name, floor, age) VALUES (%s, %s, %s);' #И так в этом запросе мы создаём запись данных
		with connection.cursor() as cursor:
			cursor.execute(insert_table_request, (name_, floor_, age_)) #Записываем данные полученные в функцию
		connection.commit() #Сохраняем изменения
		print('Данные записаны!')
		if db_work.connect_close(connection):
			print('Конект закрыт!')
		else: #Если нам вернуло False, значит произошла ошибка, в вспомогательном классе мы прописали вывод ошибки
			print('Ошибка указана выше')
	else: #Если мы не смогли подключиться к базе данных, то опять же ошибка была выведена в классе
		print('Ошибка указана выше')


@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()
	elif message.text == '/info_table':
		info_request = 'SELECT * FROM ankets WHERE id = %s'
		values = (1,)
		connection = db_work.connect_db() #Конектимся к базе данных
		if connection: #Если конект успешный
			info = db_work.info_table(connection, info_request, values)
			if info: #Если получили данные по id = 1
				await bot.send_message(message.chat.id, f'Полученные данные:\nID: {info["id"]}\nИмя: {info["name"]}\nПол: {info["floor"]}\nВозраст: {info["age"]}')
			else: #Если не смогли получить данные
				await bot.send_message(message.chat.id, 'Не удалось получить данные')
		else: #Если конект не удался
			await bot.send_message(message.chat.id, 'Не удалось подключиться к базе данных')
	elif message.text == '/new_value':
		await bot.send_message(message.chat.id, 'Введите ID для изменения возраста:')
		await new_values.new_value.set()


@dp.message_handler(state=new_values.new_value)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем ID в кеш
	await state.update_data(id_value=message.text)
	#Выводим инлайн кнопки с числами
	#Пока напишу прямо тут, в следующих уроках будем создавать функции
	await bot.send_message(message.chat.id, 'Выберите новое значение:', reply_markup=InlineKeyboardMarkup(row_width=3).add(
		InlineKeyboardButton(text='1', callback_data='new_value_1'),InlineKeyboardButton(text='2', callback_data='new_value_2'), InlineKeyboardButton(text='10', callback_data='new_value_10'),
		InlineKeyboardButton(text='25', callback_data='new_value_25')))
	#Этого достаточно



@dp.message_handler(state=anketa.name)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем имя в кеш
	await state.update_data(name=message.text)
	#Далее просим ввести пол, с выбором пола из кнопок
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=bb.menu_floor) #добавляем вывод кнопок с выбором пола
	await anketa.floor.set()


@dp.message_handler(state=anketa.floor)
async def anketa_name(message: types.Message, state: FSMContext):
	#Записываем пол в кеш
	await state.update_data(floor=message.text)
	#Далее просим ввести свой возраст
	await bot.send_message(message.chat.id, 'Введите свой возраст:', reply_markup=ReplyKeyboardRemove()) #убираем текстовую клавиатуру
	await anketa.age.set()


@dp.message_handler(state=anketa.age)
async def anketa_name(message: types.Message, state: FSMContext):
	#Получим все данные записанные в кеш
	data = await state.get_data()
	#Сортируем их по переменным
	name = data['name'] #В ковычках пишем name, потому что сами записывали в такую переменную, там может быть любая другая
	floor = data['floor'] #В ковычках пишем floor, потому что сами записывали в такую переменную, там может быть любая другая
	age = message.text #записываем ввод пользователя в переменную age
	await state.finish() #Завершаем работу с машиной состояний
	#Выведем анкету пользователю
	await bot.send_message(message.chat.id, f'Ваша анкета:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}\n\nСпасибо за уделение времени', reply_markup=bb.mark_menu) #Отправляем анкету, благодарим, и выдаём ему текстовоем меню
	#Отправим анкету администратору по его ID из config.py
	#Так же выведем ID пользователя и его юзернейм
	await bot.send_message(c.admin, f'Пользователь: {message.chat.id}\n@{message.from_user.username} заполнил анкету\nЕго данные:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}')
	insert_table(name, floor, age) #Передаём необходимые данные



@dp.callback_query_handler(lambda call: True, state='*') #Обрабатываем нажатия всех инлайн кнопок, даже когда активно ожидание ввода от пользователя
async def callback_inline(call, state: FSMContext): #В переменную call принимаем данные о нажатой кнопке
	try: #Обрабатываем ошибки, если всё успешно то мы получим переменную id_value на всю функцию
		data = await state.get_data()
		id_value = data['id_value']
		await state.finish()
	except Exception as eror: #Если будут ошибки мы их пришлём пользователю
		await bot.send_message(call.message.chat.id, f'Произошла ошибка: {eror}')
		return #Останавливаем выполнение функции
	#Приступим к обработке нажатия кнопок, т.к. у нас записано новое чило в callback_data, но начало одно и тоже
	#Нам нужно проверять есть ли в нажатой кнопке начало:
	if 'new_value_' in call.data: #В call.data содержиться callback_data
		new_value = int(call.data.replace('new_value_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
		#Грубыми словами с помощью replace мы заменяем new_value_ на ничего
		#Теперь давайте заменим значение в таблице по ID которое вписали изначально
		#Конектимся к базе данных:
		connection = db_work.connect_db()
		if connection: #Если конект успешен
			#Возпользуемся функцией edit_table из вспомогательного класса:
			new_value_request = 'UPDATE ankets SET age = %s WHERE id = %s'
			values = (new_value, int(id_value))
			status = db_work.edit_table(connection, new_value_request, values)
			if status: #Если успешно обновили данные
				await bot.send_message(call.message.chat.id, f'Данные для строки с ID: {id_value}\nУспешно обновлены на: {new_value}')
			else: #Если произошла ошибка
				await bot.send_message(call.message.chat.id, 'Произошла ошибка, она отобразилась в консоли!')
		else: #Если не удалось подключиться к базе данных
			await bot.send_message(call.message.chat.id, 'Не удалось подключиться к базе данных!')


if __name__ == "__main__": #Если скрипт запущен с этого файла, запускаем executor
	creat_table() #Запускаем функцию создания таблицы
	executor.start_polling(dp, skip_updates=True) #skip_updates=True - нужен для того чтобы не обрабатывать сообщения которые были присланы пользователем в тот момент когда бот был выключен

Добавим обработку команды "/delete_strok_table":

@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()
	elif message.text == '/info_table':
		info_request = 'SELECT * FROM ankets WHERE id = %s'
		values = (1,)
		connection = db_work.connect_db() #Конектимся к базе данных
		if connection: #Если конект успешный
			info = db_work.info_table(connection, info_request, values)
			if info: #Если получили данные по id = 1
				await bot.send_message(message.chat.id, f'Полученные данные:\nID: {info["id"]}\nИмя: {info["name"]}\nПол: {info["floor"]}\nВозраст: {info["age"]}')
			else: #Если не смогли получить данные
				await bot.send_message(message.chat.id, 'Не удалось получить данные')
		else: #Если конект не удался
			await bot.send_message(message.chat.id, 'Не удалось подключиться к базе данных')
	elif message.text == '/new_value':
		await bot.send_message(message.chat.id, 'Введите ID для изменения возраста:')
		await new_values.new_value.set()
	elif message.text == '/delete_strok_table':
		await bot.send_message(message.chat.id, 'Введите ID для удаления:')

Создадим класс для ожидания ответа от пользователя:

class delete_strok_table(StatesGroup):
	id_strok = State()


@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()
	elif message.text == '/info_table':
		info_request = 'SELECT * FROM ankets WHERE id = %s'
		values = (1,)
		connection = db_work.connect_db() #Конектимся к базе данных
		if connection: #Если конект успешный
			info = db_work.info_table(connection, info_request, values)
			if info: #Если получили данные по id = 1
				await bot.send_message(message.chat.id, f'Полученные данные:\nID: {info["id"]}\nИмя: {info["name"]}\nПол: {info["floor"]}\nВозраст: {info["age"]}')
			else: #Если не смогли получить данные
				await bot.send_message(message.chat.id, 'Не удалось получить данные')
		else: #Если конект не удался
			await bot.send_message(message.chat.id, 'Не удалось подключиться к базе данных')
	elif message.text == '/new_value':
		await bot.send_message(message.chat.id, 'Введите ID для изменения возраста:')
		await new_values.new_value.set()
	elif message.text == '/delete_strok_table':
		await bot.send_message(message.chat.id, 'Введите ID для удаления:')
		await delete_strok_table.id_strok.set()

Добавим обработчик ввода пользователя:

@dp.message_handler(state=delete_strok_table.id_strok)
async def anketa_name(message: types.Message, state: FSMContext):
	await state.finish() #Завершаем работу с машиной состояний
	id_strok = message.text
	connection = db_work.connect_db()
	if connection: #Если класс вернул конект, а не False
		#Напишем сам запрос
		delete_table = 'DELETE FROM ankets WHERE id = %s'
		values = (id_strok,)
		status = db_work.delete_from_table(connection, delete_table, values)
		if status: #Если успешно обновили данные
			await bot.send_message(message.chat.id, f'Данные строки с ID: {id_strok} - Удалены!')
		else: #Если произошла ошибка
			await bot.send_message(message.chat.id, 'Произошла ошибка, она отобразилась в консоли!')
	else:
		await bot.send_message(message.chat.id, 'Не удалось подключиться к базе данных!')

Так же давайте перепишем функцию "delete_from_table":

	def delete_from_table(self, connection, delete_, values): #Функция для редактирования данных в таблице, в delete_ будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(delete_, values)
			connection.commit()
			return True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

У нас в базе есть запись с ID: 1

Давайте запустим бота, и удалим её:

У нас всё работает, мы молодцы, так держать!

———————————————————————————————

По итогам опроса на канале, я понял что вам интересна работа с файлами .txt

Давайте немного изучим циклы:

Цикл while True
Данный цикл позволяет выполнять код пока мы не завершим цикл, пример:

#обозначим переменную a = 0
a = 0
#Создадим цикл, и заставим его завешиться толькко после того как переменна a будет равна 5
while True:
   print(a)
   if a == 5:
      print('Цикл завершён')
      break
   a += 1 #После каждого круга добавляем к переменной a 1
   # "a +=1 " сокращение кода: a = a + 1
#Вывод в консоль будет:
#1
#2
#3
#4
#5
#Цикл завершён

Следующий цикл for i in spisok
Данный цикл перебирает все данные из переменной spisok в переменную i, после чего завершается, пример:

spisok = [1, 2, 3, 4, 5]
for i in spisok:
    print(i)
print('Цикл завершён')
#Вывод в консоль:
#1
#2
#3
#4
#5
#Цикл завершён

И так мы изучили базовые циклы, на простых примерах, перейдём к файлам .txt:

Давайте напишем код который создаст файл index.txt, затем запишем в него данные из списка:

spisok = [1, 2, 3, 4, 5, 6]

my_file = open("index.txt", "w+") #Создали файл
for i in spisok:
   my_file.write(str(i)) #Записываем данные, меняя тип данных на строку (str)
my_file.close() #После записи, закрываем его

После чего у нас появился файл "index.txt"

Открываем его:

Данные записались в 1 строку, давайте это исправим, и запишем каждую цифру из списка в новой строке:

spisok = [1, 2, 3, 4, 5, 6]

my_file = open("index.txt", "w+") #Создали файл
for i in spisok:
   my_file.write(f'{i}\n') #Записываем данные, меняя тип данных на строку (str)
my_file.close() #После записи, закрываем его

Удаляем файл index.txt, и снова запускаем файл с кодом:

У нас всё так же появился файл index.txt, открываем его:

Успешно записали, теперь давайте прочитаем данные и выведем в консоль:

my_file = open("index.txt", "r") #Открываем файл на чтение
for line in my_file:
   print(line)
my_file.close()

Вывод в консоль:

Он так же выводит нам пустые строки (\n), давайте удалим их:

my_file = open("index.txt", "r") #Создали файл
for line in my_file:
   print(line.replace('\n', ''))
my_file.close()

Вывод в консоль:

Давайте разберём ещё 1 цикл, для удобства:

with open('index.txt', 'r') as file: #Открываем файл на чтение, в переменную file
   #После открытия файла через этот цикл нам не нужно будет его закрывать каждый раз

Напишем код который прочитает первые 3 строки файла:

# Открываем файл для чтения
with open('index.txt', 'r') as file:
    # Читаем все строки из файла
    all_lines = file.readlines()

# Выбираем первые три строки
first_three_lines = all_lines[:3]

# Выводим прочитанные строки
for line in first_three_lines:
    print(line.replace('\n', '')) #Удаляя \n

Вывод в консоль:

А теперь давайте выведем последние 3 строки:

Пишем тот же код но меняем 1 участок:

# Открываем файл для чтения
with open('index.txt', 'r') as file:
    # Читаем все строки из файла
    all_lines = file.readlines()

# Выбираем последние три строки
first_three_lines = all_lines[-3:]

# Выводим прочитанные строки
for line in first_three_lines:
    print(line.replace('\n', '')) #Удаляя \n

Вывод в консоль:

Подробнее с работой с файлами .txt вы можете ознакомиться на сайте: *КЛИКАБЕЛЬНО*

В канале в комментариях напишите что вам было бы ещё интересно...

Спасибо за внимание

С вами был @Xacker_Name_new

Поддержка: @Bsc_Black_Secret_Club_bot

Канал: @education_python_aiogram

Её можно скачать по ссылке - *КЛИКАБЕЛЬНО*

При установке, выбираем Modify

Далее нажимаем везде "Next"

Вроде разобрались (если не помогло прошу написать мне в личные сообщения: @Xacker_Name_new

-------------------------------------------------------------------------

Давайте начнём работать с базой данных, с помощью вспомогательного класса work_db из файла class_db.py мы будем записывать все анкеты в базу данных.

Возьмём код бота из Урока #2

from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
from aiogram.types import ReplyKeyboardRemove
from class_db import work_db #Импорируем класс для работы с базой данных из файла class_db.py
import test as bb #Импортируем файл test.py в переменную bb (мне так удобнее работать с ним)
import config as c #Импортируем файл config.py в переменную с (опять же мне так удобнее)



#Создаём класс бота и дистпетчера
bot = Bot(token=c.token) #Берём токен бота из файла config.py который импортировали ранее в переменную c
dp = Dispatcher(bot)
db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига


class anketa(StatesGroup):
	name = State()
	floor = State()
	age = State()




@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()


@dp.message_handler(state=anketa.name)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем имя в кеш
	await state.update_data(name=name)
	#Далее просим ввести пол, с выбором пола из кнопок
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=bb.main_floor) #добавляем вывод кнопок с выбором пола
	await anketa.floor.set()


@dp.message_handler(state=anketa.floor)
async def anketa_name(message: types.Message, state: FSMContext):
	#Записываем пол в кеш
	await state.update_data(floor=floor)
	#Далее просим ввести свой возраст
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=ReplyKeyboardRemove()) #убираем текстовую клавиатуру
	await anketa.age.set()


@dp.message_handler(state=anketa.age)
async def anketa_name(message: types.Message, state: FSMContext):
	#Получим все данные записанные в кеш
	data = await state.get_data()
	#Сортируем их по переменным
	name = data['name'] #В ковычках пишем name, потому что сами записывали в такую переменную, там может быть любая другая
	floor = data['floor'] #В ковычках пишем floor, потому что сами записывали в такую переменную, там может быть любая другая
	age = message.text #записываем ввод пользователя в переменную age
	await state.finish() #Завершаем работу с машиной состояний
	#Выведем анкету пользователю
	await bot.send_message(message.chat.id, f'Ваша анкета:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}\n\nСпасибо за уделение времени', reply_markup=bb.mark_menu) #Отправляем анкету, благодарим, и выдаём ему текстовоем меню
	#Отправим анкету администратору по его ID из config.py
	#Так же выведем ID пользователя и его юзернейм
	await bot.send_message(c.admin, f'Пользователь: {message.chat.id}\n@{message.from_user.username} заполнил анкету\nЕго данные:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}')




if __name__ == "__main__": #Если скрипт запущен с этого файла, запускаем executor
    executor.start_polling(dp, skip_updates=True) #skip_updates=True - нужен для того чтобы не обрабатывать сообщения которые были присланы пользователем в тот момент когда бот был выключен

Для начала давайте создадим функцию которая будет создавать таблицы:

def creat_table(): #Данную функцию будем запускать при каждом запуске кода, параметры функция не принимает
	#Для начала конектимся к базе данных:
	connection = db_work.connect_db()
	if connection: #Если класс вернул конект, а не False
		#Напишем сам запрос
		creat_table_request = 'CREATE TABLE IF NOT EXISTS `ankets`(id int AUTO_INCREMENT, name varchar(32), floor varchar(10), age int, PRIMARY KEY (id));' #И так мы написали запрос, но для чего он нам?
		#Он нам для того что-бы создать таблицу для анкет где будут следующие данные: id - это будет id анкеты (число), оно будет прописываться само (из-за AUTO_INCREMENT)
		#name типа сроки длинной не более 32 символов, floor типа строки не более 10 символов и age типа числа без ограничения
		#Первичный ключ (PRIMARY KEY) — особенное поле в таблице, которое позволяет однозначно идентифицировать каждую запись в ней
		#Запрос написан, давайте его выполним:
		status = db_work.create_table(connection, creat_table_request) #Предаём необходимые данные (Конект и сам запрос)
		#Проверяем статус создания базы данных:
		if status: #Если вернуло True значит всё хорошо (выведем в консоль что запрос выполнен)
			print('Таблица успешно создана')
			#Закрываем конект
			if db_work.connect_close(connection):
				print('Конект закрыт!')
			else: #Если нам вернуло False, значит произошла ошибка, в вспомогательном классе мы прописали вывод ошибки
				print('Ошибка указана выше')
		else: #Если вернуло False, значит не удалось создать таблицу, ошибку мы так же вывели в классе
			print('Ошибка указана выше')
	else: #Если мы не смогли подключиться к базе данных, то опять же ошибка была выведена в классе
		print('Ошибка указана выше')

И так давайте допишем запуск этой функции:

if __name__ == "__main__": #Если скрипт запущен с этого файла, запускаем executor
	creat_table() #Запускаем функцию создания таблицы
	executor.start_polling(dp, skip_updates=True) #skip_updates=True - нужен для того чтобы не обрабатывать сообщения которые были присланы пользователем в тот момент когда бот был выключен

Запускаем:

У меня возникла ошибка с вспомогательным классом для работы с базой данных, текст ошибки:

Traceback (most recent call last):
  File "C:\Users\ffff1\OneDrive\Рабочий стол\bot_ankets\main.py", line 14, in <module>
    db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига
              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: work_db.__init__() takes 1 positional argument but 6 were given

Это из-за того что я не написал в функции "__init__" принятие нескольких аргументов, а передаю аж 6, поэтому давайте перепишем функцию "__init__":

def __init__(self, host, port, user, password, database): #Функция для иницилизирования переменных в класс, запускать её не надо
		self.host = host
		self.port = port
		self.user = user
		self.password = password
		self.database = database

Запускаем:

...Пишет что базы нет, в таком случае в программе Workbench 8.0 CE заходим в базу которые создали в первом уроке

В строке (указанной прямоугольником пишем следующие:

CREATE DATABASE usersdb;

Должно получиться так:

Далее нажимаем на молнию (указана стрелочкой)

Красная стрелочка: нам пишет что база данных создана!
Черная стрелочка: На том месте нажимаем правой кнопкой и Refresh (У нас появляется база данных)

Далее покажу как смотреть данные из неё...

Запускаем бота:

Таблица успешно создана, и конект успешно закрыт, я считаю это успех)

Давайте напишем функцию которая будет записывать данные в таблицу:

def insert_table(name_, floor_, age_): #Данная функция принимает имя таблицы в которую надо записать данные (Сразу скажу т.к. мы записывать будет в ankets ропишем получение данных)
	#Для начала конектимся к базе данных:
	connection = db_work.connect_db()
	if connection: #Если класс вернул конект, а не False
		#Напишем сам запрос
		insert_table_request = 'INSERT INTO ankets (name, floor, age) VALUES (%s, %s, %s);' #И так в этом запросе мы создаём запись данных
		with connection.cursor() as cursor:
			cursor.execute(insert_table_request, (name_, floor_, age_)) #Записываем данные полученные в функцию
		connection.commit() #Сохраняем изменения
		print('Данные записаны!')
		if db_work.connect_close(connection):
			print('Конект закрыт!')
		else: #Если нам вернуло False, значит произошла ошибка, в вспомогательном классе мы прописали вывод ошибки
			print('Ошибка указана выше')
	else: #Если мы не смогли подключиться к базе данных, то опять же ошибка была выведена в классе
		print('Ошибка указана выше')

Функция записана, давайте её добавим вызов функции из обработчика возраста:

@dp.message_handler(state=anketa.age)
async def anketa_name(message: types.Message, state: FSMContext):
	#Получим все данные записанные в кеш
	data = await state.get_data()
	#Сортируем их по переменным
	name = data['name'] #В ковычках пишем name, потому что сами записывали в такую переменную, там может быть любая другая
	floor = data['floor'] #В ковычках пишем floor, потому что сами записывали в такую переменную, там может быть любая другая
	age = message.text #записываем ввод пользователя в переменную age
	await state.finish() #Завершаем работу с машиной состояний
	#Выведем анкету пользователю
	await bot.send_message(message.chat.id, f'Ваша анкета:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}\n\nСпасибо за уделение времени', reply_markup=bb.mark_menu) #Отправляем анкету, благодарим, и выдаём ему текстовоем меню
	#Отправим анкету администратору по его ID из config.py
	#Так же выведем ID пользователя и его юзернейм
	await bot.send_message(c.admin, f'Пользователь: {message.chat.id}\n@{message.from_user.username} заполнил анкету\nЕго данные:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}')
	insert_table(name, floor, age) #Передаём необходимые данные

Перезапускаем бота, и заполняем анкету:

Выдало ошибку:

FSMStorageWarning: You haven’t set any storage yet so no states and no data will be saved.
You can connect MemoryStorage for debug purposes or non-essential data.

Нужно добавить ещё 1 импорт в файл main.py:

from aiogram.contrib.fsm_storage.memory import MemoryStorage

Так же поменяем класс бота и диспетчера:

bot = Bot(token=c.token, parse_mode=types.ParseMode.HTML)
dp = Dispatcher(bot, storage=MemoryStorage())

Ещё я допустил ошибку в 2х обработчиках:

@dp.message_handler(state=anketa.name)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем имя в кеш
	await state.update_data(name=message.text)
	#Далее просим ввести пол, с выбором пола из кнопок
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=bb.main_floor) #добавляем вывод кнопок с выбором пола
	await anketa.floor.set()


@dp.message_handler(state=anketa.floor)
async def anketa_name(message: types.Message, state: FSMContext):
	#Записываем пол в кеш
	await state.update_data(floor=message.text)
	#Далее просим ввести свой возраст
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=ReplyKeyboardRemove()) #убираем текстовую клавиатуру
	await anketa.age.set()

Не думайте что я не мастер своего дела, по мимо уроков я ещё и работаю, учусь, и иногда бывают такие ошибки...

Давайте продолжим, запускаем бота и заполняем анкету:

И так мы успешно записали данные, давайте посмотрим их

Открываем программу (скрин)

Заходим двойным щелчком ЛКМ по базе "test_basa"

Раскрываем базу:

Разворачиваем таблицы

При наведении на таблице ankets у нас появляются кнопочки, нам нужна эта:

Нажимаем и снизу у нас есть все данные записанные в таблицу:

Молодцы, теперь давайте по команду в бота "/info_table"

Давайте перепишем функцию в вспомогательном классе:

	def info_table(self, connection, info, values): #Функция для получения данных из таблицы, в info будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(info, values)
			return cursor.fetchall()[0] #Возвращаем всё что нашли
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

Выведем все данные по ID 1
Напишем обработчик команды "/info_table":

@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()
	elif message.text == '/info_table':
		info_request = 'SELECT * FROM ankets WHERE id = %s'
		values = (1,)
		connection = db_work.connect_db() #Конектимся к базе данных
		if connection: #Если конект успешный
			info = db_work.info_table(connection, info_request, values)
			if info: #Если получили данные по id = 1
				await bot.send_message(message.chat.id, f'Полученные данные: {info}')
			else: #Если не смогли получить данные
				await bot.send_message(message.chat.id, 'Не удалось получить данные')
		else: #Если конект не удался
			await bot.send_message(message.chat.id, 'Не удалось подключиться к базе данных')

У нас получился такой код, перезапускаем бота, и проверяем работоспособность команды:

Работает отлично, но выводит данные не особо красиво, давайте исправим:

@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()
	elif message.text == '/info_table':
		info_request = 'SELECT * FROM ankets WHERE id = %s'
		values = (1,)
		connection = db_work.connect_db() #Конектимся к базе данных
		if connection: #Если конект успешный
			info = db_work.info_table(connection, info_request, values)
			if info: #Если получили данные по id = 1
				await bot.send_message(message.chat.id, f'Полученные данные:\nID: {info["id"]}\nИмя: {info["name"]}\nПол: {info["floor"]}\nВозраст: {info["age"]}')
			else: #Если не смогли получить данные
				await bot.send_message(message.chat.id, 'Не удалось получить данные')
		else: #Если конект не удался
			await bot.send_message(message.chat.id, 'Не удалось подключиться к базе данных')

Проверяем вывод, и наслаждаемся красотой:

Так то лучше не так ли?

Давайте обновим возраст с помощью инлайн кнопок?

Создаём обработчик команды "/new_value"

Но перед этим напишем класс для ввода ID записи в базе данных:

class new_values(StatesGroup):
	new_value = State()

И так продолжим писать обработчик:

@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()
	elif message.text == '/info_table':
		info_request = 'SELECT * FROM ankets WHERE id = %s'
		values = (1,)
		connection = db_work.connect_db() #Конектимся к базе данных
		if connection: #Если конект успешный
			info = db_work.info_table(connection, info_request, values)
			if info: #Если получили данные по id = 1
				await bot.send_message(message.chat.id, f'Полученные данные:\nID: {info["id"]}\nИмя: {info["name"]}\nПол: {info["floor"]}\nВозраст: {info["age"]}')
			else: #Если не смогли получить данные
				await bot.send_message(message.chat.id, 'Не удалось получить данные')
		else: #Если конект не удался
			await bot.send_message(message.chat.id, 'Не удалось подключиться к базе данных')
	elif message.text == '/new_value':
		await bot.send_message(message.chat.id, 'Введите ID для изменения возраста:')
		await new_values.new_value.set()

Пишем обработчик ввода пользователя:

@dp.message_handler(state=new_values.new_value)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем ID в кеш
	await state.update_data(id_value=message.text)
	#Выводим инлайн кнопки с числами
	#Пока напишу прямо тут, в следующих уроках будем создавать функции
	await bot.send_message(message.chat.id, 'Выберите новое значение:', reply_markup=InlineKeyboardMarkup(row_width=3).add(
		InlineKeyboardButton(text='1', callback_data='new_value_1'),InlineKeyboardButton(text='2', callback_data='new_value_2'), InlineKeyboardButton(text='10', callback_data='new_value_10'),
		InlineKeyboardButton(text='25', callback_data='new_value_25')))
	#Этого достаточно

Давайте допишем ипорт:

from aiogram.types import ReplyKeyboardRemove, InlineKeyboardMarkup, InlineKeyboardButton

Давайте ещё перепишем функцию в вспомогательном классе:

	def edit_table(self, connection, edit, values): #Функция для редактирования данных в таблице, в edit будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(edit, values)
			connection.commit()
			return True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

Теперь перейдём к обработчику нажатий на инлайн кнопки:

@dp.callback_query_handler(lambda call: True, state='*') #Обрабатываем нажатия всех инлайн кнопок, даже когда активно ожидание ввода от пользователя
async def callback_inline(call, state: FSMContext): #В переменную call принимаем данные о нажатой кнопке
	try: #Обрабатываем ошибки, если всё успешно то мы получим переменную id_value на всю функцию
		data = await state.get_data()
		id_value = data['id_value']
		await state.finish()
	except Exception as eror: #Если будут ошибки мы их пришлём пользователю
		await bot.send_message(call.message.chat.id, f'Произошла ошибка: {eror}')
		return #Останавливаем выполнение функции
	#Приступим к обработке нажатия кнопок, т.к. у нас записано новое чило в callback_data, но начало одно и тоже
	#Нам нужно проверять есть ли в нажатой кнопке начало:
	if 'new_value_' in call.data: #В call.data содержиться callback_data
		new_value = int(call.data.replace('new_value_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
		#Грубыми словами с помощью replace мы заменяем new_value_ на ничего
		#Теперь давайте заменим значение в таблице по ID которое вписали изначально
		#Конектимся к базе данных:
		connection = db_work.connect_db()
		if connection: #Если конект успешен
			#Возпользуемся функцией edit_table из вспомогательного класса:
			new_value_request = 'UPDATE ankets SET age = %s WHERE id = %s'
			values = (new_value, int(id_value))
			status = db_work.edit_table(connection, new_value_request, values)
			if status: #Если успешно обновили данные
				await bot.send_message(call.message.chat.id, f'Данные для строки с ID: {id_value}\nУспешно обновлены на: {new_value}')
			else: #Если произошла ошибка
				await bot.send_message(call.message.chat.id, 'Произошла ошибка, она отобразилась в консоли!')
		else: #Если не удалось подключиться к базе данных
			await bot.send_message(call.message.chat.id, 'Не удалось подключиться к базе данных!')

Запустим бота и проверим работоспособность:

Всё работает, кайф, давайте проверим данные через программу

Для обновления, нажимаем на кнопку:

И так, данные успешно обновлены:

На этом я предлагаю закончить наш урок)

Итоговый код который у нас полчиться:

from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
from aiogram.types import ReplyKeyboardRemove, InlineKeyboardMarkup, InlineKeyboardButton
from class_db import work_db #Импорируем класс для работы с базой данных из файла class_db.py
import test as bb #Импортируем файл test.py в переменную bb (мне так удобнее работать с ним)
import config as c #Импортируем файл config.py в переменную с (опять же мне так удобнее)



#Создаём класс бота и дистпетчера
bot = Bot(token=c.token, parse_mode=types.ParseMode.HTML) #Берём токен бота из файла config.py который импортировали ранее в переменную c
dp = Dispatcher(bot, storage=MemoryStorage())
db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига


class anketa(StatesGroup):
	name = State()
	floor = State()
	age = State()


class new_values(StatesGroup):
	new_value = State()


def creat_table(): #Данную функцию будем запускать при каждом запуске кода, параметры функция не принимает
	#Для начала конектимся к базе данных:
	connection = db_work.connect_db()
	if connection: #Если класс вернул конект, а не False
		#Напишем сам запрос
		creat_table_request = 'CREATE TABLE IF NOT EXISTS `ankets`(id int AUTO_INCREMENT, name varchar(32), floor varchar(10), age int, PRIMARY KEY (id));' #И так мы написали запрос, но для чего он нам?
		#Он нам для того что-бы создать таблицу для анкет где будут следующие данные: id - это будет id анкеты (число), оно будет прописываться само (из-за AUTO_INCREMENT)
		#name типа сроки длинной не более 32 символов, floor типа строки не более 10 символов и age типа числа без ограничения
		#Первичный ключ (PRIMARY KEY) — особенное поле в таблице, которое позволяет однозначно идентифицировать каждую запись в ней
		#Запрос написан, давайте его выполним:
		status = db_work.create_table(connection, creat_table_request) #Предаём необходимые данные (Конект и сам запрос)
		#Проверяем статус создания базы данных:
		if status: #Если вернуло True значит всё хорошо (выведем в консоль что запрос выполнен)
			print('Таблица успешно создана')
			#Закрываем конект
			if db_work.connect_close(connection):
				print('Конект закрыт!')
			else: #Если нам вернуло False, значит произошла ошибка, в вспомогательном классе мы прописали вывод ошибки
				print('Ошибка указана выше')
		else: #Если вернуло False, значит не удалось создать таблицу, ошибку мы так же вывели в классе
			print('Ошибка указана выше')
	else: #Если мы не смогли подключиться к базе данных, то опять же ошибка была выведена в классе
		print('Ошибка указана выше')


def insert_table(name_, floor_, age_): #Данная функция принимает имя таблицы в которую надо записать данные (Сразу скажу т.к. мы записывать будет в ankets ропишем получение данных)
	#Для начала конектимся к базе данных:
	connection = db_work.connect_db()
	if connection: #Если класс вернул конект, а не False
		#Напишем сам запрос
		insert_table_request = 'INSERT INTO ankets (name, floor, age) VALUES (%s, %s, %s);' #И так в этом запросе мы создаём запись данных
		with connection.cursor() as cursor:
			cursor.execute(insert_table_request, (name_, floor_, age_)) #Записываем данные полученные в функцию
		connection.commit() #Сохраняем изменения
		print('Данные записаны!')
		if db_work.connect_close(connection):
			print('Конект закрыт!')
		else: #Если нам вернуло False, значит произошла ошибка, в вспомогательном классе мы прописали вывод ошибки
			print('Ошибка указана выше')
	else: #Если мы не смогли подключиться к базе данных, то опять же ошибка была выведена в классе
		print('Ошибка указана выше')


@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()
	elif message.text == '/info_table':
		info_request = 'SELECT * FROM ankets WHERE id = %s'
		values = (1,)
		connection = db_work.connect_db() #Конектимся к базе данных
		if connection: #Если конект успешный
			info = db_work.info_table(connection, info_request, values)
			if info: #Если получили данные по id = 1
				await bot.send_message(message.chat.id, f'Полученные данные:\nID: {info["id"]}\nИмя: {info["name"]}\nПол: {info["floor"]}\nВозраст: {info["age"]}')
			else: #Если не смогли получить данные
				await bot.send_message(message.chat.id, 'Не удалось получить данные')
		else: #Если конект не удался
			await bot.send_message(message.chat.id, 'Не удалось подключиться к базе данных')
	elif message.text == '/new_value':
		await bot.send_message(message.chat.id, 'Введите ID для изменения возраста:')
		await new_values.new_value.set()


@dp.message_handler(state=new_values.new_value)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем ID в кеш
	await state.update_data(id_value=message.text)
	#Выводим инлайн кнопки с числами
	#Пока напишу прямо тут, в следующих уроках будем создавать функции
	await bot.send_message(message.chat.id, 'Выберите новое значение:', reply_markup=InlineKeyboardMarkup(row_width=3).add(
		InlineKeyboardButton(text='1', callback_data='new_value_1'),InlineKeyboardButton(text='2', callback_data='new_value_2'), InlineKeyboardButton(text='10', callback_data='new_value_10'),
		InlineKeyboardButton(text='25', callback_data='new_value_25')))
	#Этого достаточно



@dp.message_handler(state=anketa.name)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем имя в кеш
	await state.update_data(name=message.text)
	#Далее просим ввести пол, с выбором пола из кнопок
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=bb.menu_floor) #добавляем вывод кнопок с выбором пола
	await anketa.floor.set()


@dp.message_handler(state=anketa.floor)
async def anketa_name(message: types.Message, state: FSMContext):
	#Записываем пол в кеш
	await state.update_data(floor=message.text)
	#Далее просим ввести свой возраст
	await bot.send_message(message.chat.id, 'Введите свой возраст:', reply_markup=ReplyKeyboardRemove()) #убираем текстовую клавиатуру
	await anketa.age.set()


@dp.message_handler(state=anketa.age)
async def anketa_name(message: types.Message, state: FSMContext):
	#Получим все данные записанные в кеш
	data = await state.get_data()
	#Сортируем их по переменным
	name = data['name'] #В ковычках пишем name, потому что сами записывали в такую переменную, там может быть любая другая
	floor = data['floor'] #В ковычках пишем floor, потому что сами записывали в такую переменную, там может быть любая другая
	age = message.text #записываем ввод пользователя в переменную age
	await state.finish() #Завершаем работу с машиной состояний
	#Выведем анкету пользователю
	await bot.send_message(message.chat.id, f'Ваша анкета:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}\n\nСпасибо за уделение времени', reply_markup=bb.mark_menu) #Отправляем анкету, благодарим, и выдаём ему текстовоем меню
	#Отправим анкету администратору по его ID из config.py
	#Так же выведем ID пользователя и его юзернейм
	await bot.send_message(c.admin, f'Пользователь: {message.chat.id}\n@{message.from_user.username} заполнил анкету\nЕго данные:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}')
	insert_table(name, floor, age) #Передаём необходимые данные



@dp.callback_query_handler(lambda call: True, state='*') #Обрабатываем нажатия всех инлайн кнопок, даже когда активно ожидание ввода от пользователя
async def callback_inline(call, state: FSMContext): #В переменную call принимаем данные о нажатой кнопке
	try: #Обрабатываем ошибки, если всё успешно то мы получим переменную id_value на всю функцию
		data = await state.get_data()
		id_value = data['id_value']
		await state.finish()
	except Exception as eror: #Если будут ошибки мы их пришлём пользователю
		await bot.send_message(call.message.chat.id, f'Произошла ошибка: {eror}')
		return #Останавливаем выполнение функции
	#Приступим к обработке нажатия кнопок, т.к. у нас записано новое чило в callback_data, но начало одно и тоже
	#Нам нужно проверять есть ли в нажатой кнопке начало:
	if 'new_value_' in call.data: #В call.data содержиться callback_data
		new_value = int(call.data.replace('new_value_', '')) #С момощью этого кода мы получим число типа int, удалив из call.data не нужное нам
		#Грубыми словами с помощью replace мы заменяем new_value_ на ничего
		#Теперь давайте заменим значение в таблице по ID которое вписали изначально
		#Конектимся к базе данных:
		connection = db_work.connect_db()
		if connection: #Если конект успешен
			#Возпользуемся функцией edit_table из вспомогательного класса:
			new_value_request = 'UPDATE ankets SET age = %s WHERE id = %s'
			values = (new_value, int(id_value))
			status = db_work.edit_table(connection, new_value_request, values)
			if status: #Если успешно обновили данные
				await bot.send_message(call.message.chat.id, f'Данные для строки с ID: {id_value}\nУспешно обновлены на: {new_value}')
			else: #Если произошла ошибка
				await bot.send_message(call.message.chat.id, 'Произошла ошибка, она отобразилась в консоли!')
		else: #Если не удалось подключиться к базе данных
			await bot.send_message(call.message.chat.id, 'Не удалось подключиться к базе данных!')


if __name__ == "__main__": #Если скрипт запущен с этого файла, запускаем executor
	creat_table() #Запускаем функцию создания таблицы
	executor.start_polling(dp, skip_updates=True) #skip_updates=True - нужен для того чтобы не обрабатывать сообщения которые были присланы пользователем в тот момент когда бот был выключен

Я помню что не научил удалять данные с базы данных, но давайте будем честны, вы уже устали делать всё что выше, в следующем задании начнём с удаления данных!

Домашнее задание:
1. Добавить больше кнопок для изменения возраста
2. Создать функцию "creat_table_2" и создать в ней таблицу "users" в которую добавить столбцы:
1. id - как в функции "creat_table"
2. name - типа varchar длинной не более 32 символов
3. password - типа varchar длинной не более 20 символов
4. Возраст - типа int
Записывать в таблицу ничего не надо, просто создать её при запуске бота, как мы это сделали с "creat_table"

В обратной связи жду:
1. Скриншот кода с больший кол-вом кнопок
2. Скриншот кода функции "creat_table_2"
3. Скриншот с программы где видна новая таблица "users" и все столбца в ней

Выполнить ДЗ до 28.09.2023

Спасибо за внимание

С вами был @Xacker_Name_new

Поддержка: @Bsc_Black_Secret_Club_bot

Язык программирования - Далее ЯП

Операционная система - Далее ОС

Редактор кода - Далее IDE

CMD - Далее консоль

Первый урок - *Кликабельно*

В этом уроке мы научимся:

Начало

Работой с базой данных

1. Научимся записывать данные в базу
2. Научимся читать данные из базы
3. Научимся удалять данные с базы

Напишем telegram бота с логикой анкетирования

1. Сможем получить имя
2. Сможем получить пол
3. Сможем получить возраст

Работой с кнопками

1. Сделаем 2 кнопки (Заполнить анкету\Информация)
2. Сделаем текстовое меню
3. Сделаем выбор пола через текстовое меню

Начало

Для начала давайте создадим новый проект, создаём папку "bot_ankets"
В папке создадим 4 файла:
1. main.py - в него будем писать основной код бота
2. config.py - в него запишем токен бота, id админа, данные для подключения к базе данных
3. class_db.py - в него напишем вспомогательный класс для работы с базой данных
4. test.py - в нём я записываю все клавиатуры, если такое название вам не нравиться, вы можете назвать файл "keyboards.py", от названия ничего не зависит

Давайте заполним файл config.py:

token = 'Токен телеграм бота'
admin = 132 #ID админа (позже научу его получать)
host = 'localhost' #IP для подключения к базе данных (Ничего не менять, это локальный хостинг)
port = 8080 #Порт для подключения к базе данных (Ничего не меняем, мы его меняли при создании из первого урока)
user = 'root' #Пользователь для подключения к базе данных (Стандартный - root)
password = 'Password' #Пароль для подключения к базе данных (Замените на свой который вписывали на первом уроке)
database = 'test_basa' #Имя базы данных которую мы создали в первом уроке

И так мы заполнили конфиг, нажимаем сочетание клавиш ctrl+s для сохранения изменений

Далее давайте напишем вспомогательный класс для работы с базой данных в файл class_db.py:

import pymysql #Импортируем модуль pymysql который установили в первом уроке
from config import host, port, user, password, database #Импортируем из файла config.py данные для подключения к базе данных

class work_db:
	def __init__(self): #Функция для иницилизирования переменных в класс, запускать её не надо
		self.host = host
		self.port = port
		self.user = user
		self.password = password
		self.database = database

	def connect_db(self): #Функция для конекта к базе данных
		try:
			connection = pymysql.connect(
				host = self.host,
				port = self.port,
				user = self.user,
				password = self.password,
				database = self.database,
				cursorclass = pymysql.cursors.DictCursor
			)
			return connection #Если конект прошёл успешно, возвращаем переменную connection, для дальнейшей работы
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def connect_close(self, connection): #Передаём переменную connection если в коде подключились, после каждого подключения к базе данных и выполнения какого-либо когда, нужно закрывать подключение
		try:
			connection.close() #Закрываем подключение к базе данных
			return True #Если успешно закрыли подключение к базе, возвращаем True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def create_table(self, connection, creat): #Функция для создания таблице в базе данных, в creat будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(creat)
			connection.commit()
			return True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def edit_table(self, connection, edit): #Функция для редактирования данных в таблице, в edit будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(edit)
			connection.commit()
			return True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def info_table(self, connection, info): #Функция для получения данных из таблицы, в info будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(info)
			return cursor.fetchall()[0] #Возвращаем всё что нашли
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

	def delete_from_table(self, connection, delete_): #Функция для редактирования данных в таблице, в delete_ будем передавать текст запроса
		try:
			with connection.cursor() as cursor:
				cursor.execute(delete_)
			connection.commit()
			return True
		except Exception as eror:
			print(eror) #Если произошла ошибка, выводим её в консоль
			return False #Если произошла ошибка, возвращаем False

И так класс для работы с базой данных написан, опять же сохраняем данные (нажимаем сочетание клавиш ctrl+s)

Давайте заполним файл test.py записав в него клавиатуру:

from aiogram.types import KeyboardButton, ReplyKeyboardMarkup #Импортируем классы для работы с текстовым меню\текстовыми кнопками

mainy = [['Заполнить анкету'], ['Информация']] #Создайм список кнопок для текстового меню в данном примере кнопки расположены в 2 строки
#Можно использовать такой список: [['Заполнить анкету', 'Информация']] Кнопки будут расположены в 1 строку

mark_menu = ReplyKeyboardMarkup(mainy, resize_keyboard=True) #Создаём клавиатуру, передав список представленный выше
#resize_keyboard=True нужен для того что-бы кнопки были маленькие, вы можете его на вписывать и посмотреть как это будет выглядеть

И так клавиатура создана, приступим к основному коду telegram бота, писать будем в файле main.py:

Запишем нужные нам импорты:

from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
from aiogram.types import ReplyKeyboardRemove
from class_db import work_db #Импорируем класс для работы с базой данных из файла class_db.py
import test as bb #Импортируем файл test.py в переменную bb (мне так удобнее работать с ним)
import config as c #Импортируем файл config.py в переменную с (опять же мне так удобнее)

Создадим нужные нам экземпляры классов для работы:

bot = Bot(token=c.token) #Берём токен бота из файла config.py который импортировали ранее в переменную c
dp = Dispatcher(bot)
db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига

Пишем обработчик текстовых сообщений:

@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	pass

Давайте напишем логику обработки сообщений, начнём с кнопки "информация" и команду /start:

@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')

А теперь давайте напишем логику самого анкетирования

Перед началом объясню как работает if, elif, else

Допустим нам нужно проверить какое число пришло в функцию
И в зависимости от числа вернуть какой то текст

Для этого мы пишем саму функцию и запуск её с каким либо числом:

def info_number(number): #Данная функция принимает число в переменную number
    if number == 1: #Если полученное число равно одному, то возращаем слово Один
       return 'Один'
    elif number == 2: #Если же число равно двум, то возращаем слово Два
       return 'Два'
    else: #В ином случае говорим что такие числа мы не принимаем
       return 'Я не принимаю такие числа'

Ещё нам понадобиться такая вещь как машина состояний, мы её уже импортировали в начале

Давайте расскажу для чего нам машина состояний...

Она нам нужна для того что-бы работать с определённым пользователем, и определённой логикой
Это всё что нам требуется на этом этапе да и в принципе в программировании

Продолжим писать логику
Создаём класс для работы с машиной состояний:

class anketa(StatesGroup):
	name = State()
	floor = State()
	age = State()

Далее дописываем ожидание именно имени, у нас получился код:

@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем текст /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()

В файле test.py добавляем клавиатуру с выбором пола:

main_floor = [['Мужской', 'Женский']]
menu_floor = ReplyKeyboardMarkup(main_floor, resize_keyboard=True)

Далее нам нужен сам обработчик ввода пользователя:

@dp.message_handler(state=anketa.name)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем имя в кеш
	await state.update_data(name=name)
	#Далее просим ввести пол, с выбором пола из кнопок
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=bb.main_floor) #добавляем вывод кнопок с выбором пола

Пишем обработчик ввода пола:

@dp.message_handler(state=anketa.floor)
async def anketa_name(message: types.Message, state: FSMContext):
	#Записываем пол в кеш
	await state.update_data(floor=floor)
	#Далее просим ввести свой возраст
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=ReplyKeyboardRemove()) #убираем текстовую клавиатуру
	await anketa.age.set()

И наконец давайте обработаем возраст, и выведем данные которые ввёл пользователь, сначала пользователю, а затем админу по его ID из config.py

У нас получился такой код:

@dp.message_handler(state=anketa.age)
async def anketa_name(message: types.Message, state: FSMContext):
	#Получим все данные записанные в кеш
	data = await state.get_data()
	#Сортируем их по переменным
	name = data['name'] #В ковычках пишем name, потому что сами записывали в такую переменную, там может быть любая другая
	floor = data['floor'] #В ковычках пишем floor, потому что сами записывали в такую переменную, там может быть любая другая
	age = message.text #записываем ввод пользователя в переменную age
	await state.finish() #Завершаем работу с машиной состояний
	#Выведем анкету пользователю
	await bot.send_message(message.chat.id, f'Ваша анкета:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}\n\nСпасибо за уделение времени', reply_markup=bb.mark_menu) #Отправляем анкету, благодарим, и выдаём ему текстовоем меню
	#Отправим анкету администратору по его ID из config.py
	#Так же выведем ID пользователя и его юзернейм
	await bot.send_message(c.admin, f'Пользователь: {message.chat.id}\n@{message.from_user.username} заполнил анкету\nЕго данные:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}')


if __name__ == "__main__": #Если скрипт запущен с этого файла, запускаем executor
    executor.start_polling(dp, skip_updates=True) #skip_updates=True - нужен для того чтобы не обрабатывать сообщения которые были присланы пользователем в тот момент когда бот был выключен

Возможно у вас возникнет вопрос зачем я использую "\n" это для того что-бы перенести текст на 1 или более строк.

В итоге у нас получился такой код:

from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
from aiogram.types import ReplyKeyboardRemove
from class_db import work_db #Импорируем класс для работы с базой данных из файла class_db.py
import test as bb #Импортируем файл test.py в переменную bb (мне так удобнее работать с ним)
import config as c #Импортируем файл config.py в переменную с (опять же мне так удобнее)



#Создаём класс бота и дистпетчера
bot = Bot(token=c.token) #Берём токен бота из файла config.py который импортировали ранее в переменную c
dp = Dispatcher(bot)
db_work = work_db(c.host, c.port, c.user, c.password, c.database) #Создаём экземпляр класса для работы с базой данных, передав все нужные параметры из конфига


class anketa(StatesGroup):
	name = State()
	floor = State()
	age = State()

	
@dp.message_handler(content_types=['text']) #Обрабатываем каждое сообщение от пользователей, добавляем content_types для обработки текста, в будущих уроках будет фото и видео
async def text(message: types.Message): #Асинхронная функция с название "text" которая принимает в переменную message, текст пользователя отправевшего сообщение
	if message.text == '/start':
		await bot.send_message(message.chat.id, 'Привет, заполни анкету, или посмотри информацйию о мне', reply_markup=bb.mark_menu) #Обрабатываем команду /start и выводим клавиатуру из файлы test.py
	elif message.text == 'Информация':
		await bot.send_message(message.chat.id, f'Сюда пишем какую либо информацию, например я хочу вывести ID пользователя\nТвой ID: {message.chat.id}')
	elif message.text == 'Заполнить анкету':
		await bot.send_message(message.chat.id, 'Введите своё имя:')
		await anketa.name.set()


@dp.message_handler(state=anketa.name)
async def anketa_name(message: types.Message, state: FSMContext): #Как видите у нас добавился FSMContext, он нам нужен как раз для обработки машины состояния
	#Записываем имя в кеш
	await state.update_data(name=message.text)
	#Далее просим ввести пол, с выбором пола из кнопок
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=bb.main_floor) #добавляем вывод кнопок с выбором пола
	await anketa.floor.set()


@dp.message_handler(state=anketa.floor)
async def anketa_name(message: types.Message, state: FSMContext):
	#Записываем пол в кеш
	await state.update_data(floor=message.text)
	#Далее просим ввести свой возраст
	await bot.send_message(message.chat.id, 'Выберите свой пол:', reply_markup=ReplyKeyboardRemove()) #убираем текстовую клавиатуру
	await anketa.age.set()


@dp.message_handler(state=anketa.age)
async def anketa_name(message: types.Message, state: FSMContext):
	#Получим все данные записанные в кеш
	data = await state.get_data()
	#Сортируем их по переменным
	name = data['name'] #В ковычках пишем name, потому что сами записывали в такую переменную, там может быть любая другая
	floor = data['floor'] #В ковычках пишем floor, потому что сами записывали в такую переменную, там может быть любая другая
	age = message.text #записываем ввод пользователя в переменную age
	await state.finish() #Завершаем работу с машиной состояний
	#Выведем анкету пользователю
	await bot.send_message(message.chat.id, f'Ваша анкета:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}\n\nСпасибо за уделение времени', reply_markup=bb.mark_menu) #Отправляем анкету, благодарим, и выдаём ему текстовоем меню
	#Отправим анкету администратору по его ID из config.py
	#Так же выведем ID пользователя и его юзернейм
	await bot.send_message(c.admin, f'Пользователь: {message.chat.id}\n@{message.from_user.username} заполнил анкету\nЕго данные:\n\nИмя: {name}\nПол: {floor}\nВозраст: {age}')


if __name__ == "__main__": #Если скрипт запущен с этого файла, запускаем executor
    executor.start_polling(dp, skip_updates=True) #skip_updates=True - нужен для того чтобы не обрабатывать сообщения которые были присланы пользователем в тот момент когда бот был выключен

Работу с базой данных я перенёс на третий урок, потому что информация для некоторых новая, и её достаточно много для новичка, поэтому ожидайте третий урок

В третьей части мы научимся работать с:

1. Работой с базой данных
1. Научимся записывать данные в базу
2. Научимся читать данные из базы
3. Научимся удалять данные с базы
2. Работой с кнопками
1. Сделаем инлайн кнопки (Расскажу и покажу что это и с чем это едят)
2. Сделаем обработку таких кнопок, сделаем им не сложную логику

Так же советую посмотреть мою статью по форматированию сообщений - *КЛИКАБЕЛЬНО*

Но для них нам придётся переписать строку

bot = Bot(token=c.token)

На:

bot = Bot(token=c.token, parse_mode=types.ParseMode.HTML)

Как видим у нас добавился parse_mode, это как раз для обработки HTML тегов в сообщениях...

Домашнее задание:

1. Выдели сообщения (запрос имени, пола, возраста) в жирный шрифт
(по желанию можешь добавить наклонный текст)
2. Так же выдели в итоговой анкете, ID пользователя (само число)
в Текст для лёгкого копирования (Моноширинный)
(и у пользователя и у админа)

В обратной связи жду:
1. Скриншот кода где видно, как реализовано выделение текста
2. Скриншот с telegram бота, где видно заполнение анкеты + выделения текстов
3. Скриншот с telegram бота где видна конечная анкета (у пользователя и админа)
Прислать можно: @Xacker_Name_new

Спасибо за внимание

С вами был @Xacker_Name_new

Поддержка: @Bsc_Black_Secret_Club_bot

Язык программирования - Далее ЯП

Операционная система - Далее ОС

Редактор кода - Далее IDE

CMD - Далее консоль

Использовать будет такую ЯП как Python (советую версию 3.10) — *КЛИКАБЕЛЬНО*: Выбирайте свою ОС

После того как скачали установочный файл, при установке нужно поставить галочку со словом PATH:

Открываем консоль комбинация клавиш на клавиатуре: Win+R

В открывшемся окне пишем "cmd"

Вводим команды по порядку:

Немножко расскажу про модули которые мы установили:

aiogram - Он нам нужен для работы с api telegram ботов

asyncio - Он нам нужен для ожидания (подобие модуля time, только time останавливает выполнение остального кода, а asyncio нет)

pymysql - Он нам нужен для работы с базой данных которую мы создадим далее

Скачиваем IDE которым пользуюсь я - *КЛИКАБЕЛЬНО*

Скачиваем MySQLServer - *КЛИКАБЕЛЬНО*

При установке нажимаем везде далее

Добавлено: Если у вас не появилась программа показанная ниже, установить ей: *КЛИКАБЕЛЬНО*

После установки у нас должна быть такая программа:

После запуска, должно быть что то такое:

Нажимаем на плюсик (указан стрелочкой)

Connection Name - Имя базы данных, по которому будем в будущем подключаться к базе данных (Напишу test_basa)

Connection Method - Метод подключения (Не трогаем)

Hostname - Имя хоста для подключения (Не трогаем потому что нам нужна база данных на локальном хосте) 127.0.0.1 - это и есть локальный хост

Port - Порт для подключения к базе данных (Меняем на 8080)

Username - Имя пользователя по которому будем подключаться к базе данных

Password - Пароль для подключения, если вы его не знаете сначала нажимаете на кнопку "Clear" -> "Store in Vault"

Вводим пароль в этом поле и нажимаем "OK"

После ввода пароля нажимаем на "Test Connection"

Должно появиться такое окошко:

Если вы не поменяли порт на 8080 то будет такое окошко:

Если же поменяв порт на 8080, у вас осталось такое окно, то поменяйте на порт 3306, и попробуйте снова

и так мы настроили базу, осталось её создать (Нажимаем на OK)

У нас появилась база данных:

В будущем через код мы сможем к ней подключиться...

Давайте мы с вами посмотрим несколько уроков по aiogram:

1. Создание бота через BotFather
2. Пишем код простого Эхо бота (Эхо бот - бот которому ты пишешь сообщение, он тебе отправляет твой текст)

После просмотра 2 ролика у нас получился код:

from aiogram import Bot, types
from aiogram.dispatcher import Dispatcher
from aiogram.utils import executor

bot = Bot(token='Токен вашего бота')
dp = Dispatcher(bot)

@dp.message_handler()
async def echo(message: types.Message):
    await message.answer(message.text)


executor.start_polling(dp, skip_updates=True)

Давайте я подправлю код и напишу комментарии к некоторым участкам кода:

from aiogram import Bot, types, Dispatcher
from aiogram.utils import executor


bot = Bot(token='Токен вашего бота')
dp = Dispatcher(bot)


@dp.message_handler() #Обрабатываем каждое сообщение от пользователей 
async def echo(message: types.Message): #Асинхронная функция с название "echo" которая принимает в переменную message, текст пользователя отправевшего сообщение
    await message.answer(message.text) #Отправляет сообщение пользователя обратно ему
    #Так же можно использовать: await bot.send_message(message.chat.id, messgae.text)
    #Отправляет сообщение пользователя обрано, но с помощью этой конструкции мы можем отправлять сообщение любому пользователю по его id


if __name__ == "__main__": #Если скрипт запущен с этого файла, запускаем executor
    executor.start_polling(dp, skip_updates=True) #skip_updates=True - нужен для того чтобы не обрабатывать сообщения которые были присланы пользователем в тот момент когда бот был выключен

И так у нас получился переработанный код

Для запуска подобных скриптов, нам нужна будет консоль (WIN+R -> cmd)

В консоль пишем команду:

cd C:\путь\до\папки\с\ботом\

Скопировать его можно тут:

Далее мы перешли в директорию с ботом

Пишем в консоль:

python main.py

После чего ждём запуска, после запуска мы видим в консоли текст:

Updates were skipped successfully.

Это означает что бот успешно запущен!

Во второй части мы научимся работать с:

1. Работой с базой данных
1. Научимся записывать данные в базу
2. Научимся читать данные из базы
3. Научимся удалять данные с базы
2. Напишем telegram бота с логикой анкетирования
1. Сможем получить имя
2. Сможем получить пол
3. Сможем получить возраст
3. Работой с кнопками
1. Сделаем 2 кнопки (Заполнить анкету\Информация)
2. Сделаем текстовое меню
3. Сделаем выбор пола через текстовое меню

Спасибо за внимание

С вами был @Xacker_Name_new

Поддержка: @Bsc_Black_Secret_Club_bot