Отказался от w2n.

main.py

@@ -4,12 +4,8 @@ import asyncio
 import yaml
 
 import hashlib
-import aiohttp
 
 import json
-import re
-
-from word2number import w2n
 from function.convert import Converter
 from function.format_number import format_number
 
@@ -18,124 +14,84 @@ dp = Dispatcher()
 
 
 @dp.message()
-async def message_conv(message: types.Message):
+@dp.inline_query()
-    with open('currency.json', 'r', encoding='utf-8') as f:
+async def currency(query: types.Message | types.InlineQuery) -> None:
-        currency_json = json.load(f)
+    global result
 
-    text = message.text.lower()
+    try:
+        currency_json = json.load(open('currency.json', 'r', encoding='utf-8'))
+        text = query.query if isinstance(query, types.InlineQuery) else query.text
         args = text.split()
+        result_id = hashlib.md5(text.encode()).hexdigest()
+        conv = Converter()
 
-    number_match = re.match(r'\d+\.?\d*|\w+', args[0])
+        if len(args) <= 1:
-    if number_match:
+            return await reply(result_id,
-        number_text = number_match.group(0)
+                               "2 or 3 arguments are required.",
-
+                               "@shirino_bot USD RUB "
-        try:
+                               "\n@shirino_bot 12 USD RUB",
-            amount = float(number_text)
+                               query)
-        except ValueError:
-            try:
-                amount = float(w2n.word_to_num(number_text))
-            except ValueError:
-                await message.reply("Не удалось распознать числовое значение.")
-                return
-    else:
-        await message.reply("Не удалось найти числовое значение.")
-        return
-
         if len(args) == 4:
-        source_currency_alias = args[1]
+            conv.amount = float(args[0])
-        target_currency_alias = args[3]
+            from_currency_alias = args[1].lower()
+            conv_currency_alias = args[3].lower()
         elif len(args) == 3:
-        source_currency_alias = args[0]
+            conv.amount = float(args[0])
-        target_currency_alias = args[2]
+            from_currency_alias = args[1].lower()
+            conv_currency_alias = args[2].lower()
+        elif len(args) == 2:
+            from_currency_alias = args[0].lower()
+            conv_currency_alias = args[1].lower()
         else:
-        await message.reply("Не удалось определить исходную и целевую валюту.")
+            return await reply(result_id, 'The source and target currency could not be determined.', None, query)
-        return
 
-    source_currency_code = None
+        from_currency, conv_currency = None, None
-    target_currency_code = None
 
         for currency_code, aliases in currency_json.items():
-        if source_currency_alias in aliases:
+            if from_currency_alias in aliases:
-            source_currency_code = currency_code
+                from_currency = currency_code
-        if target_currency_alias in aliases:
+            if conv_currency_alias in aliases:
-            target_currency_code = currency_code
+                conv_currency = currency_code
 
-    if not source_currency_code or not target_currency_code or amount is None:
+            if from_currency and conv_currency:
-        await message.reply("Не удалось найти сумму или валюты по указанным данным.")
+                break
-        return
 
-    conv = Converter()
+        if not from_currency or not conv_currency:
-    conv.amount = amount
+            return await reply(result_id,
-    conv.from_currency = source_currency_code.upper()
+                               'The currency exchange rate could not be found.',
-    conv.conv_currency = target_currency_code.upper()
+                               None,
+                               query)
+
+        conv.from_currency = from_currency.upper()
+        conv.conv_currency = conv_currency.upper()
         conv.convert()
 
         result = f'{format_number(conv.amount)} {conv.from_currency} = {conv.conv_amount} {conv.conv_currency}'
-    await message.reply(result)
+        return await reply(result_id, result, None, query)
+
+    except Exception as e:
+        print(e)
 
 
-async def inline_reply(result_id: str, title: str, description: str or None, inline_query: types.InlineQuery) -> None:
+async def reply(result_id: str | None, title: str | None, desc, query: types.InlineQuery | types.Message) -> None:
+    if isinstance(query, types.InlineQuery):
         article = [None]
         article[0] = types.InlineQueryResultArticle(
             id=result_id,
             title=title,
-        description=description,
+            description=desc,
             input_message_content=types.InputTextMessageContent(
                 message_text=title
             )
         )
 
-    await inline_query.answer(
+        await query.answer(
             article,
             cache_time=1,
             is_personal=True,
         )
-
+    else:
-
+        await query.answer(title)
-@dp.inline_query()
-async def currency(inline_query: types.InlineQuery) -> None:
-    global result
-    query = inline_query.query
-    args = query.split()
-
-    result_id = hashlib.md5(query.encode()).hexdigest()
-    conv = Converter()
-
-    try:
-        if len(args) <= 1:
-            await inline_reply(result_id,
-                               "2 or 3 arguments are required",
-                               f"@shirino_bot USD RUB \n@shirino_bot 12 USD RUB", inline_query)
-
-        if len(args) == 3:
-            conv.amount = float(args[0].replace(',', '.'))
-            conv.from_currency = args[1].upper()
-            conv.conv_currency = args[2].upper()
-            conv.convert()
-        elif len(args) == 2:
-            conv.from_currency = args[0].upper()
-            conv.conv_currency = args[1].upper()
-            conv.convert()
-
-        result = (
-            f'{format_number(conv.amount)} {conv.from_currency} = '
-            f'{conv.conv_amount} {conv.conv_currency}'
-        )
-
-    except aiohttp.client_exceptions.ClientError:
-        await inline_reply(result_id,
-                           "Rate-limit from the Telegram API, repeat the request later",
-                           None,
-                           inline_query)
-
-        await asyncio.sleep(1)
-
-    except Exception:
-        await inline_reply(result_id, "Invalid data format",
-                           "@shirino_bot USD RUB \n@shirino_bot 12 USD RUB",
-                           inline_query)
-
-    await inline_reply(result_id, result, None, inline_query)
 
 
 async def main() -> None:

requirements.txt

@@ -2,4 +2,3 @@ aiohttp~=3.9.5
 requests~=2.32.3
 PyYAML~=6.0.1
 aiogram~=3.7.0
-word2number~=1.1