Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

так, смотри, мне нужно исправить этот код, изначально я его делал так, чтобы он работал…

  1. User

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

    bot/api.py

    import aiohttp import logging import json from typing import Optional, Dict

    logger = logging.getLogger(name)

    BASE_URL = "https://smshub.org/stubs/handler_api.php"

    class SmsHubAPI: def init(self, api_key: str): self.api_key = api_key

    async def get_balance(self) -> Optional[str]:
        """Запрос баланса с заданной валютой (RUB)."""
        logger.info("Запрос баланса с валютой: 643")
        params = {
            "api_key": self.api_key,
            "action": "getBalance",
            "currency": "643"
        }
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                if response.status == 200:
                    text = await response.text()
                    logger.info(f"Ответ баланса: {text}")
                    return text
                else:
                    logger.error(f"Ошибка при запросе баланса: {response.status} - {text}")
                    return None
    
    async def get_number(self, service: str, country: str = "0", operator: Optional[str] = None, max_price: Optional[float] = None) -> Optional[str]:
        """Получение номера для указанного сервиса и страны."""
        logger.info(f"Запрос номера для сервиса: {service}, страна: {country}, оператор: {operator}, макс. цена: {max_price}, валюта: 643")
        params = {
            "api_key": self.api_key,
            "action": "getNumber",
            "service": service,
            "country": country,
            "currency": "643"
        }
        if operator and operator != "any":
            params["operator"] = operator
        if max_price:
            params["maxPrice"] = max_price
    
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                text = await response.text()
                if response.status == 200:
                    logger.info(f"Ответ номера: {text}")
                    return text
                logger.error(f"Ошибка при запросе номера: {response.status} - {text}")
                return None
    
    async def get_price_for_service(self, service: str, country: str = "0") -> Optional[Dict]:
        """Получение цен для указанного сервиса."""
        logger.info(f"Запрос цен для сервиса: {service}, страна: {country}, валюта: 643")
        params = {
            "api_key": self.api_key,
            "action": "getPrices",
            "service": service,
            "country": country,
            "currency": "643"
        }
    
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                response_text = await response.text()
                if response.status == 200:
                    try:
                        prices_data = json.loads(response_text)
                        logger.info(f"Цены для сервиса {service}: {prices_data}")
                        country_data = prices_data.get(country)
                        if not country_data:
                            logger.error(f"Страна '{country}' отсутствует в данных: {prices_data}")
                            return None
                        service_data = country_data.get(service)
                        if not service_data:
                            logger.error(f"Сервис '{service}' отсутствует среди доступных для страны '{country}'. Данные: {country_data}")
                            return None
                        return service_data  # Возвращает словарь { "Цена": Количество }
                    except json.JSONDecodeError:
                        logger.error(f"Ошибка парсинга JSON: {response_text}")
                        return None
                else:
                    logger.error(f"Ошибка при запросе цен: {response.status} - {response_text}")
                    return None
    
    async def get_numbers_status(self, country: str = "0", operator: Optional[str] = None) -> Optional[Dict]:
        """Получение статуса номеров по стране и оператору."""
        logger.info(f"Запрос статуса номеров для страны: {country}, оператор: {operator}")
        params = {
            "api_key": self.api_key,
            "action": "getNumbersStatus",
            "country": country
        }
        if operator and operator != "any":
            params["operator"] = operator
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                response_text = await response.text()
                if response.status == 200:
                    try:
                        numbers_status = json.loads(response_text)
                        logger.info(f"Статус номеров: {numbers_status}")
                        return numbers_status  # Возвращает словарь { "SERVICE_CODE": Количество }
                    except json.JSONDecodeError:
                        logger.error(f"Ошибка парсинга JSON: {response_text}")
                        return None
                else:
                    logger.error(f"Ошибка при запросе статуса номеров: {response.status} - {response_text}")
                    return None
    
    async def get_status(self, activation_id: str) -> Optional[str]:
        """Получение статуса активации по ID."""
        logger.info(f"Запрос статуса для активации: {activation_id}")
        params = {
            "api_key": self.api_key,
            "action": "getStatus",
            "id": activation_id
        }
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                text = await response.text()
                if response.status == 200:
                    logger.info(f"Ответ статуса: {text}")
                    return text
                logger.error(f"Ошибка при запросе статуса: {response.status} - {text}")
                return None
    
    async def set_status(self, activation_id: str, status: str) -> Optional[str]:
        """Установка статуса для активации."""
        logger.info(f"Изменение статуса активации: {activation_id} на статус {status}")
        params = {
            "api_key": self.api_key,
            "action": "setStatus",
            "id": activation_id,
            "status": status
        }
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                text = await response.text()
                if response.status == 200:
                    logger.info(f"Ответ изменения статуса: {text}")
                    return text
                logger.error(f"Ошибка при изменении статуса: {response.status} - {text}")
                return None
    
    async def cancel_activation(self, activation_id: str) -> Optional[str]:
        """Отмена активации."""
        return await self.set_status(activation_id, status="8")
    

    import asyncio import logging import time import json from pathlib import Path from typing import Optional, List, Tuple from aiogram import Dispatcher, types, F from aiogram.utils.keyboard import InlineKeyboardBuilder from aiogram.fsm.context import FSMContext from aiogram.fsm.state import State, StatesGroup

    Импорт дополнительных модулей

    from ..data import get_user_api_key, get_user_operator, get_user_country from ..api import SmsHubAPI from ..utils import get_usd_to_rub_rate, safe_edit_or_send_message from .start import send_main_menu from .activation import user_activations, poll_for_sms from ..constants.operators import OPERATOR_DISPLAY_NAMES from ..constants.countries import COUNTRIES from ..constants.services import SERVICE_DISPLAY_NAMES

    logger = logging.getLogger(name)

    class SmsOrderState(StatesGroup): waiting_for_service = State() waiting_for_max_price = State()

    SERVICES: List[Tuple[str, str]] = list(SERVICE_DISPLAY_NAMES.items()) POPULARITY_FILE = Path("service_popularity.json")

    def load_popularity_data(): if POPULARITY_FILE.exists(): with open(POPULARITY_FILE, 'r', encoding='utf-8') as f: return json.load(f) return {}

    def save_popularity_data(popularity_data): with open(POPULARITY_FILE, 'w', encoding='utf-8') as f: json.dump(popularity_data, f, ensure_ascii=False, indent=4)

    def update_service_popularity(service_code: str): popularity_data = load_popularity_data() if service_code in popularity_data: popularity_data[service_code] += 1 else: popularity_data[service_code] = 1 save_popularity_data(popularity_data)

    def get_sorted_services(): popularity_data = load_popularity_data() sorted_services = sorted(SERVICES, key=lambda service: popularity_data.get(service[0], 0), reverse=True) return sorted_services

    def get_service_pages(services: List[Tuple[str, str]], page_size: int = 18) -> List[List[Tuple[str, str]]]: pages = [] for i in range(0, len(services), page_size): pages.append(services[i:i + page_size]) return pages

    def build_service_keyboard(page_number: int = 0) -> InlineKeyboardBuilder: sorted_services = get_sorted_services() services_pages = get_service_pages(sorted_services) keyboard = InlineKeyboardBuilder()

    if page_number < len(services_pages):
        current_page = services_pages[page_number]
    
        # Добавляет кнопки сервисов в сетке 3x6
        for code, name in current_page:
            keyboard.button(text=name, callback_data=f"service_select:{code}")
        
        # Настраивает кнопки навигации
        if page_number == 0:
            # Первая страница - только кнопка "Вперед"
            keyboard.adjust(3)  # Устраиваем сервисные кнопки в 3 столбца
            keyboard.row(types.InlineKeyboardButton(text="➡️ Вперед", callback_data=f"service_page:{page_number + 1}"))
        elif page_number == len(services_pages) - 1:
            # Последняя страница - только кнопка "Назад"
            keyboard.adjust(3)
            keyboard.row(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"service_page:{page_number - 1}"))
        else:
            # Промежуточные страницы - кнопки "Назад" и "Вперед"
            keyboard.adjust(3)
            keyboard.row(
                types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"service_page:{page_number - 1}"),
                types.InlineKeyboardButton(text="➡️ Вперед", callback_data=f"service_page:{page_number + 1}")
            )
    
    # Кнопка "Назад в меню" на всех страницах
    keyboard.row(types.InlineKeyboardButton(text="🔙 Назад в меню", callback_data="back_to_main_menu"))
    
    return keyboard
    

    async def get_sms_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    user_api_key = get_user_api_key(callback_query.from_user.id)
    if not user_api_key:
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="⚙️ Настройки", callback_data="settings")
        keyboard.button(text="🔙 Назад", callback_data="back_to_main_menu")
        keyboard.adjust(1)
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Пожалуйста, сначала настройте ваш API ключ в разделе 'Настройки'.",
            state=state,
            reply_markup=keyboard.as_markup()
        )
        return
    
    logger.info(f"Пользователь {callback_query.from_user.id} начал процесс получения номера.")
    keyboard = build_service_keyboard()
    
    await state.update_data(cancel_request=False, current_task=None)
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=(
            "Выберите сервис, нажав на кнопку ниже.\n"
            "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
        ),
        state=state,
        reply_markup=keyboard.as_markup()
    )
    await state.set_state(SmsOrderState.waiting_for_service)
    

    async def go_back_to_service_selection(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") logger.info(f"Пользователь {callback_query.from_user.id} отменил операцию.")

    await state.update_data(cancel_request=True)
    
    data = await state.get_data()
    current_task = data.get('current_task')
    if current_task:
        current_task.cancel()
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=(
            "Выберите сервис, нажав на кнопку ниже.\n"
            "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
        ),
        state=state,
        reply_markup=build_service_keyboard().as_markup()
    )
    
    await state.set_state(SmsOrderState.waiting_for_service)
    

    async def back_to_main_menu(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") logger.info(f"Пользователь {callback_query.from_user.id} вернулся в главное меню.")

    await state.set_state(None)
    await send_main_menu(callback_query.message, state)
    

    async def service_page_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    page_number = int(callback_query.data.split(":")[1])
    keyboard = build_service_keyboard(page_number)
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=(
            "Выберите сервис, нажав на кнопку ниже.\n"
            "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
        ),
        state=state,
        reply_markup=keyboard.as_markup()
    )
    

    async def service_selected_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    service_code = callback_query.data.split(":")[1]
    update_service_popularity(service_code)
    
    await state.update_data(selected_service=service_code, cancel_request=False)
    task = asyncio.create_task(service_handler_logic(
        callback_query.message, state, user_id=callback_query.from_user.id, service_code=service_code, is_service_selection=True))
    await state.update_data(current_task=task)
    

    async def service_handler(message: types.Message, state: FSMContext, service_code: Optional[str] = None, user_id: Optional[int] = None): try: await message.delete() except Exception as e: logger.error(f"Не удалось удалить сообщение пользователя: {e}")

    user_input = message.text.strip().lower()
    
    if user_id is None:
        user_id = message.from_user.id
    
    logger.info(f"Пользователь {user_id} ввел сервис: {user_input}")
    
    service_code = next((code for code, name in SERVICE_DISPLAY_NAMES.items() if name.lower() == user_input or code.lower() == user_input), None)
    
    if service_code is None:
        matched_services = [(code, name) for code, name in SERVICE_DISPLAY_NAMES.items() if user_input in name.lower()]
    
        if matched_services:
            keyboard = InlineKeyboardBuilder()
            for code, name in matched_services:
                keyboard.button(text=name, callback_data=f"service_select:{code}")
    
            keyboard.adjust(3)
            keyboard.button(text="🔙 Назад", callback_data="service_page:0")
            await safe_edit_or_send_message(
                message=message,
                new_text="Пожалуйста, выберите один из представленных сервисов:",
                state=state,
                reply_markup=keyboard.as_markup()
            )
            return
        else:
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="🔙 Назад к сервисам", callback_data="service_page:0")
            await safe_edit_or_send_message(
                message=message,
                new_text="Сервис не найден. Попробуйте ввести код или полное название сервиса.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
            return
    else:
        await state.update_data(selected_service=service_code, cancel_request=False)
        task = asyncio.create_task(service_handler_logic(message, state, user_id=user_id, service_code=service_code))
        await state.update_data(current_task=task)
    

    async def service_handler_logic(message: types.Message, state: FSMContext, user_id: int, service_code: str, is_service_selection: bool = False): logger.info(f"Пользователь {user_id} выбрал сервис: {service_code}")

    user_api_key = get_user_api_key(user_id)
    user_operator = get_user_operator(user_id) or "any"
    user_country_code = get_user_country(user_id) or "0"
    country_name = COUNTRIES.get(user_country_code, user_country_code)
    
    if not user_api_key:
        await safe_edit_or_send_message(
            message=message,
            new_text="Пожалуйста, сначала настройте ваш API ключ в разделе 'Настройки'.",
            state=state
        )
        await state.set_state(None)
        await send_main_menu(message, state)
        return
    
    smshub_api = SmsHubAPI(user_api_key)
    usd_to_rub_rate = await get_usd_to_rub_rate()
    
    max_attempts = 3
    success = False
    last_exception = None
    
    try:
        for attempt in range(1, max_attempts + 1):
            data = await state.get_data()
            if data.get("cancel_request"):
                logger.info(f"Запрос для пользователя {user_id} был отменен.")
                return
    
            try:
                progress_text = f"Идет запрос {attempt}/{max_attempts}..."
                keyboard = InlineKeyboardBuilder()
                keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
                keyboard.adjust(1)
    
                await safe_edit_or_send_message(
                    message=message,
                    new_text=progress_text,
                    state=state,
                    reply_markup=keyboard.as_markup()
                )
    
                price_info = await smshub_api.get_price_for_service(service_code, country=user_country_code)
                numbers_status = await smshub_api.get_numbers_status(country=user_country_code, operator=user_operator)
    
                if data.get("cancel_request"):
                    logger.info(f"Запрос для пользователя {user_id} был отменен после получения данных.")
                    return
    
                if price_info and numbers_status:
                    service_key = f"{service_code}_0"
                    available_numbers = int(numbers_status.get(service_key, 0) or 0)
                    
                    if available_numbers > 0:
                        prices = [float(price_str) for price_str in price_info.keys() if price_str is not None]
                        if prices:
                            min_price_usd = min(prices)
                            max_price_usd = max(prices)
                            min_price_rub = min_price_usd * usd_to_rub_rate if usd_to_rub_rate else 0
                            max_price_rub = max_price_usd * usd_to_rub_rate if usd_to_rub_rate else 0
    
                            operator_display = OPERATOR_DISPLAY_NAMES.get(user_operator, user_operator)
                            service_display = SERVICE_DISPLAY_NAMES.get(service_code, service_code)
    
                            keyboard = InlineKeyboardBuilder()
                            keyboard.button(text=f"⬇️ Мин. цена ({min_price_usd:.4f}$)", callback_data=f"select_price:{min_price_usd}")
                            keyboard.button(text=f"⬆️ Макс. цена ({max_price_usd:.4f}$)", callback_data=f"select_price:{max_price_usd}")
                            keyboard.adjust(2)
                            keyboard.row(types.InlineKeyboardButton(text="❌ Отмена", callback_data="cancel_operation"))
    
                            message_text = (
                                f"*Страна:* `{country_name}`\n"
                                f"*Доступно номеров:* `{available_numbers}`\n"
                                f"*Оператор:* `{operator_display}`\n"
                                f"*Сервис:* `{service_display}`\n"
                                f"*Цены:* от `{min_price_usd:.4f}` $ (₽{min_price_rub:.2f}) до `{max_price_usd:.4f}` $ (₽{max_price_rub:.2f}).\n\n"
                                f"_Выберите максимальную допустимую стоимость покупки с помощью кнопок ниже или введите сумму вручную (например: 0.5). Все суммы указаны в долларах ($):_"
                            )
    
                            await safe_edit_or_send_message(
                                message=message,
                                new_text=message_text,
                                state=state,
                                reply_markup=keyboard.as_markup(),
                                parse_mode="Markdown"
                            )
    
                            await state.update_data(
                                service=service_code,
                                service_display=service_display,
                                country_name=country_name,
                                available_numbers=available_numbers,
                                operator_display=operator_display,
                                min_price=min_price_usd,
                                max_price_usd=max_price_usd,
                                min_price_rub=min_price_rub,
                                max_price_rub=max_price_rub,
                                usd_to_rub_rate=usd_to_rub_rate,
                                user_id=user_id
                            )
    
                            await state.set_state(SmsOrderState.waiting_for_max_price)
                            success = True
                            break
                        else:
                            logger.info(f"Попытка {attempt}: Цены не найдены.")
                            last_exception = "Цены не найдены"
                    else:
                        logger.info(f"Попытка {attempt}: Нет доступных номеров.")
                        last_exception = "Нет доступных номеров"
    
            except Exception as e:
                logger.error(f"Ошибка при получении данных для сервиса '{service_code}', попытка {attempt}: {e}")
                last_exception = e
    
            await asyncio.sleep(5)
    
    except asyncio.CancelledError:
        logger.info(f"Задача для пользователя {user_id} была отменена.")
        return
    
    if not success:
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="Назад", callback_data="service_page:0")
        await safe_edit_or_send_message(
            message=message,
            new_text=f"Произошла ошибка при обработке запроса: {last_exception}. Попробуйте снова.",
            state=state,
            reply_markup=keyboard.as_markup()
        )
    

    async def price_selected_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    price = float(callback_query.data.split(":")[1])
    await state.update_data(max_price=price)
    
    await process_number_purchase(callback_query.message, state)
    

    async def max_price_handler(message: types.Message, state: FSMContext): max_price_input = message.text.strip() data = await state.get_data() user_id = data.get('user_id', message.from_user.id)

    try:
        await message.delete()
    except Exception as e:
        logger.error(f"Не удалось удалить сообщение пользователя: {e}")
    
    logger.info(f"Пользователь {user_id} указал максимальную стоимость: {max_price_input}")
    
    try:
        max_price = float(max_price_input)
    except ValueError:
        user_data = await state.get_data()
        min_price = user_data.get('min_price')
        max_price_usd = user_data.get('max_price_usd')
        min_price_rub = user_data.get('min_price_rub')
        max_price_rub = user_data.get('max_price_rub')
    
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
        keyboard.adjust(1)
        await safe_edit_or_send_message(
            message=message,
            new_text=(
                f"Пожалуйста, введите корректное число для максимальной стоимости. "
                f"От `{min_price:.4f}` $ (₽{min_price_rub:.2f}) до `{max_price_usd:.4f}` $ (₽{max_price_rub:.2f})."
            ),
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
        return
    
    if max_price < data.get('min_price'):
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
        keyboard.adjust(1)
        await safe_edit_or_send_message(
            message=message,
            new_text=f"Максимальная стоимость должна быть не менее `{data.get('min_price'):.4f}` $.",
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
        return
    
    await state.update_data(max_price=max_price)
    
    await process_number_purchase(message, state)
    

    async def process_number_purchase(message: types.Message, state: FSMContext): user_data = await state.get_data() user_id = user_data.get('user_id', message.from_user.id) service = user_data['service'] service_display = user_data['service_display'] country_name = user_data['country_name'] operator_display = user_data['operator_display'] max_price = user_data['max_price'] user_api_key = get_user_api_key(user_id) smshub_api = SmsHubAPI(user_api_key) user_country_code = get_user_country(user_id) or "0"

    max_attempts = 3
    last_exception = None
    
    try:
        for attempt in range(1, max_attempts + 1):
            data = await state.get_data()
    
            if data.get("cancel_request"):
                logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен.")
                return
            
            progress_text = f"Идет запрос {attempt}/{max_attempts} на получение номера..."
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
            keyboard.adjust(1)
    
            await safe_edit_or_send_message(
                message=message,
                new_text=progress_text,
                state=state,
                reply_markup=keyboard.as_markup()
            )
    
            user_operator = get_user_operator(user_id) or "any"
    
            if data.get("cancel_request"):
                logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен перед выполнением.")
                return
    
            result = await smshub_api.get_number(service, country=user_country_code, max_price=max_price, operator=user_operator)
    
            if data.get("cancel_request"):
                logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен.")
                return
    
            if result and result.startswith("ACCESS_NUMBER"):
                _, activation_id, number = result.split(":")
                logger.info(f"Пользователь {user_id} получил номер: {number}, активация ID: {activation_id}")
    
                if user_id not in user_activations:
                    user_activations[user_id] = {}
                user_activations[user_id][activation_id] = {
                    'number': number,
                    'status': 'Ожидание SMS',
                    'service': service,
                    'service_display': service_display,
                    'country_name': country_name,
                    'last_update': time.time(),
                    'task': None
                }
    
                keyboard = InlineKeyboardBuilder()
                keyboard.button(text="📂 Текущие активации", callback_data="current_activations")
                keyboard.button(text="❌ Отменить активацию", callback_data=f"cancel_activation:{activation_id}")
                keyboard.button(text="🔙 Главное меню", callback_data="back_to_main_menu")
                keyboard.adjust(1)
    
                message_text = (
                    f"*Получен номер:* `{number}`\n"
                    f"*Страна:* `{country_name}`\n"
                    f"*Оператор:* `{operator_display}`\n"
                    f"*Сервис:* `{service_display}`\n"
                    f"*Максимальная стоимость:* `{max_price:.2f}` $ (₽{max_price * user_data['usd_to_rub_rate']:.2f})\n"
                    f"*Статус:* *Ожидание SMS*\n"
                    f"Вы можете управлять активацией или вернуться в главное меню."
                )
    
                sent_message = await safe_edit_or_send_message(
                    message=message,
                    new_text=message_text,
                    state=state,
                    reply_markup=keyboard.as_markup(),
                    parse_mode="Markdown"
                )
                user_activations[user_id][activation_id]['message_id'] = sent_message.message_id
    
                await state.set_state(None)
    
                task = asyncio.create_task(poll_for_sms(
                    bot=message.bot,
                    user_id=user_id,
                    chat_id=message.chat.id,
                    activation_id=activation_id,
                    smshub_api=smshub_api
                ))
                user_activations[user_id][activation_id]['task'] = task
                return
    
            elif result == "NO_NUMBERS":
                logger.info(f"Попытка {attempt} из {max_attempts}: нет доступных номеров.")
                last_exception = result
                if attempt == max_attempts:
                    suggestion = (
                        "Попробуйте выбрать 'Любой оператор' в настройках или увеличить максимальную цену."
                        if user_operator != "any" else
                        "Попробуйте увеличить максимальную цену или повторите попытку позже."
                    )
                    keyboard = InlineKeyboardBuilder()
                    keyboard.button(text="Назад", callback_data="service_page:0")
                    await safe_edit_or_send_message(
                        message=message,
                        new_text=f"Нет доступных номеров для оператора {operator_display} по данной цене.\n{suggestion}",
                        state=state,
                        reply_markup=keyboard.as_markup()
                    )
                    return
            else:
                raise Exception("Неожиданный ответ API")
    
            await asyncio.sleep(5)
    
    except asyncio.CancelledError:
        logger.info(f"Задача для пользователя {user_id} была отменена.")
        return
    
    if last_exception and last_exception != "NO_NUMBERS":
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="Назад", callback_data="service_page:0")
        await safe_edit_or_send_message(
            message=message,
            new_text=f"Произошла ошибка при обработке запроса: {last_exception}. Попробуйте снова.",
            state=state,
            reply_markup=keyboard.as_markup()
        )
    

    def register_sms_handlers(dp: Dispatcher): dp.callback_query.register(get_sms_handler, F.data == "get_sms") dp.callback_query.register(go_back_to_service_selection, F.data == "cancel_operation") dp.callback_query.register(back_to_main_menu, F.data == "back_to_main_menu") dp.callback_query.register(service_page_handler, F.data.startswith("service_page:")) dp.callback_query.register(service_selected_handler, F.data.startswith("service_select:")) dp.callback_query.register(price_selected_handler, F.data.startswith("select_price:")) dp.message.register(service_handler, SmsOrderState.waiting_for_service) dp.message.register(max_price_handler, SmsOrderState.waiting_for_max_price)

    bot/handlers/settings.py

    import logging from aiogram import Dispatcher, types, F from aiogram.fsm.context import FSMContext from aiogram.utils.keyboard import InlineKeyboardBuilder from aiogram.fsm.state import State, StatesGroup import os

    from ..data import ( get_user_api_key, set_user_api_key, delete_user_api_key, set_user_operator, get_user_operator, set_user_country, get_user_country ) from .start import send_main_menu from ..api import SmsHubAPI from ..utils import get_usd_to_rub_rate, safe_edit_or_send_message from ..constants.operators import OPERATOR_DISPLAY_NAMES from ..constants.countries import COUNTRIES from ..constants.country_operator import COUNTRY_OPERATORS

    logger = logging.getLogger(name)

    class UserSettings(StatesGroup): entering_api_key = State()

    class OperatorSettings(StatesGroup): selecting_operator = State()

    class CountrySettings(StatesGroup): selecting_country = State()

    Обработчик основного меню настроек

    async def settings_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") await show_settings_menu(callback_query, state)

    Функция отображения меню настроек

    async def show_settings_menu(callback, state: FSMContext): user_id = callback.from_user.id if isinstance(callback, types.CallbackQuery) else callback.chat.id user_api_key = get_user_api_key(user_id) user_operator = get_user_operator(user_id) or "any" operator_display_name = OPERATOR_DISPLAY_NAMES.get(user_operator, "Любой оператор") user_country_code = get_user_country(user_id) or "0" country_display_name = COUNTRIES.get(user_country_code, user_country_code) flag_emoji = COUNTRIES.get(user_country_code, "").split()[-1]

    keyboard = InlineKeyboardBuilder()
    if user_api_key:
        keyboard.button(text="🗝️ Изменить API ключ", callback_data="edit_api_key")
        keyboard.button(text="❌ Удалить API ключ", callback_data="delete_api_key")
    else:
        keyboard.button(text="➕ Добавить API ключ", callback_data="add_api_key")
    
    keyboard.button(text="📡 Изменить оператора", callback_data="edit_operator")
    keyboard.button(text=f"{flag_emoji} Изменить страну", callback_data="edit_country")
    keyboard.button(text="🔙 Назад в меню", callback_data="back_to_main_menu")
    keyboard.adjust(1)
    
    message_text = (
        f"**Ваш текущий API ключ:** `{user_api_key}`\n" if user_api_key else "**API ключ не настроен.**\n"
    )
    message_text += f"**Текущий оператор:** `{operator_display_name}`\n"
    message_text += f"**Текущая страна:** `{country_display_name}`"
    
    sent_message = await safe_edit_or_send_message(
        message=callback.message if isinstance(callback, types.CallbackQuery) else callback,
        new_text=message_text,
        state=state,
        reply_markup=keyboard.as_markup(),
        parse_mode="Markdown"
    )
    
    if not sent_message:
        try:
            sent_message = await callback.bot.send_message(
                chat_id=user_id,
                text=message_text,
                reply_markup=keyboard.as_markup(),
                parse_mode="Markdown"
            )
            await state.update_data(prompt_message_id=sent_message.message_id)
        except Exception as e:
            logger.error(f"Не удалось отправить новое меню настроек: {e}")
    
    await state.set_state(None)
    

    Обработчик кнопки добавления/изменения API ключа

    async def input_api_key_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    keyboard = InlineKeyboardBuilder()
    keyboard.button(text="🔙 Назад", callback_data="cancel_settings")
    keyboard.adjust(1)
    
    prompt_text = (
        "Введите ваш API ключ для работы с сервисом:\n\n"
        "*Получение вашего API ключа*\n\n"
        "Чтобы начать использовать API, вам нужно получить ваш уникальный API ключ. Следуйте этим шагам:\n"
        "1. Перейдите по [ссылке на настройки SMSHUB](https://smshub.org/ru/settings).\n"
        "2. Найдите кнопку \"Сгенерировать новый ключ\" и нажмите на неё.\n"
        "3. Ваша почта, на которую был зарегистрирован аккаунт, получит сообщение с вашим новым API ключом.\n"
        "4. Скопируйте ключ из письма.\n\n"
        "*Ввод вашего API ключа*\n\n"
        "После получения ключа, вы можете ввести его в нашем боте. Для этого выполните следующие действия:\n"
        "1. Откройте интерфейс бота, выберите меню настроек.\n"
        "2. Нажмите на кнопку \"➕ Добавить API ключ\", чтобы начать процесс.\n"
        "3. Когда бот запросит, вставьте ваш API ключ в текстовое поле.\n"
        "4. Нажмите \"Отправить\".\n\n"
        "Ваш ключ будет проверен, и если он корректен, бот сохранит его для дальнейшего использования.\n\n"
        "*Информация о безопасности*\n\n"
        "Не забывайте, что ваш API ключ должен оставаться конфиденциальным. Никому не сообщайте его, чтобы избежать несанкционированного доступа к вашим данным и услугам."
    )
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=prompt_text,
        state=state,
        reply_markup=keyboard.as_markup(),
        parse_mode="Markdown",
        disable_web_page_preview=True
    )
    
    await state.set_state(UserSettings.entering_api_key)
    

    Обработчик удаления API ключа

    async def delete_user_api_key_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") logger.info(f"Пользователь {callback_query.from_user.id} запросил удаление API ключа.")

    delete_user_api_key(callback_query.from_user.id)
    await show_settings_menu(callback_query, state)  # Обновление меню настроек
    

    Обработчик возврата в главное меню

    async def back_to_main_menu_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    await state.set_state(None)
    
    # Редактируем текущее сообщение для отображения главного меню
    await send_main_menu(callback_query.message, state)
    

    Обработчик отмены действий, возвращает в меню настроек

    async def cancel_settings_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    await state.set_state(None)
    await show_settings_menu(callback_query, state)
    

    Обработчик ввода API ключа пользователем

    async def set_user_api_key_handler(message: types.Message, state: FSMContext): user_api_key = message.text.strip() logger.info(f"Пользователь {message.from_user.id} ввёл API ключ.")

    try:
        await message.delete()
    except Exception as e:
        logger.warning(f"Не удалось удалить сообщение пользователя: {e}")
    
    smshub_api = SmsHubAPI(user_api_key)
    try:
        balance_response = await smshub_api.get_balance()
        if balance_response and balance_response.startswith("ACCESS_BALANCE:"):
            balance = balance_response.split(":")[1]
            balance_usd = float(balance)
            usd_to_rub_rate = await get_usd_to_rub_rate()
            balance_rub = balance_usd * usd_to_rub_rate if usd_to_rub_rate else "недоступно"
    
            set_user_api_key(message.from_user.id, user_api_key)
    
            # Обновление меню настроек после успешного добавления API ключа
            await show_settings_menu(message, state)
        else:
            error_text = "Неверный API ключ. Пожалуйста, попробуйте снова или отмените операцию."
            await safe_edit_or_send_message(
                message=message,
                new_text=error_text,
                state=state,
                parse_mode="Markdown",
                reply_markup=get_back_button_to_settings_markup()
            )
    except Exception as e:
        logger.error(f"Ошибка при проверке API ключа: {e}")
        error_text = "Произошла ошибка при проверке ключа. Пожалуйста, попробуйте снова."
        await safe_edit_or_send_message(
            message=message,
            new_text=error_text,
            state=state,
            parse_mode="Markdown",
            reply_markup=get_back_button_to_settings_markup()
        )
    

    def get_back_button_to_settings_markup(): """Создаёт клавиатуру с кнопкой 'Назад' в меню настроек.""" keyboard = InlineKeyboardBuilder() keyboard.button(text="🔙 Назад", callback_data="cancel_settings") keyboard.adjust(1) return keyboard.as_markup()

    Обработчики для выбора оператора

    async def select_operator_handler(callback_query: types.CallbackQuery, state: FSMContext, page: int = 0): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    data = await state.get_data()
    user_country_code = data.get('selected_country_code', '0')
    
    operator_list = COUNTRY_OPERATORS.get(user_country_code, [])
    
    if "any" not in operator_list:
        operator_list.insert(0, "any")
    
    items_per_page = 10
    
    start = page * items_per_page
    end = start + items_per_page
    
    keyboard = InlineKeyboardBuilder()
    
    for op in operator_list[start:end]:
        display_name = OPERATOR_DISPLAY_NAMES.get(op, op)
        keyboard.button(text=display_name, callback_data=f"operator:{op}")
    
    keyboard.adjust(2)
    
    nav_buttons = []
    if page > 0:
        nav_buttons.append(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"operator_page:{page - 1}"))
    if end < len(operator_list):
        nav_buttons.append(types.InlineKeyboardButton(text="➡️ Вперёд", callback_data=f"operator_page:{page + 1}"))
    
    if nav_buttons:
        keyboard.row(*nav_buttons)
    
    keyboard.row(types.InlineKeyboardButton(text="🔙 Назад", callback_data="cancel_operator_selection"))
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text="Выберите оператора из списка:",
        state=state,
        reply_markup=keyboard.as_markup()
    )
    await state.set_state(OperatorSettings.selecting_operator)
    

    Обработчик навигации по страницам операторов

    async def operator_page_handler(callback_query: types.CallbackQuery, state: FSMContext): page = int(callback_query.data.split(':')[1]) await select_operator_handler(callback_query, state, page)

    Обработчик отмены выбора оператора

    async def cancel_operator_selection_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") await state.set_state(None) await show_settings_menu(callback_query, state)

    Обработчик выбора оператора

    async def operator_selected_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") operator = callback_query.data.split(":")[1] set_user_operator(callback_query.from_user.id, operator) display_name = OPERATOR_DISPLAY_NAMES.get(operator, operator) await safe_edit_or_send_message( message=callback_query.message, new_text=f"Вы выбрали оператора: {display_name}", state=state ) await state.set_state(None) await show_settings_menu(callback_query, state)

    Обработчики для выбора страны

    async def select_country_handler(callback_query: types.CallbackQuery, state: FSMContext, page: int = 0): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    countries_list = list(COUNTRIES.items())
    items_per_page = 10
    
    start = page * items_per_page
    end = start + items_per_page
    
    keyboard = InlineKeyboardBuilder()
    
    for country_code, country_name in countries_list[start:end]:
        keyboard.button(text=country_name, callback_data=f"country:{country_code}")
    
    keyboard.adjust(2)
    
    nav_buttons = []
    if page > 0:
        nav_buttons.append(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"country_page:{page - 1}"))
    if end < len(countries_list):
        nav_buttons.append(types.InlineKeyboardButton(text="➡️ Вперёд", callback_data=f"country_page:{page + 1}"))
    
    if nav_buttons:
        keyboard.row(*nav_buttons)
    
    keyboard.row(types.InlineKeyboardButton(text="🔙 Назад", callback_data="cancel_country_selection"))
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text="Выберите страну из списка:",
        state=state,
        reply_markup=keyboard.as_markup()
    )
    await state.set_state(CountrySettings.selecting_country)
    

    Обработчик навигации по страницам стран

    async def country_page_handler(callback_query: types.CallbackQuery, state: FSMContext): page = int(callback_query.data.split(':')[1]) await select_country_handler(callback_query, state, page)

    Обработчик отмены выбора страны

    async def cancel_country_selection_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") await state.set_state(None) await show_settings_menu(callback_query, state)

    Обработчик выбора страны

    async def country_selected_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    country_code = callback_query.data.split(":")[1]
    set_user_country(callback_query.from_user.id, country_code)
    country_name = COUNTRIES.get(country_code, country_code)
    
    await state.update_data(selected_country_code=country_code)
    
    current_operator = get_user_operator(callback_query.from_user.id) or "any"
    available_operators = COUNTRY_OPERATORS.get(country_code, [])
    
    if current_operator not in available_operators:
        set_user_operator(callback_query.from_user.id, "any")
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=f"Вы выбрали страну: {country_name}",
        state=state
    )
    await state.set_state(None)
    await show_settings_menu(callback_query, state)
    

    Регистрация всех обработчиков в диспетчере

    def register_settings_handlers(dp: Dispatcher): dp.callback_query.register(settings_handler, F.data == "settings") dp.callback_query.register(input_api_key_handler, F.data.in_({"edit_api_key", "add_api_key"})) dp.callback_query.register(delete_user_api_key_handler, F.data == "delete_api_key") dp.callback_query.register(back_to_main_menu_handler, F.data == "back_to_main_menu") dp.callback_query.register(cancel_settings_handler, F.data == "cancel_settings") dp.message.register(set_user_api_key_handler, UserSettings.entering_api_key) dp.callback_query.register(select_operator_handler, F.data == "edit_operator") dp.callback_query.register(cancel_operator_selection_handler, F.data == "cancel_operator_selection") dp.callback_query.register(operator_selected_handler, OperatorSettings.selecting_operator, F.data.startswith("operator:")) dp.callback_query.register(operator_page_handler, OperatorSettings.selecting_operator, F.data.startswith("operator_page:")) dp.callback_query.register(select_country_handler, F.data == "edit_country") dp.callback_query.register(country_selected_handler, CountrySettings.selecting_country, F.data.startswith("country:")) dp.callback_query.register(cancel_country_selection_handler, F.data == "cancel_country_selection") dp.callback_query.register(country_page_handler, CountrySettings.selecting_country, F.data.startswith("country_page:"))

    /bot/constants/countries.py

    Словарь доступных стран (код страны: название)

    COUNTRIES = { "0": "Россия 🇷🇺", "1": "Украина 🇺🇦", "2": "Казахстан 🇰🇿", "3": "Китай 🇨🇳", "4": "Филиппины 🇵🇭", "5": "Мьянма 🇲🇲", "6": "Индонезия 🇮🇩"

  2. Assistant

    To adapt your Telegram bot to work with the user's selected country rather than defaulting to Russia ("0"), you should ensure that the country codes are dynamically obtained from user settings and integrated into API requests. Here's how you can modify your existing codebase to achieve this:

    1. Update the API Requests to Include the User's Selected Country

    In your SmsHubAPI class methods (e.g., get_number, get_price_for_service, get_numbers_status), replace the default country ID with the user-specific country code obtained from settings.

    bot/api.py:

    async def get_number(self, service: str, country: Optional[str] = None, ...) -> Optional[str]:
        ...
        if not country:  # Get user-specific country if not provided
            country = get_user_country(user_id)
        ...
    

    For all async methods that take country as a parameter, use the same approach to ensure country defaults to the user’s stored choice when none is provided at the call site.

    2. Retrieve and Use Country in Handlers

    To ensure that the appropriate country code based on user settings is passed to the SmsHubAPI methods, you’ll update the relevant handlers that deal with services and queries to SMS Hub's API.

    Example: Update Service Handler Logic

    In the function where you handle the logic after a service is chosen:

    async def service_handler_logic(...):
        ...
        user_country_code = get_user_country(user_id) or "0"
        ...
        price_info = await smshub_api.get_price_for_service(service_code, country=user_country_code)
        numbers_status = await smshub_api.get_numbers_status(country=user_country_code, ...)
        ...
    

    3. Adjust the User Selection of Country

    Ensure that areas in your settings handle user country selection correctly and store selected values for retrieval.

    bot/handlers/settings.py:

    Inside handlers related to country selection and storage:

    async def country_selected_handler(callback_query: types.CallbackQuery, state: FSMContext):
        ...
        country_code = callback_query.data.split(":")[1]
        set_user_country(callback_query.from_user.id, country_code)  # Store user's country choice
        ...
    

    4. Testing

    Once changes are made:

    • Ensure to adequately test the application to verify that selecting a country in the settings updates SMS-Hub API requests correctly.
    • Test various scenarios where no country is set against API requests that expect a default.

    This adjustment will make sure your bot operates respecting user preferences on country selection, properly reflected in API interactions.

  3. User

    на русском, пожалуйста

  4. Assistant

    Конечно! Для того чтобы адаптировать вашего Telegram-бота так, чтобы он учитывал страну, выбранную пользователем, вместо того чтобы всегда использовать Россию ("0"), нужно сделать следующие изменения в коде:

    1. Обновите запросы к API для использования выбранной пользователем страны

    В методах класса SmsHubAPI (например, get_number, get_price_for_service, get_numbers_status) замените использование дефолтного ID страны на код страны, который установлен у пользователя.

    bot/api.py:

    async def get_number(self, service: str, country: Optional[str] = None, ...) -> Optional[str]:
        ...
        if not country:  # Получаем страну пользователя, если не указана
            country = get_user_country(user_id)
        ...
    

    Для всех асинхронных методов, которые принимают параметр country, следуйте тому же подходу, чтобы country по умолчанию принимала значение из сохранённых настроек пользователя, если оно не указано явно.

    2. Получение и использование страны в обработчиках

    Убедитесь, что код страны пользователя передаётся в методы SmsHubAPI там, где это необходимо.

    Пример: обновление логики обработчика сервиса

    В функции, где вы обрабатываете логику после выбора сервиса:

    async def service_handler_logic(...):
        ...
        user_country_code = get_user_country(user_id) or "0"
        ...
        price_info = await smshub_api.get_price_for_service(service_code, country=user_country_code)
        numbers_status = await smshub_api.get_numbers_status(country=user_country_code, ...)
        ...
    

    3. Настройте выбор страны пользователем

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

    bot/handlers/settings.py:

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

    async def country_selected_handler(callback_query: types.CallbackQuery, state: FSMContext):
        ...
        country_code = callback_query.data.split(":")[1]
        set_user_country(callback_query.from_user.id, country_code)  # Сохраняем выбор страны пользователя
        ...
    

    4. Тестирование

    После внесения всех изменений:

    • Тщательно протестируйте приложение, чтобы убедиться, что выбор страны в настройках корректно отражается в запросах к API SmsHub.
    • Проверьте различные сценарии, включая те, где страна не установлена, и убедитесь, что используются значения по умолчанию.

    Эти изменения позволят вашему боту учитывать предпочтения пользователя по выбору страны и корректно отражать их в запросах к API.

  5. User

    можешь присалть мне готовый полностью исправленный код?

  6. Assistant

    Конечно! Давайте обновим ваш код так, чтобы он поддерживал выбор страны пользователя по умолчанию. Я покажу основные моменты, которые требуют изменения. Пожалуйста, убедитесь, что вы интегрируете эти изменения во всей структуре вашего проекта.

    1. bot/api.py

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

    import aiohttp
    import logging
    import json
    from typing import Optional, Dict
    
    from ..data import get_user_country  # Импортируем функцию получения страны пользователя
    
    logger = logging.getLogger(__name__)
    
    BASE_URL = "https://smshub.org/stubs/handler_api.php"
    
    class SmsHubAPI:
        def __init__(self, api_key: str):
            self.api_key = api_key
    
        async def get_number(self, user_id: int, service: str, operator: Optional[str] = None, max_price: Optional[float] = None) -> Optional[str]:
            country = get_user_country(user_id) or "0"
            logger.info(f"Запрос номера для сервиса: {service}, страна: {country}, оператор: {operator}, макс. цена: {max_price}, валюта: 643")
            params = {
                "api_key": self.api_key,
                "action": "getNumber",
                "service": service,
                "country": country,
                "currency": "643"
            }
            if operator and operator != "any":
                params["operator"] = operator
            if max_price:
                params["maxPrice"] = max_price
    
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    text = await response.text()
                    if response.status == 200:
                        logger.info(f"Ответ номера: {text}")
                        return text
                    logger.error(f"Ошибка при запросе номера: {response.status} - {text}")
                    return None
    
        async def get_price_for_service(self, user_id: int, service: str) -> Optional[Dict]:
            country = get_user_country(user_id) or "0"
            logger.info(f"Запрос цен для сервиса: {service}, страна: {country}, валюта: 643")
            params = {
                "api_key": self.api_key,
                "action": "getPrices",
                "service": service,
                "country": country,
                "currency": "643"
            }
    
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    response_text = await response.text()
                    if response.status == 200:
                        try:
                            prices_data = json.loads(response_text)
                            logger.info(f"Цены для сервиса {service}: {prices_data}")
                            country_data = prices_data.get(country)
                            if not country_data:
                                logger.error(f"Страна '{country}' отсутствует в данных: {prices_data}")
                                return None
                            service_data = country_data.get(service)
                            if not service_data:
                                logger.error(f"Сервис '{service}' отсутствует среди доступных для страны '{country}'. Данные: {country_data}")
                                return None
                            return service_data  # Возвращает словарь { "Цена": Количество }
                        except json.JSONDecodeError:
                            logger.error(f"Ошибка парсинга JSON: {response_text}")
                            return None
                    else:
                        logger.error(f"Ошибка при запросе цен: {response.status} - {response_text}")
                        return None
    
        async def get_numbers_status(self, user_id: int) -> Optional[Dict]:
            country = get_user_country(user_id) or "0"
            logger.info(f"Запрос статуса номеров для страны: {country}")
            params = {
                "api_key": self.api_key,
                "action": "getNumbersStatus",
                "country": country
            }
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    response_text = await response.text()
                    if response.status == 200:
                        try:
                            numbers_status = json.loads(response_text)
                            logger.info(f"Статус номеров: {numbers_status}")
                            return numbers_status  # Возвращает словарь { "SERVICE_CODE": Количество }
                        except json.JSONDecodeError:
                            logger.error(f"Ошибка парсинга JSON: {response_text}")
                            return None
                    else:
                        logger.error(f"Ошибка при запросе статуса номеров: {response.status} - {response_text}")
                        return None
    
    # Подобные изменения нужно внести и в другие методы, если там используется страна
    

    2. Изменения в service_handler_logic

    Во всех местах, где вы вызываете методы SmsHubAPI, обязательно передавайте user_id, чтобы страна была выбрана корректно.

    Пример из bot/handlers/your_handler.py:

    async def service_handler_logic(message: types.Message, state: FSMContext, user_id: int, service_code: str):
        ...
        smshub_api = SmsHubAPI(user_api_key)
        ...
        price_info = await smshub_api.get_price_for_service(user_id, service_code)
        numbers_status = await smshub_api.get_numbers_status(user_id)
        ...
    

    3. Исправьте настройки страны

    Убедитесь, что код страны корректно сохраняется и загружается для каждого пользователя.

    Пример из bot/handlers/settings.py:

    async def country_selected_handler(callback_query: types.CallbackQuery, state: FSMContext):
        ...
        country_code = callback_query.data.split(":")[1]
        set_user_country(callback_query.from_user.id, country_code)  # Сохраняем выбор страны пользователя
        ...
    

    4. Обновите другие функции, использующие API

    Убедитесь, что все функции, обращающиеся к API, получают правильный код страны для каждого пользователя, передавая user_id в функции SmsHubAPI.


    Пожалуйста, интегрируйте эти изменения в вашем проекте в указанных местах. Эти поправки нужны, чтобы бот корректно использовал страну, указанную пользователем в настройках. Не забудьте провести тестирование для проверки корректности работы.

  7. User

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

  8. Assistant

    Я покажу вам, как можно полностью обновить ваш код, чтобы использовать выбранную пользователем страну. Обновления коснутся нескольких файлов, как bot/api.py, некоторых обработчиков и настроек. Я представлю пример кода для каждого файла, где нужно внести изменения. Убедитесь, что вы интегрируете эти изменения в правильные части ваших файлов.

    bot/api.py:

    import aiohttp
    import logging
    import json
    from typing import Optional, Dict
    
    # Импорт функции для получения страны пользователя
    from ..data import get_user_country
    
    logger = logging.getLogger(__name__)
    
    BASE_URL = "https://smshub.org/stubs/handler_api.php"
    
    class SmsHubAPI:
        def __init__(self, api_key: str):
            self.api_key = api_key
    
        async def get_number(self, user_id: int, service: str, operator: Optional[str] = None, max_price: Optional[float] = None) -> Optional[str]:
            country = get_user_country(user_id) or "0"
            logger.info(f"Запрос номера для сервиса: {service}, страна: {country}, оператор: {operator}, макс. цена: {max_price}, валюта: 643")
            params = {
                "api_key": self.api_key,
                "action": "getNumber",
                "service": service,
                "country": country,
                "currency": "643"
            }
            if operator and operator != "any":
                params["operator"] = operator
            if max_price:
                params["maxPrice"] = max_price
    
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    text = await response.text()
                    if response.status == 200:
                        logger.info(f"Ответ номера: {text}")
                        return text
                    logger.error(f"Ошибка при запросе номера: {response.status} - {text}")
                    return None
    
        async def get_price_for_service(self, user_id: int, service: str) -> Optional[Dict]:
            country = get_user_country(user_id) or "0"
            logger.info(f"Запрос цен для сервиса: {service}, страна: {country}, валюта: 643")
            params = {
                "api_key": self.api_key,
                "action": "getPrices",
                "service": service,
                "country": country,
                "currency": "643"
            }
    
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    response_text = await response.text()
                    if response.status == 200:
                        try:
                            prices_data = json.loads(response_text)
                            logger.info(f"Цены для сервиса {service}: {prices_data}")
                            country_data = prices_data.get(country)
                            if not country_data:
                                logger.error(f"Страна '{country}' отсутствует в данных: {prices_data}")
                                return None
                            service_data = country_data.get(service)
                            if not service_data:
                                logger.error(f"Сервис '{service}' отсутствует среди доступных для страны '{country}'. Данные: {country_data}")
                                return None
                            return service_data  # Возвращает словарь { "Цена": Количество }
                        except json.JSONDecodeError:
                            logger.error(f"Ошибка парсинга JSON: {response_text}")
                            return None
                    else:
                        logger.error(f"Ошибка при запросе цен: {response.status} - {response_text}")
                        return None
    
        async def get_numbers_status(self, user_id: int) -> Optional[Dict]:
            country = get_user_country(user_id) or "0"
            logger.info(f"Запрос статуса номеров для страны: {country}")
            params = {
                "api_key": self.api_key,
                "action": "getNumbersStatus",
                "country": country
            }
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    response_text = await response.text()
                    if response.status == 200:
                        try:
                            numbers_status = json.loads(response_text)
                            logger.info(f"Статус номеров: {numbers_status}")
                            return numbers_status  # Возвращает словарь { "SERVICE_CODE": Количество }
                        except json.JSONDecodeError:
                            logger.error(f"Ошибка парсинга JSON: {response_text}")
                            return None
                    else:
                        logger.error(f"Ошибка при запросе статуса номеров: {response.status} - {response_text}")
                        return None
    
        async def get_status(self, activation_id: str) -> Optional[str]:
            """Получение статуса активации по ID."""
            logger.info(f"Запрос статуса для активации: {activation_id}")
            params = {
                "api_key": self.api_key,
                "action": "getStatus",
                "id": activation_id
            }
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    text = await response.text()
                    if response.status == 200:
                        logger.info(f"Ответ статуса: {text}")
                        return text
                    logger.error(f"Ошибка при запросе статуса: {response.status} - {text}")
                    return None
    
        async def set_status(self, activation_id: str, status: str) -> Optional[str]:
            """Установка статуса для активации."""
            logger.info(f"Изменение статуса активации: {activation_id} на статус {status}")
            params = {
                "api_key": self.api_key,
                "action": "setStatus",
                "id": activation_id,
                "status": status
            }
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    text = await response.text()
                    if response.status == 200:
                        logger.info(f"Ответ изменения статуса: {text}")
                        return text
                    logger.error(f"Ошибка при изменении статуса: {response.status} - {text}")
                    return None
    
        async def cancel_activation(self, activation_id: str) -> Optional[str]:
            """Отмена активации."""
            return await self.set_status(activation_id, status="8")
    

    Изменения в обработчиках

    bot/handlers/service_logic.py (или аналогичный файл с логикой сервисов)

    async def service_handler_logic(message: types.Message, state: FSMContext, user_id: int, service_code: str):
        logger.info(f"Пользователь {user_id} выбрал сервис: {service_code}")
    
        user_api_key = get_user_api_key(user_id)
        user_operator = get_user_operator(user_id) or "any"
        smshub_api = SmsHubAPI(user_api_key)
        usd_to_rub_rate = await get_usd_to_rub_rate()
    
        max_attempts = 3
        success = False
        last_exception = None
    
        try:
            for attempt in range(1, max_attempts + 1):
                data = await state.get_data()
                if data.get("cancel_request"):
                    logger.info(f"Запрос для пользователя {user_id} был отменен.")
                    return
    
                try:
                    progress_text = f"Идет запрос {attempt}/{max_attempts}..."
                    keyboard = InlineKeyboardBuilder()
                    keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
                    keyboard.adjust(1)
    
                    await safe_edit_or_send_message(
                        message=message,
                        new_text=progress_text,
                        state=state,
                        reply_markup=keyboard.as_markup()
                    )
    
                    # Использование user_id для передачи страны
                    price_info = await smshub_api.get_price_for_service(user_id, service_code)
                    numbers_status = await smshub_api.get_numbers_status(user_id)
    
                    if data.get("cancel_request"):
                        logger.info(f"Запрос для пользователя {user_id} был отменен после получения данных.")
                        return
    
                    if price_info and numbers_status:
                        service_key = f"{service_code}_0"
                        available_numbers = int(numbers_status.get(service_key, 0) or 0)
                        
                        if available_numbers > 0:
                            prices = [float(price_str) for price_str in price_info.keys() if price_str is not None]
                            if prices:
                                min_price_usd = min(prices)
                                max_price_usd = max(prices)
                                min_price_rub = min_price_usd * usd_to_rub_rate if usd_to_rub_rate else 0
                                max_price_rub = max_price_usd * usd_to_rub_rate if usd_to_rub_rate else 0
    
                                operator_display = OPERATOR_DISPLAY_NAMES.get(user_operator, user_operator)
                                service_display = SERVICE_DISPLAY_NAMES.get(service_code, service_code)
                                country_code = get_user_country(user_id)
                                country_name = COUNTRIES.get(country_code, country_code)
    
                                keyboard = InlineKeyboardBuilder()
                                keyboard.button(text=f"⬇️ Мин. цена ({min_price_usd:.4f}$)", callback_data=f"select_price:{min_price_usd}")
                                keyboard.button(text=f"⬆️ Макс. цена ({max_price_usd:.4f}$)", callback_data=f"select_price:{max_price_usd}")
                                keyboard.adjust(2)
                                keyboard.row(types.InlineKeyboardButton(text="❌ Отмена", callback_data="cancel_operation"))
    
                                message_text = (
                                    f"*Страна:* `{country_name}`\n"
                                    f"*Доступно номеров:* `{available_numbers}`\n"
                                    f"*Оператор:* `{operator_display}`\n"
                                    f"*Сервис:* `{service_display}`\n"
                                    f"*Цены:* от `{min_price_usd:.4f}` $ (₽{min_price_rub:.2f}) до `{max_price_usd:.4f}` $ (₽{max_price_rub:.2f}).\n\n"
                                    f"_Выберите максимальную допустимую стоимость покупки с помощью кнопок ниже или введите сумму вручную (например: 0.5). Все суммы указаны в долларах ($):_"
                                )
    
                                await safe_edit_or_send_message(
                                    message=message,
                                    new_text=message_text,
                                    state=state,
                                    reply_markup=keyboard.as_markup(),
                                    parse_mode="Markdown"
                                )
    
                                await state.update_data(
                                    service=service_code,
                                    service_display=service_display,
                                    country_name=country_name,
                                    available_numbers=available_numbers,
                                    operator_display=operator_display,
                                    min_price=min_price_usd,
                                    max_price_usd=max_price_usd,
                                    min_price_rub=min_price_rub,
                                    max_price_rub=max_price_rub,
                                    usd_to_rub_rate=usd_to_rub_rate,
                                    user_id=user_id
                                )
    
                                await state.set_state(SmsOrderState.waiting_for_max_price)
                                success = True
                                break
                            else:
                                logger.info(f"Попытка {attempt}: Цены не найдены.")
                                last_exception = "Цены не найдены"
                        else:
                            logger.info(f"Попытка {attempt}: Нет доступных номеров.")
                            last_exception = "Нет доступных номеров"
    
                except Exception as e:
                    logger.error(f"Ошибка при получении данных для сервиса '{service_code}', попытка {attempt}: {e}")
                    last_exception = e
    
                await asyncio.sleep(5)
    
        except asyncio.CancelledError:
            logger.info(f"Задача для пользователя {user_id} была отменена.")
            return
    
        if not success:
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="Назад", callback_data="service_page:0")
            await safe_edit_or_send_message(
                message=message,
                new_text=f"Произошла ошибка при обработке запроса: {last_exception}. Попробуйте снова.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
    

    Изменения в настройках

    bot/handlers/settings.py

    async def country_selected_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        country_code = callback_query.data.split(":")[1]
        set_user_country(callback_query.from_user.id, country_code)  # Сохраняем выбор страны пользователя
        country_name = COUNTRIES.get(country_code, country_code)
    
        await state.update_data(selected_country_code=country_code)
    
        current_operator = get_user_operator(callback_query.from_user.id) or "any"
        available_operators = COUNTRY_OPERATORS.get(country_code, [])
    
        if current_operator not in available_operators:
            set_user_operator(callback_query.from_user.id, "any")
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=f"Вы выбрали страну: {country_name}",
            state=state
        )
        await state.set_state(None)
        await show_settings_menu(callback_query, state)
    

    С этими изменениями ваш код будет использовать выбранную пользователем страну для взаимодействия с API. Не забудьте протестировать изменения, чтобы убедиться в их успешном выполнении в вашем окружении разработки.

  9. User

    так, ок, давай по очереди, в этот файл какие вносим изменения? полностю можешь мне его присать исправленный:

    bot/api.py

    import aiohttp import logging import json from typing import Optional, Dict

    logger = logging.getLogger(name)

    BASE_URL = "https://smshub.org/stubs/handler_api.php"

    class SmsHubAPI: def init(self, api_key: str): self.api_key = api_key

    async def get_balance(self) -> Optional[str]:
        """Запрос баланса с заданной валютой (RUB)."""
        logger.info("Запрос баланса с валютой: 643")
        params = {
            "api_key": self.api_key,
            "action": "getBalance",
            "currency": "643"
        }
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                if response.status == 200:
                    text = await response.text()
                    logger.info(f"Ответ баланса: {text}")
                    return text
                else:
                    logger.error(f"Ошибка при запросе баланса: {response.status} - {text}")
                    return None
    
    async def get_number(self, service: str, country: str = "0", operator: Optional[str] = None, max_price: Optional[float] = None) -> Optional[str]:
        """Получение номера для указанного сервиса и страны."""
        logger.info(f"Запрос номера для сервиса: {service}, страна: {country}, оператор: {operator}, макс. цена: {max_price}, валюта: 643")
        params = {
            "api_key": self.api_key,
            "action": "getNumber",
            "service": service,
            "country": country,
            "currency": "643"
        }
        if operator and operator != "any":
            params["operator"] = operator
        if max_price:
            params["maxPrice"] = max_price
    
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                text = await response.text()
                if response.status == 200:
                    logger.info(f"Ответ номера: {text}")
                    return text
                logger.error(f"Ошибка при запросе номера: {response.status} - {text}")
                return None
    
    async def get_price_for_service(self, service: str, country: str = "0") -> Optional[Dict]:
        """Получение цен для указанного сервиса."""
        logger.info(f"Запрос цен для сервиса: {service}, страна: {country}, валюта: 643")
        params = {
            "api_key": self.api_key,
            "action": "getPrices",
            "service": service,
            "country": country,
            "currency": "643"
        }
    
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                response_text = await response.text()
                if response.status == 200:
                    try:
                        prices_data = json.loads(response_text)
                        logger.info(f"Цены для сервиса {service}: {prices_data}")
                        country_data = prices_data.get(country)
                        if not country_data:
                            logger.error(f"Страна '{country}' отсутствует в данных: {prices_data}")
                            return None
                        service_data = country_data.get(service)
                        if not service_data:
                            logger.error(f"Сервис '{service}' отсутствует среди доступных для страны '{country}'. Данные: {country_data}")
                            return None
                        return service_data  # Возвращает словарь { "Цена": Количество }
                    except json.JSONDecodeError:
                        logger.error(f"Ошибка парсинга JSON: {response_text}")
                        return None
                else:
                    logger.error(f"Ошибка при запросе цен: {response.status} - {response_text}")
                    return None
    
    async def get_numbers_status(self, country: str = "0", operator: Optional[str] = None) -> Optional[Dict]:
        """Получение статуса номеров по стране и оператору."""
        logger.info(f"Запрос статуса номеров для страны: {country}, оператор: {operator}")
        params = {
            "api_key": self.api_key,
            "action": "getNumbersStatus",
            "country": country
        }
        if operator and operator != "any":
            params["operator"] = operator
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                response_text = await response.text()
                if response.status == 200:
                    try:
                        numbers_status = json.loads(response_text)
                        logger.info(f"Статус номеров: {numbers_status}")
                        return numbers_status  # Возвращает словарь { "SERVICE_CODE": Количество }
                    except json.JSONDecodeError:
                        logger.error(f"Ошибка парсинга JSON: {response_text}")
                        return None
                else:
                    logger.error(f"Ошибка при запросе статуса номеров: {response.status} - {response_text}")
                    return None
    
    async def get_status(self, activation_id: str) -> Optional[str]:
        """Получение статуса активации по ID."""
        logger.info(f"Запрос статуса для активации: {activation_id}")
        params = {
            "api_key": self.api_key,
            "action": "getStatus",
            "id": activation_id
        }
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                text = await response.text()
                if response.status == 200:
                    logger.info(f"Ответ статуса: {text}")
                    return text
                logger.error(f"Ошибка при запросе статуса: {response.status} - {text}")
                return None
    
    async def set_status(self, activation_id: str, status: str) -> Optional[str]:
        """Установка статуса для активации."""
        logger.info(f"Изменение статуса активации: {activation_id} на статус {status}")
        params = {
            "api_key": self.api_key,
            "action": "setStatus",
            "id": activation_id,
            "status": status
        }
        async with aiohttp.ClientSession() as session:
            async with session.get(BASE_URL, params=params) as response:
                text = await response.text()
                if response.status == 200:
                    logger.info(f"Ответ изменения статуса: {text}")
                    return text
                logger.error(f"Ошибка при изменении статуса: {response.status} - {text}")
                return None
    
    async def cancel_activation(self, activation_id: str) -> Optional[str]:
        """Отмена активации."""
        return await self.set_status(activation_id, status="8")
    
  10. Assistant

    Вот обновлённый файл bot/api.py, который теперь учитывает страну, выбранную пользователем. Мы добавим нужные изменения, чтобы использовать код страны пользователя, получаемый из вашего метода get_user_country.

    bot/api.py

    import aiohttp
    import logging
    import json
    from typing import Optional, Dict
    
    # Импорт функции для получения страны пользователя
    from ..data import get_user_country
    
    logger = logging.getLogger(__name__)
    
    BASE_URL = "https://smshub.org/stubs/handler_api.php"
    
    class SmsHubAPI:
        def __init__(self, api_key: str):
            self.api_key = api_key
    
        async def get_balance(self) -> Optional[str]:
            """Запрос баланса с заданной валютой (RUB)."""
            logger.info("Запрос баланса с валютой: 643")
            params = {
                "api_key": self.api_key,
                "action": "getBalance",
                "currency": "643"
            }
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    if response.status == 200:
                        text = await response.text()
                        logger.info(f"Ответ баланса: {text}")
                        return text
                    else:
                        logger.error(f"Ошибка при запросе баланса: {response.status} - {text}")
                        return None
    
        async def get_number(self, user_id: int, service: str, operator: Optional[str] = None, max_price: Optional[float] = None) -> Optional[str]:
            """Получение номера для указанного сервиса и страны."""
            country = get_user_country(user_id) or "0"
    
            logger.info(f"Запрос номера для сервиса: {service}, страна: {country}, оператор: {operator}, макс. цена: {max_price}, валюта: 643")
            params = {
                "api_key": self.api_key,
                "action": "getNumber",
                "service": service,
                "country": country,
                "currency": "643"
            }
            if operator and operator != "any":
                params["operator"] = operator
            if max_price:
                params["maxPrice"] = max_price
    
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    text = await response.text()
                    if response.status == 200:
                        logger.info(f"Ответ номера: {text}")
                        return text
                    logger.error(f"Ошибка при запросе номера: {response.status} - {text}")
                    return None
    
        async def get_price_for_service(self, user_id: int, service: str) -> Optional[Dict]:
            """Получение цен для указанного сервиса."""
            country = get_user_country(user_id) or "0"
    
            logger.info(f"Запрос цен для сервиса: {service}, страна: {country}, валюта: 643")
            params = {
                "api_key": self.api_key,
                "action": "getPrices",
                "service": service,
                "country": country,
                "currency": "643"
            }
    
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    response_text = await response.text()
                    if response.status == 200:
                        try:
                            prices_data = json.loads(response_text)
                            logger.info(f"Цены для сервиса {service}: {prices_data}")
                            country_data = prices_data.get(country)
                            if not country_data:
                                logger.error(f"Страна '{country}' отсутствует в данных: {prices_data}")
                                return None
                            service_data = country_data.get(service)
                            if not service_data:
                                logger.error(f"Сервис '{service}' отсутствует среди доступных для страны '{country}'. Данные: {country_data}")
                                return None
                            return service_data  # Возвращает словарь { "Цена": Количество }
                        except json.JSONDecodeError:
                            logger.error(f"Ошибка парсинга JSON: {response_text}")
                            return None
                    else:
                        logger.error(f"Ошибка при запросе цен: {response.status} - {response_text}")
                        return None
    
        async def get_numbers_status(self, user_id: int, operator: Optional[str] = None) -> Optional[Dict]:
            """Получение статуса номеров по стране и оператору."""
            country = get_user_country(user_id) or "0"
    
            logger.info(f"Запрос статуса номеров для страны: {country}, оператор: {operator}")
            params = {
                "api_key": self.api_key,
                "action": "getNumbersStatus",
                "country": country
            }
            if operator and operator != "any":
                params["operator"] = operator
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    response_text = await response.text()
                    if response.status == 200:
                        try:
                            numbers_status = json.loads(response_text)
                            logger.info(f"Статус номеров: {numbers_status}")
                            return numbers_status  # Возвращает словарь { "SERVICE_CODE": Количество }
                        except json.JSONDecodeError:
                            logger.error(f"Ошибка парсинга JSON: {response_text}")
                            return None
                    else:
                        logger.error(f"Ошибка при запросе статуса номеров: {response.status} - {response_text}")
                        return None
    
        async def get_status(self, activation_id: str) -> Optional[str]:
            """Получение статуса активации по ID."""
            logger.info(f"Запрос статуса для активации: {activation_id}")
            params = {
                "api_key": self.api_key,
                "action": "getStatus",
                "id": activation_id
            }
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    text = await response.text()
                    if response.status == 200:
                        logger.info(f"Ответ статуса: {text}")
                        return text
                    logger.error(f"Ошибка при запросе статуса: {response.status} - {text}")
                    return None
    
        async def set_status(self, activation_id: str, status: str) -> Optional[str]:
            """Установка статуса для активации."""
            logger.info(f"Изменение статуса активации: {activation_id} на статус {status}")
            params = {
                "api_key": self.api_key,
                "action": "setStatus",
                "id": activation_id,
                "status": status
            }
            async with aiohttp.ClientSession() as session:
                async with session.get(BASE_URL, params=params) as response:
                    text = await response.text()
                    if response.status == 200:
                        logger.info(f"Ответ изменения статуса: {text}")
                        return text
                    logger.error(f"Ошибка при изменении статуса: {response.status} - {text}")
                    return None
    
        async def cancel_activation(self, activation_id: str) -> Optional[str]:
            """Отмена активации."""
            return await self.set_status(activation_id, status="8")
    

    Основные изменения:

    1. Добавление метода get_user_country: Для каждого метода, который взаимодействует с API, добавлен пользовательский параметр user_id. Это позволяет извлекать страну, установленную пользователем, при каждом запросе, который включает параметр country.

    2. Передача user_id в функции API: Теперь функции API требуют user_id для получения нужного кода страны, так что убедитесь, что user_id передается в эти функции откуда бы они ни вызывались в вашей логике приложения.

    Теперь вы можете использовать это обновление, чтобы ваш бот учитывал выбранную пользователем страну во всех соответствующих API-запросах.

  11. User

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

    import asyncio import logging import time import json from pathlib import Path from typing import Optional, List, Tuple from aiogram import Dispatcher, types, F from aiogram.utils.keyboard import InlineKeyboardBuilder from aiogram.fsm.context import FSMContext from aiogram.fsm.state import State, StatesGroup

    Импорт дополнительных модулей

    from ..data import get_user_api_key, get_user_operator, get_user_country from ..api import SmsHubAPI from ..utils import get_usd_to_rub_rate, safe_edit_or_send_message from .start import send_main_menu from .activation import user_activations, poll_for_sms from ..constants.operators import OPERATOR_DISPLAY_NAMES from ..constants.countries import COUNTRIES from ..constants.services import SERVICE_DISPLAY_NAMES

    logger = logging.getLogger(name)

    class SmsOrderState(StatesGroup): waiting_for_service = State() waiting_for_max_price = State()

    SERVICES: List[Tuple[str, str]] = list(SERVICE_DISPLAY_NAMES.items()) POPULARITY_FILE = Path("service_popularity.json")

    def load_popularity_data(): if POPULARITY_FILE.exists(): with open(POPULARITY_FILE, 'r', encoding='utf-8') as f: return json.load(f) return {}

    def save_popularity_data(popularity_data): with open(POPULARITY_FILE, 'w', encoding='utf-8') as f: json.dump(popularity_data, f, ensure_ascii=False, indent=4)

    def update_service_popularity(service_code: str): popularity_data = load_popularity_data() if service_code in popularity_data: popularity_data[service_code] += 1 else: popularity_data[service_code] = 1 save_popularity_data(popularity_data)

    def get_sorted_services(): popularity_data = load_popularity_data() sorted_services = sorted(SERVICES, key=lambda service: popularity_data.get(service[0], 0), reverse=True) return sorted_services

    def get_service_pages(services: List[Tuple[str, str]], page_size: int = 18) -> List[List[Tuple[str, str]]]: pages = [] for i in range(0, len(services), page_size): pages.append(services[i:i + page_size]) return pages

    def build_service_keyboard(page_number: int = 0) -> InlineKeyboardBuilder: sorted_services = get_sorted_services() services_pages = get_service_pages(sorted_services) keyboard = InlineKeyboardBuilder()

    if page_number < len(services_pages):
        current_page = services_pages[page_number]
    
        # Добавляет кнопки сервисов в сетке 3x6
        for code, name in current_page:
            keyboard.button(text=name, callback_data=f"service_select:{code}")
        
        # Настраивает кнопки навигации
        if page_number == 0:
            # Первая страница - только кнопка "Вперед"
            keyboard.adjust(3)  # Устраиваем сервисные кнопки в 3 столбца
            keyboard.row(types.InlineKeyboardButton(text="➡️ Вперед", callback_data=f"service_page:{page_number + 1}"))
        elif page_number == len(services_pages) - 1:
            # Последняя страница - только кнопка "Назад"
            keyboard.adjust(3)
            keyboard.row(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"service_page:{page_number - 1}"))
        else:
            # Промежуточные страницы - кнопки "Назад" и "Вперед"
            keyboard.adjust(3)
            keyboard.row(
                types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"service_page:{page_number - 1}"),
                types.InlineKeyboardButton(text="➡️ Вперед", callback_data=f"service_page:{page_number + 1}")
            )
    
    # Кнопка "Назад в меню" на всех страницах
    keyboard.row(types.InlineKeyboardButton(text="🔙 Назад в меню", callback_data="back_to_main_menu"))
    
    return keyboard
    

    async def get_sms_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    user_api_key = get_user_api_key(callback_query.from_user.id)
    if not user_api_key:
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="⚙️ Настройки", callback_data="settings")
        keyboard.button(text="🔙 Назад", callback_data="back_to_main_menu")
        keyboard.adjust(1)
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Пожалуйста, сначала настройте ваш API ключ в разделе 'Настройки'.",
            state=state,
            reply_markup=keyboard.as_markup()
        )
        return
    
    logger.info(f"Пользователь {callback_query.from_user.id} начал процесс получения номера.")
    keyboard = build_service_keyboard()
    
    await state.update_data(cancel_request=False, current_task=None)
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=(
            "Выберите сервис, нажав на кнопку ниже.\n"
            "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
        ),
        state=state,
        reply_markup=keyboard.as_markup()
    )
    await state.set_state(SmsOrderState.waiting_for_service)
    

    async def go_back_to_service_selection(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") logger.info(f"Пользователь {callback_query.from_user.id} отменил операцию.")

    await state.update_data(cancel_request=True)
    
    data = await state.get_data()
    current_task = data.get('current_task')
    if current_task:
        current_task.cancel()
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=(
            "Выберите сервис, нажав на кнопку ниже.\n"
            "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
        ),
        state=state,
        reply_markup=build_service_keyboard().as_markup()
    )
    
    await state.set_state(SmsOrderState.waiting_for_service)
    

    async def back_to_main_menu(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") logger.info(f"Пользователь {callback_query.from_user.id} вернулся в главное меню.")

    await state.set_state(None)
    await send_main_menu(callback_query.message, state)
    

    async def service_page_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    page_number = int(callback_query.data.split(":")[1])
    keyboard = build_service_keyboard(page_number)
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=(
            "Выберите сервис, нажав на кнопку ниже.\n"
            "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
        ),
        state=state,
        reply_markup=keyboard.as_markup()
    )
    

    async def service_selected_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    service_code = callback_query.data.split(":")[1]
    update_service_popularity(service_code)
    
    await state.update_data(selected_service=service_code, cancel_request=False)
    task = asyncio.create_task(service_handler_logic(
        callback_query.message, state, user_id=callback_query.from_user.id, service_code=service_code, is_service_selection=True))
    await state.update_data(current_task=task)
    

    async def service_handler(message: types.Message, state: FSMContext, service_code: Optional[str] = None, user_id: Optional[int] = None): try: await message.delete() except Exception as e: logger.error(f"Не удалось удалить сообщение пользователя: {e}")

    user_input = message.text.strip().lower()
    
    if user_id is None:
        user_id = message.from_user.id
    
    logger.info(f"Пользователь {user_id} ввел сервис: {user_input}")
    
    service_code = next((code for code, name in SERVICE_DISPLAY_NAMES.items() if name.lower() == user_input or code.lower() == user_input), None)
    
    if service_code is None:
        matched_services = [(code, name) for code, name in SERVICE_DISPLAY_NAMES.items() if user_input in name.lower()]
    
        if matched_services:
            keyboard = InlineKeyboardBuilder()
            for code, name in matched_services:
                keyboard.button(text=name, callback_data=f"service_select:{code}")
    
            keyboard.adjust(3)
            keyboard.button(text="🔙 Назад", callback_data="service_page:0")
            await safe_edit_or_send_message(
                message=message,
                new_text="Пожалуйста, выберите один из представленных сервисов:",
                state=state,
                reply_markup=keyboard.as_markup()
            )
            return
        else:
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="🔙 Назад к сервисам", callback_data="service_page:0")
            await safe_edit_or_send_message(
                message=message,
                new_text="Сервис не найден. Попробуйте ввести код или полное название сервиса.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
            return
    else:
        await state.update_data(selected_service=service_code, cancel_request=False)
        task = asyncio.create_task(service_handler_logic(message, state, user_id=user_id, service_code=service_code))
        await state.update_data(current_task=task)
    

    async def service_handler_logic(message: types.Message, state: FSMContext, user_id: int, service_code: str, is_service_selection: bool = False): logger.info(f"Пользователь {user_id} выбрал сервис: {service_code}")

    user_api_key = get_user_api_key(user_id)
    user_operator = get_user_operator(user_id) or "any"
    user_country_code = get_user_country(user_id) or "0"
    country_name = COUNTRIES.get(user_country_code, user_country_code)
    
    if not user_api_key:
        await safe_edit_or_send_message(
            message=message,
            new_text="Пожалуйста, сначала настройте ваш API ключ в разделе 'Настройки'.",
            state=state
        )
        await state.set_state(None)
        await send_main_menu(message, state)
        return
    
    smshub_api = SmsHubAPI(user_api_key)
    usd_to_rub_rate = await get_usd_to_rub_rate()
    
    max_attempts = 3
    success = False
    last_exception = None
    
    try:
        for attempt in range(1, max_attempts + 1):
            data = await state.get_data()
            if data.get("cancel_request"):
                logger.info(f"Запрос для пользователя {user_id} был отменен.")
                return
    
            try:
                progress_text = f"Идет запрос {attempt}/{max_attempts}..."
                keyboard = InlineKeyboardBuilder()
                keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
                keyboard.adjust(1)
    
                await safe_edit_or_send_message(
                    message=message,
                    new_text=progress_text,
                    state=state,
                    reply_markup=keyboard.as_markup()
                )
    
                price_info = await smshub_api.get_price_for_service(service_code, country=user_country_code)
                numbers_status = await smshub_api.get_numbers_status(country=user_country_code, operator=user_operator)
    
                if data.get("cancel_request"):
                    logger.info(f"Запрос для пользователя {user_id} был отменен после получения данных.")
                    return
    
                if price_info and numbers_status:
                    service_key = f"{service_code}_0"
                    available_numbers = int(numbers_status.get(service_key, 0) or 0)
                    
                    if available_numbers > 0:
                        prices = [float(price_str) for price_str in price_info.keys() if price_str is not None]
                        if prices:
                            min_price_usd = min(prices)
                            max_price_usd = max(prices)
                            min_price_rub = min_price_usd * usd_to_rub_rate if usd_to_rub_rate else 0
                            max_price_rub = max_price_usd * usd_to_rub_rate if usd_to_rub_rate else 0
    
                            operator_display = OPERATOR_DISPLAY_NAMES.get(user_operator, user_operator)
                            service_display = SERVICE_DISPLAY_NAMES.get(service_code, service_code)
    
                            keyboard = InlineKeyboardBuilder()
                            keyboard.button(text=f"⬇️ Мин. цена ({min_price_usd:.4f}$)", callback_data=f"select_price:{min_price_usd}")
                            keyboard.button(text=f"⬆️ Макс. цена ({max_price_usd:.4f}$)", callback_data=f"select_price:{max_price_usd}")
                            keyboard.adjust(2)
                            keyboard.row(types.InlineKeyboardButton(text="❌ Отмена", callback_data="cancel_operation"))
    
                            message_text = (
                                f"*Страна:* `{country_name}`\n"
                                f"*Доступно номеров:* `{available_numbers}`\n"
                                f"*Оператор:* `{operator_display}`\n"
                                f"*Сервис:* `{service_display}`\n"
                                f"*Цены:* от `{min_price_usd:.4f}` $ (₽{min_price_rub:.2f}) до `{max_price_usd:.4f}` $ (₽{max_price_rub:.2f}).\n\n"
                                f"_Выберите максимальную допустимую стоимость покупки с помощью кнопок ниже или введите сумму вручную (например: 0.5). Все суммы указаны в долларах ($):_"
                            )
    
                            await safe_edit_or_send_message(
                                message=message,
                                new_text=message_text,
                                state=state,
                                reply_markup=keyboard.as_markup(),
                                parse_mode="Markdown"
                            )
    
                            await state.update_data(
                                service=service_code,
                                service_display=service_display,
                                country_name=country_name,
                                available_numbers=available_numbers,
                                operator_display=operator_display,
                                min_price=min_price_usd,
                                max_price_usd=max_price_usd,
                                min_price_rub=min_price_rub,
                                max_price_rub=max_price_rub,
                                usd_to_rub_rate=usd_to_rub_rate,
                                user_id=user_id
                            )
    
                            await state.set_state(SmsOrderState.waiting_for_max_price)
                            success = True
                            break
                        else:
                            logger.info(f"Попытка {attempt}: Цены не найдены.")
                            last_exception = "Цены не найдены"
                    else:
                        logger.info(f"Попытка {attempt}: Нет доступных номеров.")
                        last_exception = "Нет доступных номеров"
    
            except Exception as e:
                logger.error(f"Ошибка при получении данных для сервиса '{service_code}', попытка {attempt}: {e}")
                last_exception = e
    
            await asyncio.sleep(5)
    
    except asyncio.CancelledError:
        logger.info(f"Задача для пользователя {user_id} была отменена.")
        return
    
    if not success:
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="Назад", callback_data="service_page:0")
        await safe_edit_or_send_message(
            message=message,
            new_text=f"Произошла ошибка при обработке запроса: {last_exception}. Попробуйте снова.",
            state=state,
            reply_markup=keyboard.as_markup()
        )
    

    async def price_selected_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    price = float(callback_query.data.split(":")[1])
    await state.update_data(max_price=price)
    
    await process_number_purchase(callback_query.message, state)
    

    async def max_price_handler(message: types.Message, state: FSMContext): max_price_input = message.text.strip() data = await state.get_data() user_id = data.get('user_id', message.from_user.id)

    try:
        await message.delete()
    except Exception as e:
        logger.error(f"Не удалось удалить сообщение пользователя: {e}")
    
    logger.info(f"Пользователь {user_id} указал максимальную стоимость: {max_price_input}")
    
    try:
        max_price = float(max_price_input)
    except ValueError:
        user_data = await state.get_data()
        min_price = user_data.get('min_price')
        max_price_usd = user_data.get('max_price_usd')
        min_price_rub = user_data.get('min_price_rub')
        max_price_rub = user_data.get('max_price_rub')
    
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
        keyboard.adjust(1)
        await safe_edit_or_send_message(
            message=message,
            new_text=(
                f"Пожалуйста, введите корректное число для максимальной стоимости. "
                f"От `{min_price:.4f}` $ (₽{min_price_rub:.2f}) до `{max_price_usd:.4f}` $ (₽{max_price_rub:.2f})."
            ),
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
        return
    
    if max_price < data.get('min_price'):
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
        keyboard.adjust(1)
        await safe_edit_or_send_message(
            message=message,
            new_text=f"Максимальная стоимость должна быть не менее `{data.get('min_price'):.4f}` $.",
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
        return
    
    await state.update_data(max_price=max_price)
    
    await process_number_purchase(message, state)
    

    async def process_number_purchase(message: types.Message, state: FSMContext): user_data = await state.get_data() user_id = user_data.get('user_id', message.from_user.id) service = user_data['service'] service_display = user_data['service_display'] country_name = user_data['country_name'] operator_display = user_data['operator_display'] max_price = user_data['max_price'] user_api_key = get_user_api_key(user_id) smshub_api = SmsHubAPI(user_api_key) user_country_code = get_user_country(user_id) or "0"

    max_attempts = 3
    last_exception = None
    
    try:
        for attempt in range(1, max_attempts + 1):
            data = await state.get_data()
    
            if data.get("cancel_request"):
                logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен.")
                return
            
            progress_text = f"Идет запрос {attempt}/{max_attempts} на получение номера..."
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
            keyboard.adjust(1)
    
            await safe_edit_or_send_message(
                message=message,
                new_text=progress_text,
                state=state,
                reply_markup=keyboard.as_markup()
            )
    
            user_operator = get_user_operator(user_id) or "any"
    
            if data.get("cancel_request"):
                logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен перед выполнением.")
                return
    
            result = await smshub_api.get_number(service, country=user_country_code, max_price=max_price, operator=user_operator)
    
            if data.get("cancel_request"):
                logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен.")
                return
    
            if result and result.startswith("ACCESS_NUMBER"):
                _, activation_id, number = result.split(":")
                logger.info(f"Пользователь {user_id} получил номер: {number}, активация ID: {activation_id}")
    
                if user_id not in user_activations:
                    user_activations[user_id] = {}
                user_activations[user_id][activation_id] = {
                    'number': number,
                    'status': 'Ожидание SMS',
                    'service': service,
                    'service_display': service_display,
                    'country_name': country_name,
                    'last_update': time.time(),
                    'task': None
                }
    
                keyboard = InlineKeyboardBuilder()
                keyboard.button(text="📂 Текущие активации", callback_data="current_activations")
                keyboard.button(text="❌ Отменить активацию", callback_data=f"cancel_activation:{activation_id}")
                keyboard.button(text="🔙 Главное меню", callback_data="back_to_main_menu")
                keyboard.adjust(1)
    
                message_text = (
                    f"*Получен номер:* `{number}`\n"
                    f"*Страна:* `{country_name}`\n"
                    f"*Оператор:* `{operator_display}`\n"
                    f"*Сервис:* `{service_display}`\n"
                    f"*Максимальная стоимость:* `{max_price:.2f}` $ (₽{max_price * user_data['usd_to_rub_rate']:.2f})\n"
                    f"*Статус:* *Ожидание SMS*\n"
                    f"Вы можете управлять активацией или вернуться в главное меню."
                )
    
                sent_message = await safe_edit_or_send_message(
                    message=message,
                    new_text=message_text,
                    state=state,
                    reply_markup=keyboard.as_markup(),
                    parse_mode="Markdown"
                )
                user_activations[user_id][activation_id]['message_id'] = sent_message.message_id
    
                await state.set_state(None)
    
                task = asyncio.create_task(poll_for_sms(
                    bot=message.bot,
                    user_id=user_id,
                    chat_id=message.chat.id,
                    activation_id=activation_id,
                    smshub_api=smshub_api
                ))
                user_activations[user_id][activation_id]['task'] = task
                return
    
            elif result == "NO_NUMBERS":
                logger.info(f"Попытка {attempt} из {max_attempts}: нет доступных номеров.")
                last_exception = result
                if attempt == max_attempts:
                    suggestion = (
                        "Попробуйте выбрать 'Любой оператор' в настройках или увеличить максимальную цену."
                        if user_operator != "any" else
                        "Попробуйте увеличить максимальную цену или повторите попытку позже."
                    )
                    keyboard = InlineKeyboardBuilder()
                    keyboard.button(text="Назад", callback_data="service_page:0")
                    await safe_edit_or_send_message(
                        message=message,
                        new_text=f"Нет доступных номеров для оператора {operator_display} по данной цене.\n{suggestion}",
                        state=state,
                        reply_markup=keyboard.as_markup()
                    )
                    return
            else:
                raise Exception("Неожиданный ответ API")
    
            await asyncio.sleep(5)
    
    except asyncio.CancelledError:
        logger.info(f"Задача для пользователя {user_id} была отменена.")
        return
    
    if last_exception and last_exception != "NO_NUMBERS":
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="Назад", callback_data="service_page:0")
        await safe_edit_or_send_message(
            message=message,
            new_text=f"Произошла ошибка при обработке запроса: {last_exception}. Попробуйте снова.",
            state=state,
            reply_markup=keyboard.as_markup()
        )
    

    def register_sms_handlers(dp: Dispatcher): dp.callback_query.register(get_sms_handler, F.data == "get_sms") dp.callback_query.register(go_back_to_service_selection, F.data == "cancel_operation") dp.callback_query.register(back_to_main_menu, F.data == "back_to_main_menu") dp.callback_query.register(service_page_handler, F.data.startswith("service_page:")) dp.callback_query.register(service_selected_handler, F.data.startswith("service_select:")) dp.callback_query.register(price_selected_handler, F.data.startswith("select_price:")) dp.message.register(service_handler, SmsOrderState.waiting_for_service) dp.message.register(max_price_handler, SmsOrderState.waiting_for_max_price)

  12. Assistant

    Чтобы ваш бот корректно использовал страну, выбранную пользователем, в API-запросах, нужно внести несколько изменений в ваш файл. Основное изменение заключается в том, чтобы учесть user_id при вызове методов API, что позволит извлекать правильный код страны из настроек пользователя.

    Вот исправленный файл:

    import asyncio
    import logging
    import time
    import json
    from pathlib import Path
    from typing import Optional, List, Tuple
    from aiogram import Dispatcher, types, F
    from aiogram.utils.keyboard import InlineKeyboardBuilder
    from aiogram.fsm.context import FSMContext
    from aiogram.fsm.state import State, StatesGroup
    
    # Импорт дополнительных модулей
    from ..data import get_user_api_key, get_user_operator, get_user_country
    from ..api import SmsHubAPI
    from ..utils import get_usd_to_rub_rate, safe_edit_or_send_message
    from .start import send_main_menu
    from .activation import user_activations, poll_for_sms
    from ..constants.operators import OPERATOR_DISPLAY_NAMES
    from ..constants.countries import COUNTRIES
    from ..constants.services import SERVICE_DISPLAY_NAMES
    
    logger = logging.getLogger(__name__)
    
    class SmsOrderState(StatesGroup):
        waiting_for_service = State()
        waiting_for_max_price = State()
    
    SERVICES: List[Tuple[str, str]] = list(SERVICE_DISPLAY_NAMES.items())
    POPULARITY_FILE = Path("service_popularity.json")
    
    def load_popularity_data():
        if POPULARITY_FILE.exists():
            with open(POPULARITY_FILE, 'r', encoding='utf-8') as f:
                return json.load(f)
        return {}
    
    def save_popularity_data(popularity_data):
        with open(POPULARITY_FILE, 'w', encoding='utf-8') as f:
            json.dump(popularity_data, f, ensure_ascii=False, indent=4)
    
    def update_service_popularity(service_code: str):
        popularity_data = load_popularity_data()
        if service_code in popularity_data:
            popularity_data[service_code] += 1
        else:
            popularity_data[service_code] = 1
        save_popularity_data(popularity_data)
    
    def get_sorted_services():
        popularity_data = load_popularity_data()
        sorted_services = sorted(SERVICES, key=lambda service: popularity_data.get(service[0], 0), reverse=True)
        return sorted_services
    
    def get_service_pages(services: List[Tuple[str, str]], page_size: int = 18) -> List[List[Tuple[str, str]]]:
        pages = []
        for i in range(0, len(services), page_size):
            pages.append(services[i:i + page_size])
        return pages
    
    def build_service_keyboard(page_number: int = 0) -> InlineKeyboardBuilder:
        sorted_services = get_sorted_services()
        services_pages = get_service_pages(sorted_services)
        keyboard = InlineKeyboardBuilder()
    
        if page_number < len(services_pages):
            current_page = services_pages[page_number]
    
            # Добавляет кнопки сервисов в сетке 3x6
            for code, name in current_page:
                keyboard.button(text=name, callback_data=f"service_select:{code}")
            
            # Настраивает кнопки навигации
            if page_number == 0:
                # Первая страница - только кнопка "Вперед"
                keyboard.adjust(3)  # Устраиваем сервисные кнопки в 3 столбца
                keyboard.row(types.InlineKeyboardButton(text="➡️ Вперед", callback_data=f"service_page:{page_number + 1}"))
            elif page_number == len(services_pages) - 1:
                # Последняя страница - только кнопка "Назад"
                keyboard.adjust(3)
                keyboard.row(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"service_page:{page_number - 1}"))
            else:
                # Промежуточные страницы - кнопки "Назад" и "Вперед"
                keyboard.adjust(3)
                keyboard.row(
                    types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"service_page:{page_number - 1}"),
                    types.InlineKeyboardButton(text="➡️ Вперед", callback_data=f"service_page:{page_number + 1}")
                )
        
        # Кнопка "Назад в меню" на всех страницах
        keyboard.row(types.InlineKeyboardButton(text="🔙 Назад в меню", callback_data="back_to_main_menu"))
    
        return keyboard
    
    async def get_sms_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        user_api_key = get_user_api_key(callback_query.from_user.id)
        if not user_api_key:
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="⚙️ Настройки", callback_data="settings")
            keyboard.button(text="🔙 Назад", callback_data="back_to_main_menu")
            keyboard.adjust(1)
            await safe_edit_or_send_message(
                message=callback_query.message,
                new_text="Пожалуйста, сначала настройте ваш API ключ в разделе 'Настройки'.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
            return
    
        logger.info(f"Пользователь {callback_query.from_user.id} начал процесс получения номера.")
        keyboard = build_service_keyboard()
    
        await state.update_data(cancel_request=False, current_task=None)
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=(
                "Выберите сервис, нажав на кнопку ниже.\n"
                "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
            ),
            state=state,
            reply_markup=keyboard.as_markup()
        )
        await state.set_state(SmsOrderState.waiting_for_service)
    
    async def go_back_to_service_selection(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        logger.info(f"Пользователь {callback_query.from_user.id} отменил операцию.")
        
        await state.update_data(cancel_request=True)
    
        data = await state.get_data()
        current_task = data.get('current_task')
        if current_task:
            current_task.cancel()
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=(
                "Выберите сервис, нажав на кнопку ниже.\n"
                "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
            ),
            state=state,
            reply_markup=build_service_keyboard().as_markup()
        )
    
        await state.set_state(SmsOrderState.waiting_for_service)
    
    async def back_to_main_menu(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        logger.info(f"Пользователь {callback_query.from_user.id} вернулся в главное меню.")
    
        await state.set_state(None)
        await send_main_menu(callback_query.message, state)
    
    async def service_page_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        page_number = int(callback_query.data.split(":")[1])
        keyboard = build_service_keyboard(page_number)
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=(
                "Выберите сервис, нажав на кнопку ниже.\n"
                "Если вы хотите, вы также можете ввести полное название сервиса или хотя бы часть его названия, чтобы получить результаты поиска."
            ),
            state=state,
            reply_markup=keyboard.as_markup()
        )
    
    async def service_selected_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        service_code = callback_query.data.split(":")[1]
        update_service_popularity(service_code)
    
        await state.update_data(selected_service=service_code, cancel_request=False)
        task = asyncio.create_task(service_handler_logic(
            callback_query.message, state, user_id=callback_query.from_user.id, service_code=service_code, is_service_selection=True))
        await state.update_data(current_task=task)
    
    async def service_handler(message: types.Message, state: FSMContext, service_code: Optional[str] = None, user_id: Optional[int] = None):
        try:
            await message.delete()
        except Exception as e:
            logger.error(f"Не удалось удалить сообщение пользователя: {e}")
    
        user_input = message.text.strip().lower()
    
        if user_id is None:
            user_id = message.from_user.id
    
        logger.info(f"Пользователь {user_id} ввел сервис: {user_input}")
    
        service_code = next((code for code, name in SERVICE_DISPLAY_NAMES.items() if name.lower() == user_input or code.lower() == user_input), None)
    
        if service_code is None:
            matched_services = [(code, name) for code, name in SERVICE_DISPLAY_NAMES.items() if user_input in name.lower()]
    
            if matched_services:
                keyboard = InlineKeyboardBuilder()
                for code, name in matched_services:
                    keyboard.button(text=name, callback_data=f"service_select:{code}")
    
                keyboard.adjust(3)
                keyboard.button(text="🔙 Назад", callback_data="service_page:0")
                await safe_edit_or_send_message(
                    message=message,
                    new_text="Пожалуйста, выберите один из представленных сервисов:",
                    state=state,
                    reply_markup=keyboard.as_markup()
                )
                return
            else:
                keyboard = InlineKeyboardBuilder()
                keyboard.button(text="🔙 Назад к сервисам", callback_data="service_page:0")
                await safe_edit_or_send_message(
                    message=message,
                    new_text="Сервис не найден. Попробуйте ввести код или полное название сервиса.",
                    state=state,
                    reply_markup=keyboard.as_markup()
                )
                return
        else:
            await state.update_data(selected_service=service_code, cancel_request=False)
            task = asyncio.create_task(service_handler_logic(message, state, user_id=user_id, service_code=service_code))
            await state.update_data(current_task=task)
    
    async def service_handler_logic(message: types.Message, state: FSMContext, user_id: int, service_code: str, is_service_selection: bool = False):
        logger.info(f"Пользователь {user_id} выбрал сервис: {service_code}")
    
        user_api_key = get_user_api_key(user_id)
        user_operator = get_user_operator(user_id) or "any"
        user_country_code = get_user_country(user_id) or "0"
        country_name = COUNTRIES.get(user_country_code, user_country_code)
    
        if not user_api_key:
            await safe_edit_or_send_message(
                message=message,
                new_text="Пожалуйста, сначала настройте ваш API ключ в разделе 'Настройки'.",
                state=state
            )
            await state.set_state(None)
            await send_main_menu(message, state)
            return
    
        smshub_api = SmsHubAPI(user_api_key)
        usd_to_rub_rate = await get_usd_to_rub_rate()
    
        max_attempts = 3
        success = False
        last_exception = None
    
        try:
            for attempt in range(1, max_attempts + 1):
                data = await state.get_data()
                if data.get("cancel_request"):
                    logger.info(f"Запрос для пользователя {user_id} был отменен.")
                    return
    
                try:
                    progress_text = f"Идет запрос {attempt}/{max_attempts}..."
                    keyboard = InlineKeyboardBuilder()
                    keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
                    keyboard.adjust(1)
    
                    await safe_edit_or_send_message(
                        message=message,
                        new_text=progress_text,
                        state=state,
                        reply_markup=keyboard.as_markup()
                    )
    
                    price_info = await smshub_api.get_price_for_service(user_id, service_code)
                    numbers_status = await smshub_api.get_numbers_status(user_id, operator=user_operator)
    
                    if data.get("cancel_request"):
                        logger.info(f"Запрос для пользователя {user_id} был отменен после получения данных.")
                        return
    
                    if price_info and numbers_status:
                        service_key = f"{service_code}_0"
                        available_numbers = int(numbers_status.get(service_key, 0) or 0)
                        
                        if available_numbers > 0:
                            prices = [float(price_str) for price_str in price_info.keys() if price_str is not None]
                            if prices:
                                min_price_usd = min(prices)
                                max_price_usd = max(prices)
                                min_price_rub = min_price_usd * usd_to_rub_rate if usd_to_rub_rate else 0
                                max_price_rub = max_price_usd * usd_to_rub_rate if usd_to_rub_rate else 0
    
                                operator_display = OPERATOR_DISPLAY_NAMES.get(user_operator, user_operator)
                                service_display = SERVICE_DISPLAY_NAMES.get(service_code, service_code)
    
                                keyboard = InlineKeyboardBuilder()
                                keyboard.button(text=f"⬇️ Мин. цена ({min_price_usd:.4f}$)", callback_data=f"select_price:{min_price_usd}")
                                keyboard.button(text=f"⬆️ Макс. цена ({max_price_usd:.4f}$)", callback_data=f"select_price:{max_price_usd}")
                                keyboard.adjust(2)
                                keyboard.row(types.InlineKeyboardButton(text="❌ Отмена", callback_data="cancel_operation"))
    
                                message_text = (
                                    f"*Страна:* `{country_name}`\n"
                                    f"*Доступно номеров:* `{available_numbers}`\n"
                                    f"*Оператор:* `{operator_display}`\n"
                                    f"*Сервис:* `{service_display}`\n"
                                    f"*Цены:* от `{min_price_usd:.4f}` $ (₽{min_price_rub:.2f}) до `{max_price_usd:.4f}` $ (₽{max_price_rub:.2f}).\n\n"
                                    f"_Выберите максимальную допустимую стоимость покупки с помощью кнопок ниже или введите сумму вручную (например: 0.5). Все суммы указаны в долларах ($):_"
                                )
    
                                await safe_edit_or_send_message(
                                    message=message,
                                    new_text=message_text,
                                    state=state,
                                    reply_markup=keyboard.as_markup(),
                                    parse_mode="Markdown"
                                )
    
                                await state.update_data(
                                    service=service_code,
                                    service_display=service_display,
                                    country_name=country_name,
                                    available_numbers=available_numbers,
                                    operator_display=operator_display,
                                    min_price=min_price_usd,
                                    max_price_usd=max_price_usd,
                                    min_price_rub=min_price_rub,
                                    max_price_rub=max_price_rub,
                                    usd_to_rub_rate=usd_to_rub_rate,
                                    user_id=user_id
                                )
    
                                await state.set_state(SmsOrderState.waiting_for_max_price)
                                success = True
                                break
                            else:
                                logger.info(f"Попытка {attempt}: Цены не найдены.")
                                last_exception = "Цены не найдены"
                        else:
                            logger.info(f"Попытка {attempt}: Нет доступных номеров.")
                            last_exception = "Нет доступных номеров"
    
                except Exception as e:
                    logger.error(f"Ошибка при получении данных для сервиса '{service_code}', попытка {attempt}: {e}")
                    last_exception = e
    
                await asyncio.sleep(5)
    
        except asyncio.CancelledError:
            logger.info(f"Задача для пользователя {user_id} была отменена.")
            return
    
        if not success:
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="Назад", callback_data="service_page:0")
            await safe_edit_or_send_message(
                message=message,
                new_text=f"Произошла ошибка при обработке запроса: {last_exception}. Попробуйте снова.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
    
    async def price_selected_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        price = float(callback_query.data.split(":")[1])
        await state.update_data(max_price=price)
    
        await process_number_purchase(callback_query.message, state)
    
    async def max_price_handler(message: types.Message, state: FSMContext):
        max_price_input = message.text.strip()
        data = await state.get_data()
        user_id = data.get('user_id', message.from_user.id)
    
        try:
            await message.delete()
        except Exception as e:
            logger.error(f"Не удалось удалить сообщение пользователя: {e}")
    
        logger.info(f"Пользователь {user_id} указал максимальную стоимость: {max_price_input}")
    
        try:
            max_price = float(max_price_input)
        except ValueError:
            user_data = await state.get_data()
            min_price = user_data.get('min_price')
            max_price_usd = user_data.get('max_price_usd')
            min_price_rub = user_data.get('min_price_rub')
            max_price_rub = user_data.get('max_price_rub')
    
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
            keyboard.adjust(1)
            await safe_edit_or_send_message(
                message=message,
                new_text=(
                    f"Пожалуйста, введите корректное число для максимальной стоимости. "
                    f"От `{min_price:.4f}` $ (₽{min_price_rub:.2f}) до `{max_price_usd:.4f}` $ (₽{max_price_rub:.2f})."
                ),
                state=state,
                reply_markup=keyboard.as_markup(),
                parse_mode="Markdown"
            )
            return
    
        if max_price < data.get('min_price'):
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
            keyboard.adjust(1)
            await safe_edit_or_send_message(
                message=message,
                new_text=f"Максимальная стоимость должна быть не менее `{data.get('min_price'):.4f}` $.",
                state=state,
                reply_markup=keyboard.as_markup(),
                parse_mode="Markdown"
            )
            return
    
        await state.update_data(max_price=max_price)
    
        await process_number_purchase(message, state)
    
    async def process_number_purchase(message: types.Message, state: FSMContext):
        user_data = await state.get_data()
        user_id = user_data.get('user_id', message.from_user.id)
        service = user_data['service']
        service_display = user_data['service_display']
        country_name = user_data['country_name']
        operator_display = user_data['operator_display']
        max_price = user_data['max_price']
        user_api_key = get_user_api_key(user_id)
        smshub_api = SmsHubAPI(user_api_key)
    
        max_attempts = 3
        last_exception = None
    
        try:
            for attempt in range(1, max_attempts + 1):
                data = await state.get_data()
    
                if data.get("cancel_request"):
                    logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен.")
                    return
                
                progress_text = f"Идет запрос {attempt}/{max_attempts} на получение номера..."
                keyboard = InlineKeyboardBuilder()
                keyboard.button(text="❌ Отмена", callback_data="cancel_operation")
                keyboard.adjust(1)
    
                await safe_edit_or_send_message(
                    message=message,
                    new_text=progress_text,
                    state=state,
                    reply_markup=keyboard.as_markup()
                )
    
                user_operator = get_user_operator(user_id) or "any"
    
                if data.get("cancel_request"):
                    logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен перед выполнением.")
                    return
    
                result = await smshub_api.get_number(user_id, service, operator=user_operator, max_price=max_price)
    
                if data.get("cancel_request"):
                    logger.info(f"Запрос на получение номера для пользователя {user_id} был отменен.")
                    return
    
                if result and result.startswith("ACCESS_NUMBER"):
                    _, activation_id, number = result.split(":")
                    logger.info(f"Пользователь {user_id} получил номер: {number}, активация ID: {activation_id}")
    
                    if user_id not in user_activations:
                        user_activations[user_id] = {}
                    user_activations[user_id][activation_id] = {
                        'number': number,
                        'status': 'Ожидание SMS',
                        'service': service,
                        'service_display': service_display,
                        'country_name': country_name,
                        'last_update': time.time(),
                        'task': None
                    }
    
                    keyboard = InlineKeyboardBuilder()
                    keyboard.button(text="📂 Текущие активации", callback_data="current_activations")
                    keyboard.button(text="❌ Отменить активацию", callback_data=f"cancel_activation:{activation_id}")
                    keyboard.button(text="🔙 Главное меню", callback_data="back_to_main_menu")
                    keyboard.adjust(1)
    
                    message_text = (
                        f"*Получен номер:* `{number}`\n"
                        f"*Страна:* `{country_name}`\n"
                        f"*Оператор:* `{operator_display}`\n"
                        f"*Сервис:* `{service_display}`\n"
                        f"*Максимальная стоимость:* `{max_price:.2f}` $ (₽{max_price * user_data['usd_to_rub_rate']:.2f})\n"
                        f"*Статус:* *Ожидание SMS*\n"
                        f"Вы можете управлять активацией или вернуться в главное меню."
                    )
    
                    sent_message = await safe_edit_or_send_message(
                        message=message,
                        new_text=message_text,
                        state=state,
                        reply_markup=keyboard.as_markup(),
                        parse_mode="Markdown"
                    )
                    user_activations[user_id][activation_id]['message_id'] = sent_message.message_id
    
                    await state.set_state(None)
    
                    task = asyncio.create_task(poll_for_sms(
                        bot=message.bot,
                        user_id=user_id,
                        chat_id=message.chat.id,
                        activation_id=activation_id,
                        smshub_api=smshub_api
                    ))
                    user_activations[user_id][activation_id]['task'] = task
                    return
    
                elif result == "NO_NUMBERS":
                    logger.info(f"Попытка {attempt} из {max_attempts}: нет доступных номеров.")
                    last_exception = result
                    if attempt == max_attempts:
                        suggestion = (
                            "Попробуйте выбрать 'Любой оператор' в настройках или увеличить максимальную цену."
                            if user_operator != "any" else
                            "Попробуйте увеличить максимальную цену или повторите попытку позже."
                        )
                        keyboard = InlineKeyboardBuilder()
                        keyboard.button(text="Назад", callback_data="service_page:0")
                        await safe_edit_or_send_message(
                            message=message,
                            new_text=f"Нет доступных номеров для оператора {operator_display} по данной цене.\n{suggestion}",
                            state=state,
                            reply_markup=keyboard.as_markup()
                        )
                        return
                else:
                    raise Exception("Неожиданный ответ API")
    
                await asyncio.sleep(5)
    
        except asyncio.CancelledError:
            logger.info(f"Задача для пользователя {user_id} была отменена.")
            return
    
        if last_exception and last_exception != "NO_NUMBERS":
            keyboard = InlineKeyboardBuilder()
            keyboard.button(text="Назад", callback_data="service_page:0")
            await safe_edit_or_send_message(
                message=message,
                new_text=f"Произошла ошибка при обработке запроса: {last_exception}. Попробуйте снова.",
                state=state,
                reply_markup=keyboard.as_markup()
            )
    
    def register_sms_handlers(dp: Dispatcher):
        dp.callback_query.register(get_sms_handler, F.data == "get_sms")
        dp.callback_query.register(go_back_to_service_selection, F.data == "cancel_operation")
        dp.callback_query.register(back_to_main_menu, F.data == "back_to_main_menu")
        dp.callback_query.register(service_page_handler, F.data.startswith("service_page:"))
        dp.callback_query.register(service_selected_handler, F.data.startswith("service_select:"))
        dp.callback_query.register(price_selected_handler, F.data.startswith("select_price:"))
        dp.message.register(service_handler, SmsOrderState.waiting_for_service)
        dp.message.register(max_price_handler, SmsOrderState.waiting_for_max_price)
    

    Основные изменения:

    • Передача user_id в методы SmsHubAPI, такие как get_number, get_price_for_service и get_numbers_status, чтобы методы могли получать страну пользователя через get_user_country.
    • Вызов get_number, get_price_for_service и get_numbers_status теперь включает user_id как аргумент.

    Эти изменения гарантируют, что ваш бот будет учитывать предпочтения страны пользователя при выполнении операций.

  13. User

    так, отлтчно, и в настройки какие изменения?

    bot/handlers/settings.py

    import logging from aiogram import Dispatcher, types, F from aiogram.fsm.context import FSMContext from aiogram.utils.keyboard import InlineKeyboardBuilder from aiogram.fsm.state import State, StatesGroup import os

    from ..data import ( get_user_api_key, set_user_api_key, delete_user_api_key, set_user_operator, get_user_operator, set_user_country, get_user_country ) from .start import send_main_menu from ..api import SmsHubAPI from ..utils import get_usd_to_rub_rate, safe_edit_or_send_message from ..constants.operators import OPERATOR_DISPLAY_NAMES from ..constants.countries import COUNTRIES from ..constants.country_operator import COUNTRY_OPERATORS

    logger = logging.getLogger(name)

    class UserSettings(StatesGroup): entering_api_key = State()

    class OperatorSettings(StatesGroup): selecting_operator = State()

    class CountrySettings(StatesGroup): selecting_country = State()

    Обработчик основного меню настроек

    async def settings_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") await show_settings_menu(callback_query, state)

    Функция отображения меню настроек

    async def show_settings_menu(callback, state: FSMContext): user_id = callback.from_user.id if isinstance(callback, types.CallbackQuery) else callback.chat.id user_api_key = get_user_api_key(user_id) user_operator = get_user_operator(user_id) or "any" operator_display_name = OPERATOR_DISPLAY_NAMES.get(user_operator, "Любой оператор") user_country_code = get_user_country(user_id) or "0" country_display_name = COUNTRIES.get(user_country_code, user_country_code) flag_emoji = COUNTRIES.get(user_country_code, "").split()[-1]

    keyboard = InlineKeyboardBuilder()
    if user_api_key:
        keyboard.button(text="🗝️ Изменить API ключ", callback_data="edit_api_key")
        keyboard.button(text="❌ Удалить API ключ", callback_data="delete_api_key")
    else:
        keyboard.button(text="➕ Добавить API ключ", callback_data="add_api_key")
    
    keyboard.button(text="📡 Изменить оператора", callback_data="edit_operator")
    keyboard.button(text=f"{flag_emoji} Изменить страну", callback_data="edit_country")
    keyboard.button(text="🔙 Назад в меню", callback_data="back_to_main_menu")
    keyboard.adjust(1)
    
    message_text = (
        f"**Ваш текущий API ключ:** `{user_api_key}`\n" if user_api_key else "**API ключ не настроен.**\n"
    )
    message_text += f"**Текущий оператор:** `{operator_display_name}`\n"
    message_text += f"**Текущая страна:** `{country_display_name}`"
    
    sent_message = await safe_edit_or_send_message(
        message=callback.message if isinstance(callback, types.CallbackQuery) else callback,
        new_text=message_text,
        state=state,
        reply_markup=keyboard.as_markup(),
        parse_mode="Markdown"
    )
    
    if not sent_message:
        try:
            sent_message = await callback.bot.send_message(
                chat_id=user_id,
                text=message_text,
                reply_markup=keyboard.as_markup(),
                parse_mode="Markdown"
            )
            await state.update_data(prompt_message_id=sent_message.message_id)
        except Exception as e:
            logger.error(f"Не удалось отправить новое меню настроек: {e}")
    
    await state.set_state(None)
    

    Обработчик кнопки добавления/изменения API ключа

    async def input_api_key_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    keyboard = InlineKeyboardBuilder()
    keyboard.button(text="🔙 Назад", callback_data="cancel_settings")
    keyboard.adjust(1)
    
    prompt_text = (
        "Введите ваш API ключ для работы с сервисом:\n\n"
        "*Получение вашего API ключа*\n\n"
        "Чтобы начать использовать API, вам нужно получить ваш уникальный API ключ. Следуйте этим шагам:\n"
        "1. Перейдите по [ссылке на настройки SMSHUB](https://smshub.org/ru/settings).\n"
        "2. Найдите кнопку \"Сгенерировать новый ключ\" и нажмите на неё.\n"
        "3. Ваша почта, на которую был зарегистрирован аккаунт, получит сообщение с вашим новым API ключом.\n"
        "4. Скопируйте ключ из письма.\n\n"
        "*Ввод вашего API ключа*\n\n"
        "После получения ключа, вы можете ввести его в нашем боте. Для этого выполните следующие действия:\n"
        "1. Откройте интерфейс бота, выберите меню настроек.\n"
        "2. Нажмите на кнопку \"➕ Добавить API ключ\", чтобы начать процесс.\n"
        "3. Когда бот запросит, вставьте ваш API ключ в текстовое поле.\n"
        "4. Нажмите \"Отправить\".\n\n"
        "Ваш ключ будет проверен, и если он корректен, бот сохранит его для дальнейшего использования.\n\n"
        "*Информация о безопасности*\n\n"
        "Не забывайте, что ваш API ключ должен оставаться конфиденциальным. Никому не сообщайте его, чтобы избежать несанкционированного доступа к вашим данным и услугам."
    )
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=prompt_text,
        state=state,
        reply_markup=keyboard.as_markup(),
        parse_mode="Markdown",
        disable_web_page_preview=True
    )
    
    await state.set_state(UserSettings.entering_api_key)
    

    Обработчик удаления API ключа

    async def delete_user_api_key_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") logger.info(f"Пользователь {callback_query.from_user.id} запросил удаление API ключа.")

    delete_user_api_key(callback_query.from_user.id)
    await show_settings_menu(callback_query, state)  # Обновление меню настроек
    

    Обработчик возврата в главное меню

    async def back_to_main_menu_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    await state.set_state(None)
    
    # Редактируем текущее сообщение для отображения главного меню
    await send_main_menu(callback_query.message, state)
    

    Обработчик отмены действий, возвращает в меню настроек

    async def cancel_settings_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    await state.set_state(None)
    await show_settings_menu(callback_query, state)
    

    Обработчик ввода API ключа пользователем

    async def set_user_api_key_handler(message: types.Message, state: FSMContext): user_api_key = message.text.strip() logger.info(f"Пользователь {message.from_user.id} ввёл API ключ.")

    try:
        await message.delete()
    except Exception as e:
        logger.warning(f"Не удалось удалить сообщение пользователя: {e}")
    
    smshub_api = SmsHubAPI(user_api_key)
    try:
        balance_response = await smshub_api.get_balance()
        if balance_response and balance_response.startswith("ACCESS_BALANCE:"):
            balance = balance_response.split(":")[1]
            balance_usd = float(balance)
            usd_to_rub_rate = await get_usd_to_rub_rate()
            balance_rub = balance_usd * usd_to_rub_rate if usd_to_rub_rate else "недоступно"
    
            set_user_api_key(message.from_user.id, user_api_key)
    
            # Обновление меню настроек после успешного добавления API ключа
            await show_settings_menu(message, state)
        else:
            error_text = "Неверный API ключ. Пожалуйста, попробуйте снова или отмените операцию."
            await safe_edit_or_send_message(
                message=message,
                new_text=error_text,
                state=state,
                parse_mode="Markdown",
                reply_markup=get_back_button_to_settings_markup()
            )
    except Exception as e:
        logger.error(f"Ошибка при проверке API ключа: {e}")
        error_text = "Произошла ошибка при проверке ключа. Пожалуйста, попробуйте снова."
        await safe_edit_or_send_message(
            message=message,
            new_text=error_text,
            state=state,
            parse_mode="Markdown",
            reply_markup=get_back_button_to_settings_markup()
        )
    

    def get_back_button_to_settings_markup(): """Создаёт клавиатуру с кнопкой 'Назад' в меню настроек.""" keyboard = InlineKeyboardBuilder() keyboard.button(text="🔙 Назад", callback_data="cancel_settings") keyboard.adjust(1) return keyboard.as_markup()

    Обработчики для выбора оператора

    async def select_operator_handler(callback_query: types.CallbackQuery, state: FSMContext, page: int = 0): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    data = await state.get_data()
    user_country_code = data.get('selected_country_code', '0')
    
    operator_list = COUNTRY_OPERATORS.get(user_country_code, [])
    
    if "any" not in operator_list:
        operator_list.insert(0, "any")
    
    items_per_page = 10
    
    start = page * items_per_page
    end = start + items_per_page
    
    keyboard = InlineKeyboardBuilder()
    
    for op in operator_list[start:end]:
        display_name = OPERATOR_DISPLAY_NAMES.get(op, op)
        keyboard.button(text=display_name, callback_data=f"operator:{op}")
    
    keyboard.adjust(2)
    
    nav_buttons = []
    if page > 0:
        nav_buttons.append(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"operator_page:{page - 1}"))
    if end < len(operator_list):
        nav_buttons.append(types.InlineKeyboardButton(text="➡️ Вперёд", callback_data=f"operator_page:{page + 1}"))
    
    if nav_buttons:
        keyboard.row(*nav_buttons)
    
    keyboard.row(types.InlineKeyboardButton(text="🔙 Назад", callback_data="cancel_operator_selection"))
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text="Выберите оператора из списка:",
        state=state,
        reply_markup=keyboard.as_markup()
    )
    await state.set_state(OperatorSettings.selecting_operator)
    

    Обработчик навигации по страницам операторов

    async def operator_page_handler(callback_query: types.CallbackQuery, state: FSMContext): page = int(callback_query.data.split(':')[1]) await select_operator_handler(callback_query, state, page)

    Обработчик отмены выбора оператора

    async def cancel_operator_selection_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") await state.set_state(None) await show_settings_menu(callback_query, state)

    Обработчик выбора оператора

    async def operator_selected_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") operator = callback_query.data.split(":")[1] set_user_operator(callback_query.from_user.id, operator) display_name = OPERATOR_DISPLAY_NAMES.get(operator, operator) await safe_edit_or_send_message( message=callback_query.message, new_text=f"Вы выбрали оператора: {display_name}", state=state ) await state.set_state(None) await show_settings_menu(callback_query, state)

    Обработчики для выбора страны

    async def select_country_handler(callback_query: types.CallbackQuery, state: FSMContext, page: int = 0): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    countries_list = list(COUNTRIES.items())
    items_per_page = 10
    
    start = page * items_per_page
    end = start + items_per_page
    
    keyboard = InlineKeyboardBuilder()
    
    for country_code, country_name in countries_list[start:end]:
        keyboard.button(text=country_name, callback_data=f"country:{country_code}")
    
    keyboard.adjust(2)
    
    nav_buttons = []
    if page > 0:
        nav_buttons.append(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"country_page:{page - 1}"))
    if end < len(countries_list):
        nav_buttons.append(types.InlineKeyboardButton(text="➡️ Вперёд", callback_data=f"country_page:{page + 1}"))
    
    if nav_buttons:
        keyboard.row(*nav_buttons)
    
    keyboard.row(types.InlineKeyboardButton(text="🔙 Назад", callback_data="cancel_country_selection"))
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text="Выберите страну из списка:",
        state=state,
        reply_markup=keyboard.as_markup()
    )
    await state.set_state(CountrySettings.selecting_country)
    

    Обработчик навигации по страницам стран

    async def country_page_handler(callback_query: types.CallbackQuery, state: FSMContext): page = int(callback_query.data.split(':')[1]) await select_country_handler(callback_query, state, page)

    Обработчик отмены выбора страны

    async def cancel_country_selection_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}") await state.set_state(None) await show_settings_menu(callback_query, state)

    Обработчик выбора страны

    async def country_selected_handler(callback_query: types.CallbackQuery, state: FSMContext): try: await callback_query.answer() except Exception as e: logger.warning(f"Не удалось ответить на callback_query: {e}")

    country_code = callback_query.data.split(":")[1]
    set_user_country(callback_query.from_user.id, country_code)
    country_name = COUNTRIES.get(country_code, country_code)
    
    await state.update_data(selected_country_code=country_code)
    
    current_operator = get_user_operator(callback_query.from_user.id) or "any"
    available_operators = COUNTRY_OPERATORS.get(country_code, [])
    
    if current_operator not in available_operators:
        set_user_operator(callback_query.from_user.id, "any")
    
    await safe_edit_or_send_message(
        message=callback_query.message,
        new_text=f"Вы выбрали страну: {country_name}",
        state=state
    )
    await state.set_state(None)
    await show_settings_menu(callback_query, state)
    

    Регистрация всех обработчиков в диспетчере

    def register_settings_handlers(dp: Dispatcher): dp.callback_query.register(settings_handler, F.data == "settings") dp.callback_query.register(input_api_key_handler, F.data.in_({"edit_api_key", "add_api_key"})) dp.callback_query.register(delete_user_api_key_handler, F.data == "delete_api_key") dp.callback_query.register(back_to_main_menu_handler, F.data == "back_to_main_menu") dp.callback_query.register(cancel_settings_handler, F.data == "cancel_settings") dp.message.register(set_user_api_key_handler, UserSettings.entering_api_key) dp.callback_query.register(select_operator_handler, F.data == "edit_operator") dp.callback_query.register(cancel_operator_selection_handler, F.data == "cancel_operator_selection") dp.callback_query.register(operator_selected_handler, OperatorSettings.selecting_operator, F.data.startswith("operator:")) dp.callback_query.register(operator_page_handler, OperatorSettings.selecting_operator, F.data.startswith("operator_page:")) dp.callback_query.register(select_country_handler, F.data == "edit_country") dp.callback_query.register(country_selected_handler, CountrySettings.selecting_country, F.data.startswith("country:")) dp.callback_query.register(cancel_country_selection_handler, F.data == "cancel_country_selection") dp.callback_query.register(country_page_handler, CountrySettings.selecting_country, F.data.startswith("country_page:"))

  14. Assistant

    В вашем файле bot/handlers/settings.py будем вносить исправления, связанные с выбором страны и оператора, а также обновим логику, где пользователь может выбрать свою страну. Изменения минимальны, так как основная часть инфраструктуры уже сделана, но я покажу, как переоформить ваш код, чтобы все работало согласованно.

    Вот как должен выглядеть обновленный файл:

    import logging
    from aiogram import Dispatcher, types, F
    from aiogram.fsm.context import FSMContext
    from aiogram.utils.keyboard import InlineKeyboardBuilder
    from aiogram.fsm.state import State, StatesGroup
    
    from ..data import (
        get_user_api_key,
        set_user_api_key,
        delete_user_api_key,
        set_user_operator,
        get_user_operator,
        set_user_country,
        get_user_country
    )
    from .start import send_main_menu
    from ..api import SmsHubAPI
    from ..utils import get_usd_to_rub_rate, safe_edit_or_send_message
    from ..constants.operators import OPERATOR_DISPLAY_NAMES
    from ..constants.countries import COUNTRIES
    from ..constants.country_operator import COUNTRY_OPERATORS
    
    logger = logging.getLogger(__name__)
    
    class UserSettings(StatesGroup):
        entering_api_key = State()
    
    class OperatorSettings(StatesGroup):
        selecting_operator = State()
    
    class CountrySettings(StatesGroup):
        selecting_country = State()
    
    async def settings_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        await show_settings_menu(callback_query, state)
    
    async def show_settings_menu(callback, state: FSMContext):
        user_id = callback.from_user.id if isinstance(callback, types.CallbackQuery) else callback.chat.id
        user_api_key = get_user_api_key(user_id)
        user_operator = get_user_operator(user_id) or "any"
        operator_display_name = OPERATOR_DISPLAY_NAMES.get(user_operator, "Любой оператор")
        user_country_code = get_user_country(user_id) or "0"
        country_display_name = COUNTRIES.get(user_country_code, user_country_code)
        flag_emoji = COUNTRIES.get(user_country_code, "").split()[-1]
    
        keyboard = InlineKeyboardBuilder()
        if user_api_key:
            keyboard.button(text="🗝️ Изменить API ключ", callback_data="edit_api_key")
            keyboard.button(text="❌ Удалить API ключ", callback_data="delete_api_key")
        else:
            keyboard.button(text="➕ Добавить API ключ", callback_data="add_api_key")
    
        keyboard.button(text="📡 Изменить оператора", callback_data="edit_operator")
        keyboard.button(text=f"{flag_emoji} Изменить страну", callback_data="edit_country")
        keyboard.button(text="🔙 Назад в меню", callback_data="back_to_main_menu")
        keyboard.adjust(1)
    
        message_text = (
            f"**Ваш текущий API ключ:** `{user_api_key}`\n" if user_api_key else "**API ключ не настроен.**\n"
        )
        message_text += f"**Текущий оператор:** `{operator_display_name}`\n"
        message_text += f"**Текущая страна:** `{country_display_name}`"
    
        sent_message = await safe_edit_or_send_message(
            message=callback.message if isinstance(callback, types.CallbackQuery) else callback,
            new_text=message_text,
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown"
        )
    
        if not sent_message:
            try:
                sent_message = await callback.bot.send_message(
                    chat_id=user_id,
                    text=message_text,
                    reply_markup=keyboard.as_markup(),
                    parse_mode="Markdown"
                )
                await state.update_data(prompt_message_id=sent_message.message_id)
            except Exception as e:
                logger.error(f"Не удалось отправить новое меню настроек: {e}")
    
        await state.set_state(None)
    
    async def input_api_key_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="🔙 Назад", callback_data="cancel_settings")
        keyboard.adjust(1)
    
        prompt_text = (
            "Введите ваш API ключ для работы с сервисом:\n\n"
            "*Получение вашего API ключа*\n\n"
            "Чтобы начать использовать API, вам нужно получить ваш уникальный API ключ. Следуйте этим шагам:\n"
            "1. Перейдите по [ссылке на настройки SMSHUB](https://smshub.org/ru/settings).\n"
            "2. Найдите кнопку \"Сгенерировать новый ключ\" и нажмите на неё.\n"
            "3. Ваша почта, на которую был зарегистрирован аккаунт, получит сообщение с вашим новым API ключом.\n"
            "4. Скопируйте ключ из письма.\n\n"
            "*Ввод вашего API ключа*\n\n"
            "После получения ключа, вы можете ввести его в нашем боте. Для этого выполните следующие действия:\n"
            "1. Откройте интерфейс бота, выберите меню настроек.\n"
            "2. Нажмите на кнопку \"➕ Добавить API ключ\", чтобы начать процесс.\n"
            "3. Когда бот запросит, вставьте ваш API ключ в текстовое поле.\n"
            "4. Нажмите \"Отправить\".\n\n"
            "Ваш ключ будет проверен, и если он корректен, бот сохранит его для дальнейшего использования.\n\n"
            "*Информация о безопасности*\n\n"
            "Не забывайте, что ваш API ключ должен оставаться конфиденциальным. Никому не сообщайте его, чтобы избежать несанкционированного доступа к вашим данным и услугам."
        )
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=prompt_text,
            state=state,
            reply_markup=keyboard.as_markup(),
            parse_mode="Markdown",
            disable_web_page_preview=True
        )
    
        await state.set_state(UserSettings.entering_api_key)
    
    async def delete_user_api_key_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        logger.info(f"Пользователь {callback_query.from_user.id} запросил удаление API ключа.")
        
        delete_user_api_key(callback_query.from_user.id)
        await show_settings_menu(callback_query, state)
    
    async def back_to_main_menu_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        await state.set_state(None)
        await send_main_menu(callback_query.message, state)
    
    async def cancel_settings_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        await state.set_state(None)
        await show_settings_menu(callback_query, state)
    
    async def set_user_api_key_handler(message: types.Message, state: FSMContext):
        user_api_key = message.text.strip()
        logger.info(f"Пользователь {message.from_user.id} ввёл API ключ.")
    
        try:
            await message.delete()
        except Exception as e:
            logger.warning(f"Не удалось удалить сообщение пользователя: {e}")
    
        smshub_api = SmsHubAPI(user_api_key)
        try:
            balance_response = await smshub_api.get_balance()
            if balance_response and balance_response.startswith("ACCESS_BALANCE:"):
                balance = balance_response.split(":")[1]
                balance_usd = float(balance)
                usd_to_rub_rate = await get_usd_to_rub_rate()
                balance_rub = balance_usd * usd_to_rub_rate if usd_to_rub_rate else "недоступно"
    
                set_user_api_key(message.from_user.id, user_api_key)
                await show_settings_menu(message, state)
            else:
                error_text = "Неверный API ключ. Пожалуйста, попробуйте снова или отмените операцию."
                await safe_edit_or_send_message(
                    message=message,
                    new_text=error_text,
                    state=state,
                    parse_mode="Markdown",
                    reply_markup=get_back_button_to_settings_markup()
                )
        except Exception as e:
            logger.error(f"Ошибка при проверке API ключа: {e}")
            error_text = "Произошла ошибка при проверке ключа. Пожалуйста, попробуйте снова."
            await safe_edit_or_send_message(
                message=message,
                new_text=error_text,
                state=state,
                parse_mode="Markdown",
                reply_markup=get_back_button_to_settings_markup()
            )
    
    def get_back_button_to_settings_markup():
        keyboard = InlineKeyboardBuilder()
        keyboard.button(text="🔙 Назад", callback_data="cancel_settings")
        keyboard.adjust(1)
        return keyboard.as_markup()
    
    async def select_operator_handler(callback_query: types.CallbackQuery, state: FSMContext, page: int = 0):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        
        data = await state.get_data()
        user_country_code = data.get('selected_country_code', '0')
        operator_list = COUNTRY_OPERATORS.get(user_country_code, [])
    
        if "any" not in operator_list:
            operator_list.insert(0, "any")
    
        items_per_page = 10
        start = page * items_per_page
        end = start + items_per_page
    
        keyboard = InlineKeyboardBuilder()
        for op in operator_list[start:end]:
            display_name = OPERATOR_DISPLAY_NAMES.get(op, op)
            keyboard.button(text=display_name, callback_data=f"operator:{op}")
    
        keyboard.adjust(2)
    
        nav_buttons = []
        if page > 0:
            nav_buttons.append(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"operator_page:{page - 1}"))
        if end < len(operator_list):
            nav_buttons.append(types.InlineKeyboardButton(text="➡️ Вперёд", callback_data=f"operator_page:{page + 1}"))
    
        if nav_buttons:
            keyboard.row(*nav_buttons)
    
        keyboard.row(types.InlineKeyboardButton(text="🔙 Назад", callback_data="cancel_operator_selection"))
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Выберите оператора из списка:",
            state=state,
            reply_markup=keyboard.as_markup()
        )
        await state.set_state(OperatorSettings.selecting_operator)
    
    async def operator_page_handler(callback_query: types.CallbackQuery, state: FSMContext):
        page = int(callback_query.data.split(':')[1])
        await select_operator_handler(callback_query, state, page)
    
    async def cancel_operator_selection_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        await state.set_state(None)
        await show_settings_menu(callback_query, state)
    
    async def operator_selected_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        operator = callback_query.data.split(":")[1]
        set_user_operator(callback_query.from_user.id, operator)
        display_name = OPERATOR_DISPLAY_NAMES.get(operator, operator)
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=f"Вы выбрали оператора: {display_name}",
            state=state
        )
        await state.set_state(None)
        await show_settings_menu(callback_query, state)
    
    async def select_country_handler(callback_query: types.CallbackQuery, state: FSMContext, page: int = 0):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        countries_list = list(COUNTRIES.items())
        items_per_page = 10
    
        start = page * items_per_page
        end = start + items_per_page
    
        keyboard = InlineKeyboardBuilder()
        for country_code, country_name in countries_list[start:end]:
            keyboard.button(text=country_name, callback_data=f"country:{country_code}")
    
        keyboard.adjust(2)
    
        nav_buttons = []
        if page > 0:
            nav_buttons.append(types.InlineKeyboardButton(text="⬅️ Назад", callback_data=f"country_page:{page - 1}"))
        if end < len(countries_list):
            nav_buttons.append(types.InlineKeyboardButton(text="➡️ Вперёд", callback_data=f"country_page:{page + 1}"))
    
        if nav_buttons:
            keyboard.row(*nav_buttons)
    
        keyboard.row(types.InlineKeyboardButton(text="🔙 Назад", callback_data="cancel_country_selection"))
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text="Выберите страну из списка:",
            state=state,
            reply_markup=keyboard.as_markup()
        )
        await state.set_state(CountrySettings.selecting_country)
    
    async def country_page_handler(callback_query: types.CallbackQuery, state: FSMContext):
        page = int(callback_query.data.split(':')[1])
        await select_country_handler(callback_query, state, page)
    
    async def cancel_country_selection_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
        await state.set_state(None)
        await show_settings_menu(callback_query, state)
    
    async def country_selected_handler(callback_query: types.CallbackQuery, state: FSMContext):
        try:
            await callback_query.answer()
        except Exception as e:
            logger.warning(f"Не удалось ответить на callback_query: {e}")
    
        country_code = callback_query.data.split(":")[1]
        set_user_country(callback_query.from_user.id, country_code)
        country_name = COUNTRIES.get(country_code, country_code)
    
        await state.update_data(selected_country_code=country_code)
    
        current_operator = get_user_operator(callback_query.from_user.id) or "any"
        available_operators = COUNTRY_OPERATORS.get(country_code, [])
    
        if current_operator not in available_operators:
            set_user_operator(callback_query.from_user.id, "any")
    
        await safe_edit_or_send_message(
            message=callback_query.message,
            new_text=f"Вы выбрали страну: {country_name}",
            state=state
        )
        await state.set_state(None)
        await show_settings_menu(callback_query, state)
    
    def register_settings_handlers(dp: Dispatcher):
        dp.callback_query.register(settings_handler, F.data == "settings")
        dp.callback_query.register(input_api_key_handler, F.data.in_({"edit_api_key", "add_api_key"}))
        dp.callback_query.register(delete_user_api_key_handler, F.data == "delete_api_key")
        dp.callback_query.register(back_to_main_menu_handler, F.data == "back_to_main_menu")
        dp.callback_query.register(cancel_settings_handler, F.data == "cancel_settings")
        dp.message.register(set_user_api_key_handler, UserSettings.entering_api_key)
        dp.callback_query.register(select_operator_handler, F.data == "edit_operator")
        dp.callback_query.register(cancel_operator_selection_handler, F.data == "cancel_operator_selection")
        dp.callback_query.register(operator_selected_handler, OperatorSettings.selecting_operator, F.data.startswith("operator:"))
        dp.callback_query.register(operator_page_handler, OperatorSettings.selecting_operator, F.data.startswith("operator_page:"))
        dp.callback_query.register(select_country_handler, F.data == "edit_country")
        dp.callback_query.register(country_selected_handler, CountrySettings.selecting_country, F.data.startswith("country:"))
        dp.callback_query.register(cancel_country_selection_handler, F.data == "cancel_country_selection")
        dp.callback_query.register(country_page_handler, CountrySettings.selecting_country, F.data.startswith("country_page:"))
    

    Изменения:

    • В функциях регистрации и обработки выбора страны и оператора теперь используется set_user_country и set_user_operator, чтобы обновить информацию о пользователе.
    • Логика выбора доступных операторов теперь завязана на выбранный пользователем код страны.
    • Оформление кода более аккуратное, чтобы все функции выполняли свои задачи последовательно и обеспечивали хорошее взаимодействие с пользователем.
  15. User

    Oct 31 07:11:12 vps1707806210 systemd[1]: Started My SMS Bot Service. Oct 31 07:11:16 vps1707806210 python[8239]: Traceback (most recent call last): Oct 31 07:11:16 vps1707806210 python[8239]: File "/root/sms/main.py", line 8, in Oct 31 07:11:16 vps1707806210 python[8239]: from bot.handlers import register_handlers Oct 31 07:11:16 vps1707806210 python[8239]: File "/root/sms/bot/handlers/init.py", line 6, in Oct 31 07:11:16 vps1707806210 python[8239]: from .settings import register_settings_handlers Oct 31 07:11:16 vps1707806210 python[8239]: File "/root/sms/bot/handlers/settings.py", line 17, in Oct 31 07:11:16 vps1707806210 python[8239]: from ..api import SmsHubAPI Oct 31 07:11:16 vps1707806210 python[8239]: File "/root/sms/bot/api.py", line 7, in Oct 31 07:11:16 vps1707806210 python[8239]: from ..data import get_user_country Oct 31 07:11:16 vps1707806210 python[8239]: ImportError: attempted relative import beyond top-level package Oct 31 07:11:16 vps1707806210 systemd[1]: my_smsbot.service: Main process exited, code=exited, status=1/FAILURE Oct 31 07:11:16 vps1707806210 systemd[1]: my_smsbot.service: Failed with result 'exit-code'. Oct 31 07:11:16 vps1707806210 systemd[1]: my_smsbot.service: Consumed 4.546s CPU time. Oct 31 07:11:16 vps1707806210 systemd[1]: my_smsbot.service: Scheduled restart job, restart counter is at 4. Oct 31 07:11:16 vps1707806210 systemd[1]: Stopped My SMS Bot Service. Oct 31 07:11:16 vps1707806210 systemd[1]: my_smsbot.service: Consumed 4.546s CPU time. Oct 31 07:11:16 vps1707806210 systemd[1]: Started My SMS Bot Service.

  16. Assistant

    Ошибка ImportError: attempted relative import beyond top-level package указывает на проблему с импортом в вашей программе. Это может произойти, когда вы используете относительные импорты (..) за пределами допустимых ограничений в вашей структуре модулей.

    Как исправить:

    1. Использование Абсолютных Импортов:

      Если ваша структура проекта следующая:

      sms/
        ├── main.py
        └── bot/
            ├── api.py
            └── handlers/
                ├── __init__.py
                └── settings.py
      

      То вместо использования относительных импортов (from ..data import get_user_country), вы можете использовать абсолютные пути:

      from bot.data import get_user_country
      

      Так будет легче избежать ошибок в пути, особенно если ваш скрипт запускается из корневой директории проекта.

    2. Настройка PYTHONPATH:

      Если вы хотите использовать относительные пути и всё-таки ваш файл main.py запускается как самостоятельный скрипт, убедитесь, что PYTHONPATH настроен правильно. Это делается командой в терминале перед запуском вашего скрипта:

      export PYTHONPATH=/root/sms
      python /root/sms/main.py
      

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

    3. Запуск из модульного контекста:

      Если вы запускаете скрипт напрямую, попробуйте изменить метод запуска с использованием параметра -m:

      python -m sms.main
      

      Это поможет Python правильно настроить пути.

    Рекомендация:

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

  17. User

    файл data.json у меня находится по пути: /bot/data.json

  18. Assistant

    Если ваш data.json находится по указанному пути и вы планируете его использовать в вашем Python-коде, вам нужно правильно загрузить и обработать этот файл. Я покажу вам, как это можно сделать.

    Предположим, что структура вашего проекта выглядит следующим образом:

    sms/
      ├── bot/
      │   ├── api.py
      │   ├── handlers/
      │   ├── data.json
      └── main.py
    

    Пример кода

    1. Загрузка JSON файла:

      Убедитесь, что у вас есть подходящий код для чтения data.json и обработки его содержимого. Ниже приведён пример функции, которая читает данные из data.json.

      import json
      from pathlib import Path
      
      # Define the path to your JSON file relative to this script
      file_path = Path(__file__).parent / 'data.json'
      
      def load_data():
          """Load JSON data from a file."""
          try:
              with open(file_path, 'r', encoding='utf-8') as file:
                  data = json.load(file)
                  return data
          except FileNotFoundError:
              print(f"File {file_path} not found.")
              return None
          except json.JSONDecodeError as e:
              print(f"Error decoding JSON: {e}")
              return None
      
      # Example usage
      data = load_data()
      if data:
          print("Successfully loaded data from JSON file.")
      else:
          print("Failed to load data.")
      
    2. Использование данных:

      После загрузки JSON, данные можно использовать в других частях вашего кода. Рекомендуется абстрагировать операцию чтения в отдельную функцию, чтобы её можно было вызвать откуда угодно в вашем приложении.

    3. Изменяемость пути:

      Убедитесь, что путь к файлу корректен. Вы можете использовать Path из pathlib, как показано выше, чтобы избежать ошибок, связанных с путями.

    Советы:

    • Если вы планируете часто использовать данные из JSON-файла, возможно, имеет смысл загрузить его один раз в начале работы программы и затем просто передавать нужные данные туда, где они требуются.
    • Имейте в виду, что любые изменения в data.json после загрузки данных не будут автоматически обновляться в вашем приложении, если вы не реализуете механизмы перезагрузки данных.

    Убедитесь, что данные в JSON корректны и соответствуют структуре, ожидаемой вашим приложением.